1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
// GENERATED CONTENT - DO NOT EDIT
// Content was automatically extracted by Reffy into webref
// (https://github.com/w3c/webref)
// Source: WebTransport (https://w3c.github.io/webtransport/)
[Exposed=(Window,Worker), SecureContext, Transferable]
interface WebTransportDatagramsWritable : WritableStream {
attribute WebTransportSendGroup? sendGroup;
attribute long long sendOrder;
};
[Exposed=(Window,Worker), SecureContext]
interface WebTransportDatagramDuplexStream {
WebTransportDatagramsWritable createWritable(
optional WebTransportSendOptions options = {});
readonly attribute ReadableStream readable;
readonly attribute unsigned long maxDatagramSize;
attribute unrestricted double? incomingMaxAge;
attribute unrestricted double? outgoingMaxAge;
attribute unrestricted double incomingHighWaterMark;
attribute unrestricted double outgoingHighWaterMark;
};
[Exposed=(Window,Worker), SecureContext]
interface WebTransport {
constructor(USVString url, optional WebTransportOptions options = {});
Promise<WebTransportConnectionStats> getStats();
[NewObject] Promise<ArrayBuffer> exportKeyingMaterial(BufferSource label, optional BufferSource context);
readonly attribute Promise<undefined> ready;
readonly attribute WebTransportReliabilityMode reliability;
readonly attribute WebTransportCongestionControl congestionControl;
[EnforceRange] attribute unsigned short? anticipatedConcurrentIncomingUnidirectionalStreams;
[EnforceRange] attribute unsigned short? anticipatedConcurrentIncomingBidirectionalStreams;
readonly attribute DOMString protocol;
readonly attribute Promise<WebTransportCloseInfo> closed;
readonly attribute Promise<undefined> draining;
undefined close(optional WebTransportCloseInfo closeInfo = {});
readonly attribute WebTransportDatagramDuplexStream datagrams;
Promise<WebTransportBidirectionalStream> createBidirectionalStream(
optional WebTransportSendStreamOptions options = {});
/* a ReadableStream of WebTransportBidirectionalStream objects */
readonly attribute ReadableStream incomingBidirectionalStreams;
Promise<WebTransportSendStream> createUnidirectionalStream(
optional WebTransportSendStreamOptions options = {});
/* a ReadableStream of WebTransportReceiveStream objects */
readonly attribute ReadableStream incomingUnidirectionalStreams;
WebTransportSendGroup createSendGroup();
static readonly attribute boolean supportsReliableOnly;
};
enum WebTransportReliabilityMode {
"pending",
"reliable-only",
"supports-unreliable",
};
dictionary WebTransportHash {
required DOMString algorithm;
required BufferSource value;
};
dictionary WebTransportOptions {
boolean allowPooling = false;
boolean requireUnreliable = false;
sequence<WebTransportHash> serverCertificateHashes = [];
WebTransportCongestionControl congestionControl = "default";
[EnforceRange] unsigned short? anticipatedConcurrentIncomingUnidirectionalStreams = null;
[EnforceRange] unsigned short? anticipatedConcurrentIncomingBidirectionalStreams = null;
sequence<DOMString> protocols = [];
ReadableStreamType datagramsReadableType;
};
enum WebTransportCongestionControl {
"default",
"throughput",
"low-latency",
};
dictionary WebTransportCloseInfo {
unsigned long closeCode = 0;
USVString reason = "";
};
dictionary WebTransportSendOptions {
WebTransportSendGroup? sendGroup = null;
long long sendOrder = 0;
};
dictionary WebTransportSendStreamOptions : WebTransportSendOptions {
boolean waitUntilAvailable = false;
};
dictionary WebTransportConnectionStats {
unsigned long long bytesSent;
unsigned long long bytesSentOverhead;
unsigned long long bytesAcknowledged;
unsigned long long packetsSent;
unsigned long long bytesLost;
unsigned long long packetsLost;
unsigned long long bytesReceived;
unsigned long long packetsReceived;
DOMHighResTimeStamp smoothedRtt;
DOMHighResTimeStamp rttVariation;
DOMHighResTimeStamp minRtt;
required WebTransportDatagramStats datagrams;
unsigned long long? estimatedSendRate = null;
boolean atSendCapacity = false;
};
dictionary WebTransportDatagramStats {
unsigned long long droppedIncoming;
unsigned long long expiredIncoming;
unsigned long long expiredOutgoing;
unsigned long long lostOutgoing;
};
[Exposed=(Window,Worker), SecureContext, Transferable]
interface WebTransportSendStream : WritableStream {
attribute WebTransportSendGroup? sendGroup;
attribute long long sendOrder;
Promise<WebTransportSendStreamStats> getStats();
WebTransportWriter getWriter();
};
dictionary WebTransportSendStreamStats {
unsigned long long bytesWritten;
unsigned long long bytesSent;
unsigned long long bytesAcknowledged;
};
[Exposed=(Window,Worker), SecureContext]
interface WebTransportSendGroup {
Promise<WebTransportSendStreamStats> getStats();
};
[Exposed=(Window,Worker), SecureContext, Transferable]
interface WebTransportReceiveStream : ReadableStream {
Promise<WebTransportReceiveStreamStats> getStats();
};
dictionary WebTransportReceiveStreamStats {
unsigned long long bytesReceived;
unsigned long long bytesRead;
};
[Exposed=(Window,Worker), SecureContext]
interface WebTransportBidirectionalStream {
readonly attribute WebTransportReceiveStream readable;
readonly attribute WebTransportSendStream writable;
};
[Exposed=*, SecureContext]
interface WebTransportWriter : WritableStreamDefaultWriter {
Promise<undefined> atomicWrite(optional any chunk);
undefined commit();
};
[Exposed=(Window,Worker), Serializable, SecureContext]
interface WebTransportError : DOMException {
constructor(optional DOMString message = "", optional WebTransportErrorOptions options = {});
readonly attribute WebTransportErrorSource source;
readonly attribute unsigned long? streamErrorCode;
};
dictionary WebTransportErrorOptions {
WebTransportErrorSource source = "stream";
[Clamp] unsigned long? streamErrorCode = null;
};
enum WebTransportErrorSource {
"stream",
"session",
};
|
