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[]>
}

interface CookieStore extends EventTarget {
  get(name: string): Promise<CookieListItem | undefined>
  get(options?: CookieStoreGetOptions): Promise<CookieListItem | undefined>

  getAll(name: string): Promise<CookieList>
  getAll(options?: CookieStoreGetOptions): Promise<CookieList>

  set(name: string, value: string): Promise<undefined>
  set(options: CookieInit): Promise<undefined>

  delete(name: string): Promise<undefined>
  delete(options: CookieStoreDeleteOptions): Promise<undefined>

  onchange: ((this: CookieStore, ev: CookieChangeEvent) => any) | null
}

interface CookieStoreGetOptions {
  name: string
  url: string
}

enum CookieSameSite {
  "strict",
  "lax",
  "none"
}

interface CookieInit {
  name: string
  value: string
  expires?: DOMHighResTimeStamp | null
  domain?: string | null
  path?: string
  sameSite?: CookieSameSite
  partitioned?: boolean
}

interface CookieStoreDeleteOptions {
  name: string
  domain?: string | null
  path?: string
  partitione?: boolean
}

interface CookieListItem {
  name: string
  value: string
  domain?: string
  path: string
  expires?: DOMHighResTimeStamp
  secure: boolean
  sameSite: CookieSameSite
  partitioned: boolean
}

type CookieList = Array<CookieListItem>

interface CookieStoreManager {
  subscribe(subscriptions: Array<CookieStoreGetOptions>): Promise<undefined>
  getSubscriptions(): Promise<Array<CookieStoreGetOptions>>
  unsubscribe(subscriptions: Array<CookieStoreGetOptions>): Promise<undefined>
}

interface ServiceWorkerRegistration {
  readonly cookies: CookieStoreManager
}

interface CookieChangeEvent extends Event {
  constructor(type: string, eventInitDict?: CookieChangeEventInit)
  readonly changed: ReadonlyArray<CookieListItem>
  readonly deleted: ReadonlyArray<CookieListItem>
}

interface CookieChangeEventInit extends EventInit {
  changed: CookieList
  deleted: CookieList
}

interface ExtendableCookieChangeEvent extends ExtendableEvent {
  constructor(type: string, eventInitDict?: ExtendableCookieChangeEventInit)
  readonly changed: ReadonlyArray<CookieListItem>
  readonly deleted: ReadonlyArray<CookieListItem>
}

interface ExtendableCookieChangeEventInit extends ExtendableEventInit {
  changed: CookieList
  deleted: CookieList
}

interface Window {
  readonly cookieStore: CookieStore
}

interface ServiceWorkerGlobalScope {
  readonly cookieStore: CookieStore

  oncookiechange: ((this: ServiceWorkerGlobalScope, ev: ExtendableCookieChangeEvent) => any) | null
}

interface NavigatorUABrandVersion {
  brand: string
  version: string
}

interface UADataValues {
  architecture: string
  bitness: string
  brands: NavigatorUABrandVersion[]
  formFactor: string[]
  fullVersionList: NavigatorUABrandVersion[]
  model: string
  mobile: boolean
  platform: string
  platformVersion: string
  /** @deprecated */ uaFullVersion: string
  wow64: boolean
}

interface UALowEntropyJSON {
  brands: NavigatorUABrandVersion[]
  mobile: boolean
  platform: string
}

interface NavigatorUAData {
  readonly brands: ReadonlyArray<>
  readonly mobile: boolean
  readonly platform: string
  getHighEntropyValues(hints: string[]): Promise<UADataValues>
  toJSON(): UALowEntropyJSON
}

interface NavigatorUA {
  readonly userAgentData: NavigatorUAData
}

interface Navigator extends NavigatorUA {}
interface WorkerNavigator extends NavigatorUA {}

type TaskPriority = "user-blocking" | "user-visible" | "background"

interface SchedulerPostTaskOptions {
  signal?: AbortSignal
  priority?: TaskPriority
  delay?: number
}

type SchedulerPostTaskCallback = Function

interface Scheduler {
  postTask(callback: SchedulerPostTaskCallback, options?: SchedulerPostTaskOptions): Promise<any>
}

interface TaskPriorityChangeEvent extends Event {
  constructor(type: string, priorityChangeEventInitDict: TaskPriorityChangeEventInit)

  readonly previousPriority: TaskPriority
}

interface TaskPriorityChangeEventInit extends EventInit {
  previousPriority: TaskPriority
}

interface TaskControllerInit {
  priority: TaskPriority
}

interface TaskController extends AbortController {
  constructor(init: TaskControllerInit)

  setPriority(priority: TaskPriority): void
}

interface TaskSignal extends AbortSignal {
  readonly priority: TaskPriority

  onprioritychange: ((this: TaskSignal, ev: TaskPriorityChangeEvent) => any) | null
}

interface WindowOrWorkerGlobalScope {
  readonly scheduler: Scheduler
}

interface Navigator {
  readonly scheduling: Scheduling
}

interface Scheduling {
  isInputPending(isInputPendingOptions?: IsInputPendingOptions): boolean
}

interface IsInputPendingOptions {
  includeContinuous: boolean
}

interface Screen {
  readonly orientation: ScreenOrientation
}

interface ScreenOrientation extends EventTarget {
  readonly angle: number
  readonly type: OrientationType
  onchange: ((this: ScreenOrientation, ev: Event) => any) | null
  lock(orientation: OrientationLockType): Promise<void>
  unlock(): void
}

type OrientationLockType = "any" | "landscape" | "landscape-primary" | "landscape-secondary" | "natural" | "portrait" | "portrait-primary" | "portrait-secondary"

type OrientationType = "landscape-primary" | "landscape-secondary" | "portrait-primary" | "portrait-secondary"