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