1// GENERATED CONTENT - DO NOT EDIT
2// Content was automatically extracted by Reffy into webref
3// (https://github.com/w3c/webref)
4// Source: WebUSB API (https://wicg.github.io/webusb/)
5
6dictionary USBDeviceFilter {
7  unsigned short vendorId;
8  unsigned short productId;
9  octet classCode;
10  octet subclassCode;
11  octet protocolCode;
12  DOMString serialNumber;
13};
14
15dictionary USBDeviceRequestOptions {
16  required sequence<USBDeviceFilter> filters;
17};
18
19[Exposed=(DedicatedWorker,SharedWorker,Window), SecureContext]
20interface USB : EventTarget {
21  attribute EventHandler onconnect;
22  attribute EventHandler ondisconnect;
23  Promise<sequence<USBDevice>> getDevices();
24  [Exposed=Window] Promise<USBDevice> requestDevice(USBDeviceRequestOptions options);
25};
26
27[Exposed=Window, SecureContext]
28partial interface Navigator {
29  [SameObject] readonly attribute USB usb;
30};
31
32[Exposed=(DedicatedWorker,SharedWorker), SecureContext]
33partial interface WorkerNavigator {
34  [SameObject] readonly attribute USB usb;
35};
36
37dictionary USBConnectionEventInit : EventInit {
38    required USBDevice device;
39};
40
41[
42  Exposed=(DedicatedWorker,SharedWorker,Window),
43  SecureContext
44]
45interface USBConnectionEvent : Event {
46  constructor(DOMString type, USBConnectionEventInit eventInitDict);
47  [SameObject] readonly attribute USBDevice device;
48};
49
50[Exposed=(DedicatedWorker,SharedWorker,Window), SecureContext]
51interface USBDevice {
52  readonly attribute octet usbVersionMajor;
53  readonly attribute octet usbVersionMinor;
54  readonly attribute octet usbVersionSubminor;
55  readonly attribute octet deviceClass;
56  readonly attribute octet deviceSubclass;
57  readonly attribute octet deviceProtocol;
58  readonly attribute unsigned short vendorId;
59  readonly attribute unsigned short productId;
60  readonly attribute octet deviceVersionMajor;
61  readonly attribute octet deviceVersionMinor;
62  readonly attribute octet deviceVersionSubminor;
63  readonly attribute DOMString? manufacturerName;
64  readonly attribute DOMString? productName;
65  readonly attribute DOMString? serialNumber;
66  readonly attribute USBConfiguration? configuration;
67  readonly attribute FrozenArray<USBConfiguration> configurations;
68  readonly attribute boolean opened;
69  Promise<undefined> open();
70  Promise<undefined> close();
71  Promise<undefined> selectConfiguration(octet configurationValue);
72  Promise<undefined> claimInterface(octet interfaceNumber);
73  Promise<undefined> releaseInterface(octet interfaceNumber);
74  Promise<undefined> selectAlternateInterface(octet interfaceNumber, octet alternateSetting);
75  Promise<USBInTransferResult> controlTransferIn(USBControlTransferParameters setup, unsigned short length);
76  Promise<USBOutTransferResult> controlTransferOut(USBControlTransferParameters setup, optional BufferSource data);
77  Promise<undefined> clearHalt(USBDirection direction, octet endpointNumber);
78  Promise<USBInTransferResult> transferIn(octet endpointNumber, unsigned long length);
79  Promise<USBOutTransferResult> transferOut(octet endpointNumber, BufferSource data);
80  Promise<USBIsochronousInTransferResult> isochronousTransferIn(octet endpointNumber, sequence<unsigned long> packetLengths);
81  Promise<USBIsochronousOutTransferResult> isochronousTransferOut(octet endpointNumber, BufferSource data, sequence<unsigned long> packetLengths);
82  Promise<undefined> reset();
83};
84
85enum USBRequestType {
86  "standard",
87  "class",
88  "vendor"
89};
90
91enum USBRecipient {
92  "device",
93  "interface",
94  "endpoint",
95  "other"
96};
97
98enum USBTransferStatus {
99  "ok",
100  "stall",
101  "babble"
102};
103
104dictionary USBControlTransferParameters {
105  required USBRequestType requestType;
106  required USBRecipient recipient;
107  required octet request;
108  required unsigned short value;
109  required unsigned short index;
110};
111
112[
113  Exposed=(DedicatedWorker,SharedWorker,Window),
114  SecureContext
115]
116interface USBInTransferResult {
117  constructor(USBTransferStatus status, optional DataView? data);
118  readonly attribute DataView? data;
119  readonly attribute USBTransferStatus status;
120};
121
122[
123  Exposed=(DedicatedWorker,SharedWorker,Window),
124  SecureContext
125]
126interface USBOutTransferResult {
127  constructor(USBTransferStatus status, optional unsigned long bytesWritten = 0);
128  readonly attribute unsigned long bytesWritten;
129  readonly attribute USBTransferStatus status;
130};
131
132[
133  Exposed=(DedicatedWorker,SharedWorker,Window),
134  SecureContext
135]
136interface USBIsochronousInTransferPacket {
137  constructor(USBTransferStatus status, optional DataView? data);
138  readonly attribute DataView? data;
139  readonly attribute USBTransferStatus status;
140};
141
142[
143  Exposed=(DedicatedWorker,SharedWorker,Window),
144  SecureContext
145]
146interface USBIsochronousInTransferResult {
147  constructor(sequence<USBIsochronousInTransferPacket> packets, optional DataView? data);
148  readonly attribute DataView? data;
149  readonly attribute FrozenArray<USBIsochronousInTransferPacket> packets;
150};
151
152[
153  Exposed=(DedicatedWorker,SharedWorker,Window),
154  SecureContext
155]
156interface USBIsochronousOutTransferPacket {
157  constructor(USBTransferStatus status, optional unsigned long bytesWritten = 0);
158  readonly attribute unsigned long bytesWritten;
159  readonly attribute USBTransferStatus status;
160};
161
162[
163  Exposed=(DedicatedWorker,SharedWorker,Window),
164  SecureContext
165]
166interface USBIsochronousOutTransferResult {
167  constructor(sequence<USBIsochronousOutTransferPacket> packets);
168  readonly attribute FrozenArray<USBIsochronousOutTransferPacket> packets;
169};
170
171[
172  Exposed=(DedicatedWorker,SharedWorker,Window),
173  SecureContext
174]
175interface USBConfiguration {
176  constructor(USBDevice device, octet configurationValue);
177  readonly attribute octet configurationValue;
178  readonly attribute DOMString? configurationName;
179  readonly attribute FrozenArray<USBInterface> interfaces;
180};
181
182[
183  Exposed=(DedicatedWorker,SharedWorker,Window),
184  SecureContext
185]
186interface USBInterface {
187  constructor(USBConfiguration configuration, octet interfaceNumber);
188  readonly attribute octet interfaceNumber;
189  readonly attribute USBAlternateInterface alternate;
190  readonly attribute FrozenArray<USBAlternateInterface> alternates;
191  readonly attribute boolean claimed;
192};
193
194[
195  Exposed=(DedicatedWorker,SharedWorker,Window),
196  SecureContext
197]
198interface USBAlternateInterface {
199  constructor(USBInterface deviceInterface, octet alternateSetting);
200  readonly attribute octet alternateSetting;
201  readonly attribute octet interfaceClass;
202  readonly attribute octet interfaceSubclass;
203  readonly attribute octet interfaceProtocol;
204  readonly attribute DOMString? interfaceName;
205  readonly attribute FrozenArray<USBEndpoint> endpoints;
206};
207
208enum USBDirection {
209  "in",
210  "out"
211};
212
213enum USBEndpointType {
214  "bulk",
215  "interrupt",
216  "isochronous"
217};
218
219[
220  Exposed=(DedicatedWorker,SharedWorker,Window),
221  SecureContext
222]
223interface USBEndpoint {
224  constructor(USBAlternateInterface alternate, octet endpointNumber, USBDirection direction);
225  readonly attribute octet endpointNumber;
226  readonly attribute USBDirection direction;
227  readonly attribute USBEndpointType type;
228  readonly attribute unsigned long packetSize;
229};
230
231dictionary USBPermissionDescriptor : PermissionDescriptor {
232  sequence<USBDeviceFilter> filters;
233};
234
235dictionary AllowedUSBDevice {
236  required octet vendorId;
237  required octet productId;
238  DOMString serialNumber;
239};
240
241dictionary USBPermissionStorage {
242  sequence<AllowedUSBDevice> allowedDevices = [];
243};
244
245[Exposed=(DedicatedWorker,SharedWorker,Window)]
246interface USBPermissionResult : PermissionStatus {
247  attribute FrozenArray<USBDevice> devices;
248};
249