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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
|
// GENERATED CONTENT - DO NOT EDIT
// Content was automatically extracted by Reffy into webref
// (https://github.com/w3c/webref)
// Source: WebUSB API (https://wicg.github.io/webusb/)
dictionary USBDeviceFilter {
unsigned short vendorId;
unsigned short productId;
octet classCode;
octet subclassCode;
octet protocolCode;
DOMString serialNumber;
};
dictionary USBDeviceRequestOptions {
required sequence<USBDeviceFilter> filters;
sequence<USBDeviceFilter> exclusionFilters = [];
};
[Exposed=(Worker,Window), SecureContext]
interface USB : EventTarget {
attribute EventHandler onconnect;
attribute EventHandler ondisconnect;
Promise<sequence<USBDevice>> getDevices();
[Exposed=Window] Promise<USBDevice> requestDevice(USBDeviceRequestOptions options);
};
[Exposed=Window, SecureContext]
partial interface Navigator {
[SameObject] readonly attribute USB usb;
};
[Exposed=Worker, SecureContext]
partial interface WorkerNavigator {
[SameObject] readonly attribute USB usb;
};
dictionary USBConnectionEventInit : EventInit {
required USBDevice device;
};
[
Exposed=(DedicatedWorker,SharedWorker,Window),
SecureContext
]
interface USBConnectionEvent : Event {
constructor(DOMString type, USBConnectionEventInit eventInitDict);
[SameObject] readonly attribute USBDevice device;
};
enum USBTransferStatus {
"ok",
"stall",
"babble"
};
[
Exposed=(DedicatedWorker,SharedWorker,Window),
SecureContext
]
interface USBInTransferResult {
constructor(USBTransferStatus status, optional DataView? data);
readonly attribute DataView? data;
readonly attribute USBTransferStatus status;
};
[
Exposed=(DedicatedWorker,SharedWorker,Window),
SecureContext
]
interface USBOutTransferResult {
constructor(USBTransferStatus status, optional unsigned long bytesWritten = 0);
readonly attribute unsigned long bytesWritten;
readonly attribute USBTransferStatus status;
};
[
Exposed=(DedicatedWorker,SharedWorker,Window),
SecureContext
]
interface USBIsochronousInTransferPacket {
constructor(USBTransferStatus status, optional DataView? data);
readonly attribute DataView? data;
readonly attribute USBTransferStatus status;
};
[
Exposed=(DedicatedWorker,SharedWorker,Window),
SecureContext
]
interface USBIsochronousInTransferResult {
constructor(sequence<USBIsochronousInTransferPacket> packets, optional DataView? data);
readonly attribute DataView? data;
readonly attribute FrozenArray<USBIsochronousInTransferPacket> packets;
};
[
Exposed=(DedicatedWorker,SharedWorker,Window),
SecureContext
]
interface USBIsochronousOutTransferPacket {
constructor(USBTransferStatus status, optional unsigned long bytesWritten = 0);
readonly attribute unsigned long bytesWritten;
readonly attribute USBTransferStatus status;
};
[
Exposed=(DedicatedWorker,SharedWorker,Window),
SecureContext
]
interface USBIsochronousOutTransferResult {
constructor(sequence<USBIsochronousOutTransferPacket> packets);
readonly attribute FrozenArray<USBIsochronousOutTransferPacket> packets;
};
[Exposed=(DedicatedWorker,SharedWorker,Window), SecureContext]
interface USBDevice {
readonly attribute octet usbVersionMajor;
readonly attribute octet usbVersionMinor;
readonly attribute octet usbVersionSubminor;
readonly attribute octet deviceClass;
readonly attribute octet deviceSubclass;
readonly attribute octet deviceProtocol;
readonly attribute unsigned short vendorId;
readonly attribute unsigned short productId;
readonly attribute octet deviceVersionMajor;
readonly attribute octet deviceVersionMinor;
readonly attribute octet deviceVersionSubminor;
readonly attribute DOMString? manufacturerName;
readonly attribute DOMString? productName;
readonly attribute DOMString? serialNumber;
readonly attribute USBConfiguration? configuration;
readonly attribute FrozenArray<USBConfiguration> configurations;
readonly attribute boolean opened;
Promise<undefined> open();
Promise<undefined> close();
Promise<undefined> forget();
Promise<undefined> selectConfiguration(octet configurationValue);
Promise<undefined> claimInterface(octet interfaceNumber);
Promise<undefined> releaseInterface(octet interfaceNumber);
Promise<undefined> selectAlternateInterface(octet interfaceNumber, octet alternateSetting);
Promise<USBInTransferResult> controlTransferIn(USBControlTransferParameters setup, unsigned short length);
Promise<USBOutTransferResult> controlTransferOut(USBControlTransferParameters setup, optional BufferSource data);
Promise<undefined> clearHalt(USBDirection direction, octet endpointNumber);
Promise<USBInTransferResult> transferIn(octet endpointNumber, unsigned long length);
Promise<USBOutTransferResult> transferOut(octet endpointNumber, BufferSource data);
Promise<USBIsochronousInTransferResult> isochronousTransferIn(octet endpointNumber, sequence<unsigned long> packetLengths);
Promise<USBIsochronousOutTransferResult> isochronousTransferOut(octet endpointNumber, BufferSource data, sequence<unsigned long> packetLengths);
Promise<undefined> reset();
};
enum USBRequestType {
"standard",
"class",
"vendor"
};
enum USBRecipient {
"device",
"interface",
"endpoint",
"other"
};
dictionary USBControlTransferParameters {
required USBRequestType requestType;
required USBRecipient recipient;
required octet request;
required unsigned short value;
required unsigned short index;
};
[
Exposed=(DedicatedWorker,SharedWorker,Window),
SecureContext
]
interface USBConfiguration {
constructor(USBDevice device, octet configurationValue);
readonly attribute octet configurationValue;
readonly attribute DOMString? configurationName;
readonly attribute FrozenArray<USBInterface> interfaces;
};
[
Exposed=(DedicatedWorker,SharedWorker,Window),
SecureContext
]
interface USBInterface {
constructor(USBConfiguration configuration, octet interfaceNumber);
readonly attribute octet interfaceNumber;
readonly attribute USBAlternateInterface alternate;
readonly attribute FrozenArray<USBAlternateInterface> alternates;
readonly attribute boolean claimed;
};
[
Exposed=(DedicatedWorker,SharedWorker,Window),
SecureContext
]
interface USBAlternateInterface {
constructor(USBInterface deviceInterface, octet alternateSetting);
readonly attribute octet alternateSetting;
readonly attribute octet interfaceClass;
readonly attribute octet interfaceSubclass;
readonly attribute octet interfaceProtocol;
readonly attribute DOMString? interfaceName;
readonly attribute FrozenArray<USBEndpoint> endpoints;
};
enum USBDirection {
"in",
"out"
};
enum USBEndpointType {
"bulk",
"interrupt",
"isochronous"
};
[
Exposed=(DedicatedWorker,SharedWorker,Window),
SecureContext
]
interface USBEndpoint {
constructor(USBAlternateInterface alternate, octet endpointNumber, USBDirection direction);
readonly attribute octet endpointNumber;
readonly attribute USBDirection direction;
readonly attribute USBEndpointType type;
readonly attribute unsigned long packetSize;
};
// USBBlocklistEntry is never exposed.
dictionary USBBlocklistEntry {
required unsigned short idVendor;
required unsigned short idProduct;
required unsigned short bcdDevice;
};
dictionary USBPermissionDescriptor : PermissionDescriptor {
sequence<USBDeviceFilter> filters;
sequence<USBDeviceFilter> exclusionFilters;
};
dictionary AllowedUSBDevice {
required octet vendorId;
required octet productId;
DOMString serialNumber;
};
dictionary USBPermissionStorage {
sequence<AllowedUSBDevice> allowedDevices = [];
};
[Exposed=(DedicatedWorker,SharedWorker,Window)]
interface USBPermissionResult : PermissionStatus {
attribute FrozenArray<USBDevice> devices;
};
|
