type LaunchConsumer = (params: LaunchParams) => any

interface LaunchParams {
  readonly targetURL?: string
  readonly files: ReadonlyArray<FileSystemHandle>
}

interface LaunchQueue {
  setConsumer(consumer: LaunchConsumer): void
}

interface Window {
  readonly launchQueue: LaunchQueue
}

interface Window {
  showOpenFilePicker: (options?: OpenFilePickerOptions) => Promise<FileSystemFileHandle[]>
  showSaveFilePicker: (options?: SaveFilePickerOptions) => Promise<FileSystemFileHandle>
  showDirectoryPicker: (options?: DirectoryPickerOptions) => Promise<FileSystemDirectoryHandle>
}

interface FilePickerAcceptType {
  description?: string
  accept: Record<string, string | string[]>
}

interface FilePickerOptions {
  excludeAcceptAllOption?: boolean
  id?: string
  types?: FilePickerAcceptType[]
  startIn?: StartInDirectory
}

interface OpenFilePickerOptions extends FilePickerOptions {
  multiple?: boolean
}

interface SaveFilePickerOptions extends FilePickerOptions {
  suggestedName?: string
}

interface DirectoryPickerOptions {
  id?: string
  startIn?: StartInDirectory
  mode?: FileSystemPermissionMode
}

type WellKnownDirectory = 'desktop' | 'documents' | 'downloads' | 'music' | 'pictures' | 'videos'

type StartInDirectory = WellKnownDirectory | FileSystemHandle

type FileSystemPermissionMode = 'read' | 'readwrite'

interface Blob {
  readonly size: number
  readonly type: string

  slice(start?: number, end?: number, contentType?: string): Blob

  stream(): ReadableStream
  text(): Promise<string>
  arrayBuffer(): Promise<ArrayBuffer>
}

declare var Blob: {
  new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob
  prototype: Blob
}

enum EndingType {
  transparent = 'transparent',
  native = 'native',
}

interface BlobPropertyBag {
  type?: string
  endings?: EndingType
}

type BlobPart = Blob | string | BufferSource

interface File extends Blob {
  readonly name: string
  readonly lastModified: number
}

declare var File: {
  new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File
  prototype: File
}

interface FilePropertyBag extends BlobPropertyBag {
  lastModified?: number
}

interface FileList {
  item(index: number): File | null
  readonly length: number
  [index: number]: File
  [Symbol.iterator](): IterableIterator<File>
}

declare var FileList: {
  prototype: FileList
}

interface FileReader extends EventTarget {
  readAsArrayBuffer(blob: Blob): void
  readAsBinaryString(blob: Blob): void
  readAsText(blob: Blob, encoding?: string): void
  readAsDataURL(blob: Blob): void

  abort(): void

  readonly EMPTY: 0
  readonly LOADING: 1
  readonly DONE: 2

  readonly readyState: FileReader['EMPTY' | 'LOADING' | 'DONE']

  readonly result: string | ArrayBuffer | null

  readonly error: DOMException | null

  onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null
  onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null
  onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null
  onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null
  onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null
  onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null
}

declare var FileReader: {
  new(): FileReader
  prototype: FileReader
  readonly EMPTY: 0
  readonly LOADING: 1
  readonly DONE: 2
}

interface FileReaderSync {
  readAsArrayBuffer(blob: Blob): ArrayBuffer
  readAsBinaryString(blob: Blob): string
  readAsText(blob: Blob, encoding?: string): string
  readAsDataURL(blob: Blob): string
}

declare var FileReaderSync: {
  new(): FileReaderSync
  prototype: FileReaderSync
}

declare var URL: {
  new(url: string | URL, base?: string | URL): URL
  prototype: URL
  createObjectURL(obj: Blob | MediaSource): string
  revokeObjectURL(url: string): void
}

interface BarcodeDetector {
  detect(image: ImageBitmapSource): Promise<DetectedBarcode[]>
}

declare var BarcodeDetector: {
  new (barcodeDetectorOptions?: BarcodeDetectorOptions): BarcodeDetector
  prototype: BarcodeDetector

  getSupportedFormats(): Promise<BarcodeFormat[]>
}

interface BarcodeDetectorOptions {
  formats: BarcodeFormat[]
}

