// Copied from https://wicg.github.io/webusb/#idl-index minus the
// definitions related to Permissions API integration which is unstable.

dictionary USBDeviceFilter {
  unsigned short vendorId;
  unsigned short productId;
  octet classCode;
  octet subclassCode;
  octet protocolCode;
  DOMString serialNumber;
};

dictionary USBDeviceRequestOptions {
  required sequence<USBDeviceFilter> filters;
};

interface USB : EventTarget {
  attribute EventHandler onconnect;
  attribute EventHandler ondisconnect;
  Promise<sequence<USBDevice>> getDevices();
  Promise<USBDevice> requestDevice(USBDeviceRequestOptions options);
};

[SecureContext]
partial interface Navigator {
  [SameObject] readonly attribute USB usb;
};

dictionary USBConnectionEventInit : EventInit {
    required USBDevice device;
};

[Constructor(DOMString type, USBConnectionEventInit eventInitDict)]
interface USBConnectionEvent : Event {
  [SameObject] readonly attribute USBDevice device;
};

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<void> open();
  Promise<void> close();
  Promise<void> selectConfiguration(octet configurationValue);
  Promise<void> claimInterface(octet interfaceNumber);
  Promise<void> releaseInterface(octet interfaceNumber);
  Promise<void> selectAlternateInterface(octet interfaceNumber, octet alternateSetting);
  Promise<USBInTransferResult> controlTransferIn(USBControlTransferParameters setup, unsigned short length);
  Promise<USBOutTransferResult> controlTransferOut(USBControlTransferParameters setup, optional BufferSource data);
  Promise<void> 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<void> 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;
};

[Constructor(USBTransferStatus status, optional DataView? data)]
interface USBInTransferResult {
  readonly attribute DataView? data;
  readonly attribute USBTransferStatus status;
};

[Constructor(USBTransferStatus status, optional unsigned long bytesWritten = 0)]
interface USBOutTransferResult {
  readonly attribute unsigned long bytesWritten;
  readonly attribute USBTransferStatus status;
};

[Constructor(USBTransferStatus status, optional DataView? data)]
interface USBIsochronousInTransferPacket {
  readonly attribute DataView? data;
  readonly attribute USBTransferStatus status;
};

[Constructor(sequence<USBIsochronousInTransferPacket> packets, optional DataView? data)]
interface USBIsochronousInTransferResult {
  readonly attribute DataView? data;
  readonly attribute FrozenArray<USBIsochronousInTransferPacket> packets;
};

[Constructor(USBTransferStatus status, optional unsigned long bytesWritten = 0)]
interface USBIsochronousOutTransferPacket {
  readonly attribute unsigned long bytesWritten;
  readonly attribute USBTransferStatus status;
};

[Constructor(sequence<USBIsochronousOutTransferPacket> packets)]
interface USBIsochronousOutTransferResult {
  readonly attribute FrozenArray<USBIsochronousOutTransferPacket> packets;
};

[Constructor(USBDevice device, octet configurationValue)]
interface USBConfiguration {
  readonly attribute octet configurationValue;
  readonly attribute DOMString? configurationName;
  readonly attribute FrozenArray<USBInterface> interfaces;
};

[Constructor(USBConfiguration configuration, octet interfaceNumber)]
interface USBInterface {
  readonly attribute octet interfaceNumber;
  readonly attribute USBAlternateInterface alternate;
  readonly attribute FrozenArray<USBAlternateInterface> alternates;
  readonly attribute boolean claimed;
};

[Constructor(USBInterface deviceInterface, octet alternateSetting)]
interface USBAlternateInterface {
  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"
};

[Constructor(USBAlternateInterface alternate, octet endpointNumber, USBDirection direction)]
interface USBEndpoint {
  readonly attribute octet endpointNumber;
  readonly attribute USBDirection direction;
  readonly attribute USBEndpointType type;
  readonly attribute unsigned long packetSize;
};