interface Window {
  readonly navigation: Navigation
}

interface Navigation extends EventTarget {
  entries(): NavigationHistoryEntry[]
  readonly currentEntry?: NavigationHistoryEntry
  updateCurrentEntry(options: NavigationUpdateCurrentEntryOptions): void
  readonly transition?: NavigationTransition

  navigate(url: string, options?: NavigationNavigateOptions): NavigationResult
  reload(options?: NavigationReloadOptions): NavigationResult

  readonly canGoBack: boolean
  readonly canGoForward: boolean

  back(options?: NavigationOptions): NavigationResult
  forward(options?: NavigationOptions): NavigationResult
  traverseTo(key: string, options?: NavigationOptions): NavigationResult

  oncurrententrychange: ((this: Navigation, ev: NavigationCurrentEntryChangeEvent) => any) | null
  onnavigate: ((this: Navigation, ev: NavigateEvent) => any) | null
  onnavigateerror: ((this: Navigation, ev: Event) => any) | null
  onnavigatesuccess: ((this: Navigation, ev: Event) => any) | null
}

declare var Navigation: {
  prototype: Navigation
}

interface NavigationUpdateCurrentEntryOptions {
  state: any
}

interface NavigationOptions {
  info?: any
}

interface NavigationNavigateOptions extends NavigationOptions {
  state?: any
  history?: NavigationHistoryBehavior
}

interface NavigationReloadOptions extends NavigationOptions {
  state?: any
}

interface NavigationResult {
  committed: Promise<NavigationHistoryEntry>
  finished: Promise<NavigationHistoryEntry>
}

enum NavigationHistoryBehavior {
  "auto",
  "push",
  "replace",
}

enum NavigationType {
 "push",
 "replace",
 "reload",
 "traverse",
}

interface NavigationHistoryEntry extends EventTarget {
  readonly url: string | null
  readonly key: string
  readonly id: string
  readonly index: number
  readonly sameDocument: boolean

  getState(): any

  ondispose: ((this: NavigationHistoryEntry, ev: Event) => any) | null
}

declare var NavigationHistoryEntry: {
  prototype: NavigationHistoryEntry
}

interface NavigationTransition {
  readonly navigationType: NavigationType
  readonly from: NavigationHistoryEntry
  readonly finished: Promise<undefined>
}

declare var NavigationTransition: {
  prototype: NavigationTransition
}

interface NavigationCurrentEntryChangeEvent extends Event {
  readonly navigationType: NavigationType | null
  readonly from: NavigationHistoryEntry
}

declare var NavigationCurrentEntryChangeEvent: {
  new(type: string, eventInitDict: NavigationCurrentEntryChangeEventInit): NavigationCurrentEntryChangeEvent
  prototype: NavigationCurrentEntryChangeEvent
}

interface NavigationCurrentEntryChangeEventInit extends EventInit {
  navigationType?: NavigationType
  from: NavigationHistoryEntry
}

interface NavigateEvent extends Event {
  readonly navigationType: NavigationType
  readonly destination: NavigationDestination
  readonly canIntercept: boolean
  readonly userInitiated: boolean
  readonly hashChange: boolean
  readonly signal: AbortSignal
  readonly formData?: FormData
  readonly downloadRequest?: string
  readonly info: any
  readonly hasUAVisualTransition: boolean

  intercept(options?: NavigationInterceptOptions): void
  scroll(): void
}

declare var NavigateEvent: {
  new(type: string, eventInitDict: NavigateEventInit): NavigateEvent
  prototype: NavigateEvent
}

interface NavigateEventInit extends EventInit {
  navigationType?: NavigationType
  destination: NavigationDestination
  canIntercept?: boolean
  userInitiated?: boolean
  hashChange?: boolean
  signal: AbortSignal
  formData?: FormData
  downloadRequest?: string
  info: any
  hasUAVisualTransition?: boolean
}

interface NavigationInterceptOptions {
  handler?: NavigationInterceptHandler
  focusReset?: NavigationFocusReset
  scroll?: NavigationScrollBehavior
}

enum NavigationFocusReset {
  "after-transition",
  "manual",
}

enum NavigationScrollBehavior {
  "after-transition",
  "manual",
}

type NavigationInterceptHandler = () => Promise<undefined>

interface NavigationDestination {
  readonly url: string
  readonly key: string
  readonly id: string
  readonly index: number
  readonly sameDocument: boolean

  getState(): any
}

declare var NavigationDestination: {
  prototype: NavigationDestination
}

interface Element {
  hasPointerCapture(pointerId: number): boolean
  releasePointerCapture(pointerId: number): void
  setPointerCapture(pointerId: number): void
}

interface GlobalEventHandlers {
  ongotpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null
  onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null
  onpointercancel: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null
  onpointerdown: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null
  onpointerenter: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null
  onpointerleave: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null
  onpointermove: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null
  onpointerout: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null
  onpointerover: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null
  onpointerrawupdate: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null
  onpointerup: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null
}

interface Navigator {
  readonly maxTouchPoints: number
}

interface GlobalEventHandlers {
  ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined
  ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined
  ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined
  ontouchstart?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined
}

interface Touch {
  readonly clientX: number
  readonly clientY: number
  readonly force: number
  readonly identifier: number
  readonly pageX: number
  readonly pageY: number
  readonly radiusX: number
  readonly radiusY: number
  readonly rotationAngle: number
  readonly screenX: number
  readonly screenY: number
  readonly target: EventTarget
}

declare var Touch: {
  prototype: Touch
  new(touchInitDict: TouchInit): Touch
}

interface TouchInit {
  altitudeAngle?: number
  azimuthAngle?: number
  clientX?: number
  clientY?: number
  force?: number
  identifier: number
  pageX?: number
  pageY?: number
  radiusX?: number
  radiusY?: number
  rotationAngle?: number
  screenX?: number
  screenY?: number
  target: EventTarget
  touchType?: TouchType
}

interface TouchEvent extends UIEvent {
  readonly altKey: boolean
  readonly changedTouches: TouchList
  readonly ctrlKey: boolean
  readonly metaKey: boolean
  readonly shiftKey: boolean
  readonly targetTouches: TouchList
  readonly touches: TouchList
}

declare var TouchEvent: {
  prototype: TouchEvent
  new(type: string, eventInitDict?: TouchEventInit): TouchEvent
}

interface TouchEventInit extends EventModifierInit {
  changedTouches?: Touch[]
  targetTouches?: Touch[]
  touches?: Touch[]
}

interface TouchList {
  readonly length: number
  item(index: number): Touch | null
  [index: number]: Touch
}

declare var TouchList: {
  prototype: TouchList
}

type TouchType = 'direct' | 'stylus'

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
}