interface DetectedBarcode {
  boundingBox: DOMRectReadOnly
  rawValue: string
  format: BarcodeFormat
  cornerPoints: ReadonlyArray<Point2D>
}

enum BarcodeFormat {
  "aztec",
  "code_128",
  "code_39",
  "code_93",
  "codabar",
  "data_matrix",
  "ean_13",
  "ean_8",
  "itf",
  "pdf417",
  "qr_code",
  "unknown",
  "upc_a",
  "upc_e"
}

interface Document {
  readonly hidden: boolean
  readonly visibilityState: DocumentVisibilityState
  onvisibilitychange: ((this: Document, ev: Event) => any) | null
}

type DocumentVisibilityState = 'hidden' | 'visible'

interface UserActivation {
  readonly hasBeenActive: boolean
  readonly isActive: boolean
}

declare var UserActivation: {
  prototype: UserActivation
}

interface Navigator {
  readonly userActivation: UserActivation
}

interface UIEvent extends Event {
  readonly detail: number
  readonly view: Window | null
  /** @deprecated */
  readonly which: number
  /** @deprecated */
  initUIEvent(typeArg: string, bubblesArg?: boolean, cancelableArg?: boolean, viewArg?: Window | null, detailArg?: number): void
}

declare var UIEvent: {
  prototype: UIEvent
  new(type: string, eventInitDict?: UIEventInit): UIEvent
}

interface UIEventInit extends EventInit {
  detail?: number
  view?: Window | null
  /** @deprecated */
  which?: number
}

interface FocusEvent extends UIEvent {
  readonly relatedTarget: EventTarget | null
}

declare var FocusEvent: {
  prototype: FocusEvent
  new(type: string, eventInitDict?: FocusEventInit): FocusEvent
}

interface FocusEventInit extends UIEventInit {
  relatedTarget?: EventTarget | null
}

interface MouseEvent extends UIEvent {
  readonly altKey: boolean
  readonly button: number
  readonly buttons: number
  readonly clientX: number
  readonly clientY: number
  readonly ctrlKey: boolean
  readonly metaKey: boolean
  readonly movementX: number
  readonly movementY: number
  readonly offsetX: number
  readonly offsetY: number
  readonly pageX: number
  readonly pageY: number
  readonly relatedTarget: EventTarget | null
  readonly screenX: number
  readonly screenY: number
  readonly shiftKey: boolean
  readonly x: number
  readonly y: number
  getModifierState(keyArg: string): boolean
  /** @deprecated */
  initMouseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget | null): void
}

declare var MouseEvent: {
  prototype: MouseEvent
  new(type: string, eventInitDict?: MouseEventInit): MouseEvent
}

interface MouseEventInit extends EventModifierInit {
  button?: number
  buttons?: number
  clientX?: number
  clientY?: number
  movementX?: number
  movementY?: number
  relatedTarget?: EventTarget | null
  screenX?: number
  screenY?: number
}

interface EventModifierInit extends UIEventInit {
  altKey?: boolean
  ctrlKey?: boolean
  metaKey?: boolean
  modifierAltGraph?: boolean
  modifierCapsLock?: boolean
  modifierFn?: boolean
  modifierFnLock?: boolean
  modifierHyper?: boolean
  modifierNumLock?: boolean
  modifierScrollLock?: boolean
  modifierSuper?: boolean
  modifierSymbol?: boolean
  modifierSymbolLock?: boolean
  shiftKey?: boolean
}

interface WheelEvent extends MouseEvent {
  readonly deltaMode: number
  readonly deltaX: number
  readonly deltaY: number
  readonly deltaZ: number
  readonly DOM_DELTA_PIXEL: 0x00
  readonly DOM_DELTA_LINE: 0x01
  readonly DOM_DELTA_PAGE: 0x02
}

declare var WheelEvent: {
  prototype: WheelEvent
  new(type: string, eventInitDict?: WheelEventInit): WheelEvent
  readonly DOM_DELTA_PIXEL: 0x00
  readonly DOM_DELTA_LINE: 0x01
  readonly DOM_DELTA_PAGE: 0x02
}

interface WheelEventInit extends MouseEventInit {
  deltaMode?: number
  deltaX?: number
  deltaY?: number
  deltaZ?: number
}

