@webref/idl 3.1.3 → 3.3.0

package/app-history.idl

@@ -1,85 +1,85 @@
 // GENERATED CONTENT - DO NOT EDIT
 // Content was automatically extracted by Reffy into webref
 // (https://github.com/w3c/webref)
-// Source: App History API (https://wicg.github.io/app-history/)
+// Source: Navigation API (https://wicg.github.io/navigation-api/)
 
 partial interface Window {
-  readonly attribute AppHistory appHistory;
+  readonly attribute Navigation navigation;
 };
 
 [Exposed=Window]
-interface AppHistory : EventTarget {
-  sequence<AppHistoryEntry> entries();
-  readonly attribute AppHistoryEntry? current;
-  undefined updateCurrent(AppHistoryUpdateCurrentOptions options);
-  readonly attribute AppHistoryTransition? transition;
+interface Navigation : EventTarget {
+  sequence<NavigationHistoryEntry> entries();
+  readonly attribute NavigationHistoryEntry? currentEntry;
+  undefined updateCurrentEntry(NavigationUpdateCurrentEntryOptions options);
+  readonly attribute NavigationTransition? transition;
 
   readonly attribute boolean canGoBack;
   readonly attribute boolean canGoForward;
 
-  AppHistoryResult navigate(USVString url, optional AppHistoryNavigateOptions options = {});
-  AppHistoryResult reload(optional AppHistoryReloadOptions options = {});
+  NavigationResult navigate(USVString url, optional NavigationNavigateOptions options = {});
+  NavigationResult reload(optional NavigationReloadOptions options = {});
 
-  AppHistoryResult goTo(DOMString key, optional AppHistoryNavigationOptions options = {});
-  AppHistoryResult back(optional AppHistoryNavigationOptions options = {});
-  AppHistoryResult forward(optional AppHistoryNavigationOptions options = {});
+  NavigationResult traverseTo(DOMString key, optional NavigationOptions options = {});
+  NavigationResult back(optional NavigationOptions options = {});
+  NavigationResult forward(optional NavigationOptions options = {});
 
   attribute EventHandler onnavigate;
   attribute EventHandler onnavigatesuccess;
   attribute EventHandler onnavigateerror;
-  attribute EventHandler oncurrentchange;
+  attribute EventHandler oncurrententrychange;
 };
 
-dictionary AppHistoryUpdateCurrentOptions {
+dictionary NavigationUpdateCurrentEntryOptions {
   required any state;
 };
 
-dictionary AppHistoryNavigationOptions {
+dictionary NavigationOptions {
   any info;
 };
 
-dictionary AppHistoryNavigateOptions : AppHistoryNavigationOptions {
+dictionary NavigationNavigateOptions : NavigationOptions {
   any state;
   boolean replace = false;
 };
 
-dictionary AppHistoryReloadOptions : AppHistoryNavigationOptions {
+dictionary NavigationReloadOptions : NavigationOptions {
   any state;
 };
 
-dictionary AppHistoryResult {
-  Promise<AppHistoryEntry> committed;
-  Promise<AppHistoryEntry> finished;
+dictionary NavigationResult {
+  Promise<NavigationHistoryEntry> committed;
+  Promise<NavigationHistoryEntry> finished;
 };
 
 [Exposed=Window]
-interface AppHistoryCurrentChangeEvent : Event {
-  constructor(DOMString type, AppHistoryCurrentChangeEventInit eventInit);
+interface NavigationCurrentEntryChangeEvent : Event {
+  constructor(DOMString type, NavigationCurrentEntryChangeEventInit eventInit);
 
-  readonly attribute AppHistoryNavigationType? navigationType;
-  readonly attribute AppHistoryEntry from;
+  readonly attribute NavigationNavigationType? navigationType;
+  readonly attribute NavigationHistoryEntry from;
 };
 
-dictionary AppHistoryCurrentChangeEventInit : EventInit {
-  AppHistoryNavigationType? navigationType = null;
-  required AppHistoryEntry destination;
+dictionary NavigationCurrentEntryChangeEventInit : EventInit {
+  NavigationNavigationType? navigationType = null;
+  required NavigationHistoryEntry destination;
 };
 
 [Exposed=Window]
-interface AppHistoryTransition {
-  readonly attribute AppHistoryNavigationType navigationType;
-  readonly attribute AppHistoryEntry from;
+interface NavigationTransition {
+  readonly attribute NavigationNavigationType navigationType;
+  readonly attribute NavigationHistoryEntry from;
   readonly attribute Promise<undefined> finished;
 
-  AppHistoryResult rollback(optional AppHistoryNavigationOptions options = {});
+  NavigationResult rollback(optional NavigationOptions options = {});
 };
 
 [Exposed=Window]
-interface AppHistoryNavigateEvent : Event {
-  constructor(DOMString type, AppHistoryNavigateEventInit eventInit);
+interface NavigateEvent : Event {
+  constructor(DOMString type, NavigateEventInit eventInit);
 
-  readonly attribute AppHistoryNavigationType navigationType;
-  readonly attribute AppHistoryDestination destination;
+  readonly attribute NavigationNavigationType navigationType;
+  readonly attribute NavigationDestination destination;
   readonly attribute boolean canTransition;
   readonly attribute boolean userInitiated;
   readonly attribute boolean hashChange;
@@ -90,9 +90,9 @@ interface AppHistoryNavigateEvent : Event {
   undefined transitionWhile(Promise<undefined> newNavigationAction);
 };
 
-dictionary AppHistoryNavigateEventInit : EventInit {
-  AppHistoryNavigationType navigationType = "push";
-  required AppHistoryDestination destination;
+dictionary NavigateEventInit : EventInit {
+  NavigationNavigationType navigationType = "push";
+  required NavigationDestination destination;
   boolean canTransition = false;
   boolean userInitiated = false;
   boolean hashChange = false;
@@ -101,7 +101,8 @@ dictionary AppHistoryNavigateEventInit : EventInit {
   any info;
 };
 
-enum AppHistoryNavigationType {
+// TODO: rename to NavigationType after https://github.com/w3c/navigation-timing/pull/172 lands.
+enum NavigationNavigationType {
   "reload",
   "push",
   "replace",
@@ -109,7 +110,7 @@ enum AppHistoryNavigationType {
 };
 
 [Exposed=Window]
-interface AppHistoryDestination {
+interface NavigationDestination {
   readonly attribute USVString url;
   readonly attribute DOMString? key;
   readonly attribute DOMString? id;
@@ -120,7 +121,7 @@ interface AppHistoryDestination {
 };
 
 [Exposed=Window]
-interface AppHistoryEntry : EventTarget {
+interface NavigationHistoryEntry : EventTarget {
   readonly attribute USVString? url;
   readonly attribute DOMString key;
   readonly attribute DOMString id;

package/clipboard-apis.idl

@@ -17,31 +17,14 @@ partial interface Navigator {
   [SecureContext, SameObject] readonly attribute Clipboard clipboard;
 };
 
-typedef sequence<ClipboardItem> ClipboardItems;
-
-[SecureContext, Exposed=Window] interface Clipboard : EventTarget {
-  Promise<ClipboardItems> read();
-  Promise<DOMString> readText();
-  Promise<undefined> write(ClipboardItems data);
-  Promise<undefined> writeText(DOMString data);
-};
-
-typedef (DOMString or Blob) ClipboardItemDataType;
-typedef Promise<ClipboardItemDataType> ClipboardItemData;
-
-callback ClipboardItemDelayedCallback = ClipboardItemData ();
+typedef Promise<(DOMString or Blob)> ClipboardItemData;
 
-[Exposed=Window] interface ClipboardItem {
+[SecureContext, Exposed=Window]
+interface ClipboardItem {
   constructor(record<DOMString, ClipboardItemData> items,
-    optional ClipboardItemOptions options = {});
-  static ClipboardItem createDelayed(
-      record<DOMString, ClipboardItemDelayedCallback> items,
-      optional ClipboardItemOptions options = {});
+              optional ClipboardItemOptions options = {});
 
   readonly attribute PresentationStyle presentationStyle;
-  readonly attribute long long lastModified;
-  readonly attribute boolean delayed;
-
   readonly attribute FrozenArray<DOMString> types;
 
   Promise<Blob> getType(DOMString type);
@@ -53,6 +36,16 @@ dictionary ClipboardItemOptions {
   PresentationStyle presentationStyle = "unspecified";
 };
 
+typedef sequence<ClipboardItem> ClipboardItems;
+
+[SecureContext, Exposed=Window]
+interface Clipboard : EventTarget {
+  Promise<ClipboardItems> read();
+  Promise<DOMString> readText();
+  Promise<undefined> write(ClipboardItems data);
+  Promise<undefined> writeText(DOMString data);
+};
+
 dictionary ClipboardPermissionDescriptor : PermissionDescriptor {
   boolean allowWithoutGesture = false;
 };

package/close-watcher.idl

@@ -5,11 +5,15 @@
 
 [Exposed=Window]
 interface CloseWatcher : EventTarget {
-  constructor();
+  constructor(optional CloseWatcherOptions options = {});
 
   undefined destroy();
-  undefined signalClose();
+  undefined close();
 
   attribute EventHandler oncancel;
   attribute EventHandler onclose;
 };
+
+dictionary CloseWatcherOptions {
+  AbortSignal signal;
+};

package/compute-pressure.idl

@@ -3,29 +3,36 @@
 // (https://github.com/w3c/webref)
 // Source: Compute Pressure API (https://wicg.github.io/compute-pressure/)
 
-enum PressureState { "nominal", "fair", "serious", "critical" };
+enum ComputePressureState { "nominal", "fair", "serious", "critical" };
+
+enum ComputePressureFactor { "thermal", "power-supply" };
 
 callback ComputePressureUpdateCallback = undefined (
-  sequence<ComputePressureEntry> entries,
+  sequence<ComputePressureRecord> changes,
   ComputePressureObserver observer
 );
 
-enum ComputePressureTarget { "cpu" };
+enum ComputePressureSource { "cpu" };
 
-[Exposed=Window]
+[Exposed=(DedicatedWorker,SharedWorker,Window), SecureContext]
 interface ComputePressureObserver {
   constructor(ComputePressureUpdateCallback callback);
 
-  undefined observe(ComputePressureTarget target, optional ComputePressureObserverOptions options = {});
-  undefined unobserve(ComputePressureTarget target);
+  undefined observe(ComputePressureSource source, optional ComputePressureObserverOptions options = {});
+  undefined unobserve(ComputePressureSource source);
   undefined disconnect();
-  sequence<ComputePressureEntry> takeRecords();
+  sequence<ComputePressureRecord> takeRecords();
+
+  [SameObject] static readonly attribute FrozenArray<DOMString> supportedSources;
 
-  [SameObject] static readonly attribute FrozenArray<DOMString> supportedTargetTypes;
+  [Exposed=Window] static Promise<PermissionState> requestPermission();
 };
 
-dictionary ComputePressureEntry {
-  PressureState state;
+dictionary ComputePressureRecord {
+  ComputePressureSource source;
+  ComputePressureState state;
+  sequence<ComputePressureFactor> factors;
+  DOMHighResTimeStamp timestamp;
   ComputePressureObserverOptions options;
 };
 

package/css-contain-3.idl

@@ -0,0 +1,8 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: CSS Containment Module Level 3 (https://drafts.csswg.org/css-contain-3/)
+
+[Exposed=Window]
+interface CSSContainerRule : CSSConditionRule {
+};

package/html.idl

@@ -116,6 +116,7 @@ interface HTMLElement : Element {
 
   // user interaction
   [CEReactions] attribute boolean hidden;
+  [CEReactions] attribute boolean inert;
   undefined click();
   [CEReactions] attribute DOMString accessKey;
   readonly attribute DOMString accessKeyLabel;
@@ -1341,7 +1342,7 @@ interface mixin CanvasTransform {
 interface mixin CanvasCompositing {
   // compositing
   attribute unrestricted double globalAlpha; // (default 1.0)
-  attribute DOMString globalCompositeOperation; // (default source-over)
+  attribute DOMString globalCompositeOperation; // (default "source-over")
 };
 
 interface mixin CanvasImageSmoothing {
@@ -1480,7 +1481,7 @@ interface mixin CanvasPath {
   undefined bezierCurveTo(unrestricted double cp1x, unrestricted double cp1y, unrestricted double cp2x, unrestricted double cp2y, unrestricted double x, unrestricted double y);
   undefined arcTo(unrestricted double x1, unrestricted double y1, unrestricted double x2, unrestricted double y2, unrestricted double radius);
   undefined rect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
-  undefined roundRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h, sequence<(unrestricted double or DOMPointInit)> radii);
+  undefined roundRect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h, optional (unrestricted double or DOMPointInit or sequence<(unrestricted double or DOMPointInit)>) radii = 0);
   undefined arc(unrestricted double x, unrestricted double y, unrestricted double radius, unrestricted double startAngle, unrestricted double endAngle, optional boolean counterclockwise = false);
   undefined ellipse(unrestricted double x, unrestricted double y, unrestricted double radiusX, unrestricted double radiusY, unrestricted double rotation, unrestricted double startAngle, unrestricted double endAngle, optional boolean counterclockwise = false);
 };
@@ -2208,53 +2209,6 @@ dictionary EventSourceInit {
   boolean withCredentials = false;
 };
 
-enum BinaryType { "blob", "arraybuffer" };
-[Exposed=(Window,Worker)]
-interface WebSocket : EventTarget {
-  constructor(USVString url, optional (DOMString or sequence<DOMString>) protocols = []);
-
-  readonly attribute USVString url;
-
-  // ready state
-  const unsigned short CONNECTING = 0;
-  const unsigned short OPEN = 1;
-  const unsigned short CLOSING = 2;
-  const unsigned short CLOSED = 3;
-  readonly attribute unsigned short readyState;
-  readonly attribute unsigned long long bufferedAmount;
-
-  // networking
-  attribute EventHandler onopen;
-  attribute EventHandler onerror;
-  attribute EventHandler onclose;
-  readonly attribute DOMString extensions;
-  readonly attribute DOMString protocol;
-  undefined close(optional [Clamp] unsigned short code, optional USVString reason);
-
-  // messaging
-  attribute EventHandler onmessage;
-  attribute BinaryType binaryType;
-  undefined send(USVString data);
-  undefined send(Blob data);
-  undefined send(ArrayBuffer data);
-  undefined send(ArrayBufferView data);
-};
-
-[Exposed=(Window,Worker)]
-interface CloseEvent : Event {
-  constructor(DOMString type, optional CloseEventInit eventInitDict = {});
-
-  readonly attribute boolean wasClean;
-  readonly attribute unsigned short code;
-  readonly attribute USVString reason;
-};
-
-dictionary CloseEventInit : EventInit {
-  boolean wasClean = false;
-  unsigned short code = 0;
-  USVString reason = "";
-};
-
 [Exposed=(Window,Worker)]
 interface MessageChannel {
   constructor();

package/navigation-timing.idl

@@ -5,20 +5,20 @@
 
 [Exposed=Window]
 interface PerformanceNavigationTiming : PerformanceResourceTiming {
-    readonly        attribute DOMHighResTimeStamp unloadEventStart;
-    readonly        attribute DOMHighResTimeStamp unloadEventEnd;
-    readonly        attribute DOMHighResTimeStamp domInteractive;
-    readonly        attribute DOMHighResTimeStamp domContentLoadedEventStart;
-    readonly        attribute DOMHighResTimeStamp domContentLoadedEventEnd;
-    readonly        attribute DOMHighResTimeStamp domComplete;
-    readonly        attribute DOMHighResTimeStamp loadEventStart;
-    readonly        attribute DOMHighResTimeStamp loadEventEnd;
-    readonly        attribute NavigationType      type;
-    readonly        attribute unsigned short      redirectCount;
+    readonly        attribute DOMHighResTimeStamp  unloadEventStart;
+    readonly        attribute DOMHighResTimeStamp  unloadEventEnd;
+    readonly        attribute DOMHighResTimeStamp  domInteractive;
+    readonly        attribute DOMHighResTimeStamp  domContentLoadedEventStart;
+    readonly        attribute DOMHighResTimeStamp  domContentLoadedEventEnd;
+    readonly        attribute DOMHighResTimeStamp  domComplete;
+    readonly        attribute DOMHighResTimeStamp  loadEventStart;
+    readonly        attribute DOMHighResTimeStamp  loadEventEnd;
+    readonly        attribute NavigationTimingType type;
+    readonly        attribute unsigned short       redirectCount;
     [Default] object toJSON();
 };
 
-enum NavigationType {
+enum NavigationTimingType {
     "navigate",
     "reload",
     "back_forward",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@webref/idl",
   "description": "Web IDL definitions of the web platform",
-  "version": "3.1.3",
+  "version": "3.3.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/w3c/webref.git"

package/priority-hints.idl

@@ -3,28 +3,28 @@
 // (https://github.com/w3c/webref)
 // Source: Priority Hints (https://wicg.github.io/priority-hints/)
 
-enum Importance { "high", "low", "auto" };
+enum FetchPriority { "high", "low", "auto" };
 
 partial interface Request {
-  readonly attribute Importance importance;
+  readonly attribute FetchPriority priority;
 };
 
 partial dictionary RequestInit {
-  Importance importance;
+  FetchPriority priority;
 };
 
 partial interface HTMLImageElement {
-    [CEReactions] attribute DOMString importance;
+    [CEReactions] attribute DOMString fetchpriority;
 };
 
 partial interface HTMLLinkElement {
-    [CEReactions] attribute DOMString importance;
+    [CEReactions] attribute DOMString fetchpriority;
 };
 
 partial interface HTMLScriptElement {
-    [CEReactions] attribute DOMString importance;
+    [CEReactions] attribute DOMString fetchpriority;
 };
 
 partial interface HTMLIFrameElement {
-    [CEReactions] attribute DOMString importance;
+    [CEReactions] attribute DOMString fetchpriority;
 };

package/secure-payment-confirmation.idl

@@ -5,6 +5,7 @@
 
 dictionary SecurePaymentConfirmationRequest {
     required BufferSource challenge;
+    required USVString rpId;
     required FrozenArray<BufferSource> credentialIds;
     required PaymentCredentialInstrument instrument;
     unsigned long timeout;

package/webgpu.idl

@@ -355,6 +355,7 @@ enum GPUTextureFormat {
 
 [Exposed=(Window, DedicatedWorker), SecureContext]
 interface GPUExternalTexture {
+    readonly attribute boolean expired;
 };
 GPUExternalTexture includes GPUObjectBase;
 

package/webnn.idl

@@ -16,33 +16,20 @@ enum MLDevicePreference {
 };
 
 enum MLPowerPreference {
-  // Let the user agent select the most suitable behavior.
   "default",
-
-  // Prioritizes execution speed over power consumption.
   "high-performance",
-
-  // Prioritizes power consumption over other considerations such as execution speed.
   "low-power"
 };
 
 dictionary MLContextOptions {
-  // Preferred kind of device used
   MLDevicePreference devicePreference = "default";
-
-  // Preference as related to power consumption
   MLPowerPreference powerPreference = "default";
 };
 
 [SecureContext, Exposed=(Window, DedicatedWorker)]
 interface ML {
-  // Create a context with options
   MLContext createContext(optional MLContextOptions options = {});
-
-  // Create a context from WebGL rendering context
   MLContext createContext(WebGLRenderingContext glContext);
-
-  // Create a context from WebGPU device
   MLContext createContext(GPUDevice gpuDevice);
 };
 

package/websockets.idl

@@ -0,0 +1,48 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: WebSockets Standard (https://websockets.spec.whatwg.org/)
+
+enum BinaryType { "blob", "arraybuffer" };
+
+[Exposed=(Window,Worker)]
+interface WebSocket : EventTarget {
+  constructor(USVString url, optional (DOMString or sequence<DOMString>) protocols = []);
+  readonly attribute USVString url;
+
+  // ready state
+  const unsigned short CONNECTING = 0;
+  const unsigned short OPEN = 1;
+  const unsigned short CLOSING = 2;
+  const unsigned short CLOSED = 3;
+  readonly attribute unsigned short readyState;
+  readonly attribute unsigned long long bufferedAmount;
+
+  // networking
+  attribute EventHandler onopen;
+  attribute EventHandler onerror;
+  attribute EventHandler onclose;
+  readonly attribute DOMString extensions;
+  readonly attribute DOMString protocol;
+  undefined close(optional [Clamp] unsigned short code, optional USVString reason);
+
+  // messaging
+  attribute EventHandler onmessage;
+  attribute BinaryType binaryType;
+  undefined send((BufferSource or Blob or USVString) data);
+};
+
+[Exposed=(Window,Worker)]
+interface CloseEvent : Event {
+  constructor(DOMString type, optional CloseEventInit eventInitDict = {});
+
+  readonly attribute boolean wasClean;
+  readonly attribute unsigned short code;
+  readonly attribute USVString reason;
+};
+
+dictionary CloseEventInit : EventInit {
+  boolean wasClean = false;
+  unsigned short code = 0;
+  USVString reason = "";
+};

package/webusb.idl

@@ -47,68 +47,12 @@ interface USBConnectionEvent : Event {
   [SameObject] readonly attribute USBDevice device;
 };
 
-[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> 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"
-};
-
 enum USBTransferStatus {
   "ok",
   "stall",
   "babble"
 };
 
-dictionary USBControlTransferParameters {
-  required USBRequestType requestType;
-  required USBRecipient recipient;
-  required octet request;
-  required unsigned short value;
-  required unsigned short index;
-};
-
 [
   Exposed=(DedicatedWorker,SharedWorker,Window),
   SecureContext
@@ -168,6 +112,63 @@ interface USBIsochronousOutTransferResult {
   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