interface InputEvent extends UIEvent {
  readonly data: string | null
  readonly dataTransfer: DataTransfer | null
  readonly inputType: string
  readonly isComposing: boolean
  getTargetRanges(): StaticRange[]
}

declare var InputEvent: {
  prototype: InputEvent
  new(type: string, eventInitDict?: InputEventInit): InputEvent
}

interface InputEventInit extends UIEventInit {
  data?: string | null
  dataTransfer?: DataTransfer | null
  inputType?: string
  isComposing?: boolean
  targetRanges?: StaticRange[]
}

interface KeyboardEvent extends UIEvent {
  readonly altKey: boolean
  /** @deprecated */
  readonly charCode: number
  readonly code: string
  readonly ctrlKey: boolean
  readonly isComposing: boolean
  readonly key: string
  /** @deprecated */
  readonly keyCode: number
  readonly location: number
  readonly metaKey: boolean
  readonly repeat: boolean
  readonly shiftKey: boolean
  getModifierState(keyArg: string): boolean
  /** @deprecated */
  initKeyboardEvent(typeArg: string, bubblesArg?: boolean, cancelableArg?: boolean, viewArg?: Window | null, keyArg?: string, locationArg?: number, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean, metaKey?: boolean): void
  readonly DOM_KEY_LOCATION_STANDARD: 0x00
  readonly DOM_KEY_LOCATION_LEFT: 0x01
  readonly DOM_KEY_LOCATION_RIGHT: 0x02
  readonly DOM_KEY_LOCATION_NUMPAD: 0x03
}

declare var KeyboardEvent: {
  prototype: KeyboardEvent
  new(type: string, eventInitDict?: KeyboardEventInit): KeyboardEvent
  readonly DOM_KEY_LOCATION_STANDARD: 0x00
  readonly DOM_KEY_LOCATION_LEFT: 0x01
  readonly DOM_KEY_LOCATION_RIGHT: 0x02
  readonly DOM_KEY_LOCATION_NUMPAD: 0x03
}

interface KeyboardEventInit extends EventModifierInit {
  /** @deprecated */
  charCode?: number
  code?: string
  isComposing?: boolean
  key?: string
  /** @deprecated */
  keyCode?: number
  location?: number
  repeat?: boolean
}

interface CompositionEvent extends UIEvent {
  readonly data: string
  /** @deprecated */
  initCompositionEvent(typeArg: string, bubblesArg?: boolean, cancelableArg?: boolean, viewArg?: WindowProxy | null, dataArg?: string): void
}

declare var CompositionEvent: {
  prototype: CompositionEvent
  new(type: string, eventInitDict?: CompositionEventInit): CompositionEvent
}

interface CompositionEventInit extends UIEventInit {
  data?: string
}

interface MutationEvent extends Event {
  /** @deprecated */
  readonly attrChange: number
  /** @deprecated */
  readonly attrName: string
  /** @deprecated */
  readonly newValue: string
  /** @deprecated */
  readonly prevValue: string
  /** @deprecated */
  readonly relatedNode: Node | null
  /** @deprecated */
  initMutationEvent(typeArg: string, bubblesArg?: boolean, cancelableArg?: boolean, relatedNodeArg?: Node | null, prevValueArg?: string, newValueArg?: string, attrNameArg?: string, attrChangeArg?: number): void
  readonly MODIFICATION: 1
  readonly ADDITION: 2
  readonly REMOVAL: 3
}

/** @deprecated */
declare var MutationEvent: {
  prototype: MutationEvent
  new(): MutationEvent
  readonly MODIFICATION: 1
  readonly ADDITION: 2
  readonly REMOVAL: 3
}

interface DataTransfer {
    dropEffect: "none" | "copy" | "link" | "move"
    effectAllowed: "none" | "copy" | "copyLink" | "copyMove" | "link" | "linkMove" | "move" | "all" | "uninitialized"
    readonly files: FileList
    readonly items: DataTransferItemList
    readonly types: ReadonlyArray<string>
    clearData(format?: string): void
    getData(format: string): string
    setData(format: string, data: string): void
    setDragImage(image: Element, x: number, y: number): void
}

declare var DataTransfer: {
    prototype: DataTransfer
    new(): DataTransfer
}

interface DataTransferItem {
    readonly kind: string
    readonly type: string
    getAsFile(): File | null
    getAsString(callback: FunctionStringCallback | null): void
    webkitGetAsEntry(): FileSystemEntry | null
}

declare var DataTransferItem: {
    prototype: DataTransferItem
}

interface DataTransferItemList {
    readonly length: number
    add(data: string, type: string): DataTransferItem | null
    add(data: File): DataTransferItem | null
    clear(): void
    remove(index: number): void
    [index: number]: DataTransferItem
}

declare var DataTransferItemList: {
    prototype: DataTransferItemList
}

interface DragEvent extends MouseEvent {
    readonly dataTransfer: DataTransfer | null
}

declare var DragEvent: {
    prototype: DragEvent
    new(type: string, eventInitDict?: DragEventInit): DragEvent
}

interface DragEventInit extends MouseEventInit {
    dataTransfer?: DataTransfer | null
}

interface GlobalEventHandlersEventMap {
    "drag": DragEvent;
    "dragend": DragEvent;
    "dragenter": DragEvent;
    "dragleave": DragEvent;
    "dragover": DragEvent;
    "dragstart": DragEvent;
    "drop": DragEvent;
}

interface GlobalEventHandlers {
    ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null
    ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null
    ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null
    ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null
    ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null
    ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null
    ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null
}

interface Window {
  ondeviceorientation: ((this: Window, ev: DeviceOrientationEvent) => any) | null
  ondeviceorientationabsolute: ((this: Window, ev: DeviceOrientationEvent) => any) | null
  ondevicemotion: ((this: Window, ev: DeviceMotionEvent) => any) | null
}

interface DeviceOrientationEvent extends Event {
  readonly alpha: number | null
  readonly beta: number | null
  readonly gamma: number | null
  readonly absolute: boolean
}

declare var DeviceOrientationEvent: {
  new (type: string, eventInitDict?: DeviceOrientationEventInit): DeviceOrientationEvent
  prototype: DeviceOrientationEvent

  requestPermission(): Promise<PermissionState>
}

interface DeviceOrientationEventInit extends EventInit {
  alpha?: number | null
  beta?: number | null
  gamma?: number | null
  absolute?: boolean
}

interface DeviceMotionEventAcceleration {
  readonly x: number | null
  readonly y: number | null
  readonly z: number | null
}

interface DeviceMotionEventRotationRate {
  readonly alpha: number | null
  readonly beta: number | null
  readonly gamma: number | null
}

interface DeviceMotionEvent extends Event {
  readonly acceleration: DeviceMotionEventAcceleration | null
  readonly accelerationIncludingGravity: DeviceMotionEventAcceleration | null
  readonly rotationRate: DeviceMotionEventRotationRate | null
  readonly interval: number
}

declare var DeviceMotionEvent: {
  new (type: string, eventInitDict?: DeviceMotionEventInit): DeviceMotionEvent
  prototype: DeviceMotionEvent

  requestPermission(): Promise<PermissionState>
}

interface DeviceMotionEventAccelerationInit {
  x?: number | null
  y?: number | null
  z?: number | null
}

interface DeviceMotionEventRotationRateInit {
  alpha?: number | null
  beta?: number | null
  gamma?: number | null
}

interface DeviceMotionEventInit extends EventInit {
  acceleration?: DeviceMotionEventAccelerationInit
  accelerationIncludingGravity?: DeviceMotionEventAccelerationInit
  rotationRate?: DeviceMotionEventRotationRateInit
  interval?: number
}

interface Navigator {
  readonly contacts: ContactsManager
}

type ContactProperty = "address" | "email" | "icon" | "name" | "tel"

interface ContactAddress {
  toJSON(): Object
  readonly city: string
  readonly country: string
  readonly dependentLocality: string
  readonly organization: string
  readonly phone: string
  readonly postalCode: string
  readonly recipient: string
  readonly region: string
  readonly sortingCode: string
  readonly addressLine: string[]
}

interface ContactInfo {
  address: ContactAddress[]
  email: string[]
  icon: Blob[]
  name: string[]
  tel: string[]
}

interface ContactsSelectOptions {
  multiple?: boolean
}

interface ContactsManager {
  getProperties(): Promise<ContactProperty[]>
  select(properties: ContactProperty[], options?: ContactsSelectOptions): Promise<ContactInfo[]>
}