1// flow-typed signature: 09630545c584c3b212588a2390c257d02// flow-typed version: baae4b8bcc/bom/flow_>=v0.261.x34/* BOM */56declare class Screen {7  +availHeight: number;8  +availWidth: number;9  +availLeft: number;10  +availTop: number;11  +top: number;12  +left: number;13  +colorDepth: number;14  +pixelDepth: number;15  +width: number;16  +height: number;17  +orientation?: {18    lock(): Promise<void>,19    unlock(): void,20    angle: number,21    onchange: () => mixed,22    type:23      | 'portrait-primary'24      | 'portrait-secondary'25      | 'landscape-primary'26      | 'landscape-secondary',27    ...28  };29  // deprecated30  mozLockOrientation?: (orientation: string | Array<string>) => boolean;31  mozUnlockOrientation?: () => void;32  mozOrientation?: string;33  onmozorientationchange?: (...args: any[]) => mixed;34}3536declare var screen: Screen;3738declare interface Crypto {39  // Not using $TypedArray as that would include Float32Array and Float64Array which are not accepted40  getRandomValues: <41    T:42      | Int8Array43      | Uint8Array44      | Uint8ClampedArray45      | Int16Array46      | Uint16Array47      | Int32Array48      | Uint32Array49      | BigInt64Array50      | BigUint64Array,51  >(52    typedArray: T53  ) => T;54  randomUUID: () => string;55}56declare var crypto: Crypto;5758declare var window: any;5960type GamepadButton = {61  pressed: boolean,62  value: number,63  ...64};65type GamepadHapticActuator = {66  type: 'vibration',67  pulse(value: number, duration: number): Promise<boolean>,68  ...69};70type GamepadPose = {71  angularAcceleration: null | Float32Array,72  angularVelocity: null | Float32Array,73  hasOrientation: boolean,74  hasPosition: boolean,75  linearAcceleration: null | Float32Array,76  linearVelocity: null | Float32Array,77  orientation: null | Float32Array,78  position: null | Float32Array,79  ...80};81type Gamepad = {82  axes: number[],83  buttons: GamepadButton[],84  connected: boolean,85  displayId?: number,86  hapticActuators?: GamepadHapticActuator[],87  hand?: '' | 'left' | 'right',88  id: string,89  index: number,90  mapping: string,91  pose?: null | GamepadPose,92  timestamp: number,93  ...94};9596// deprecated97type BatteryManager = {98  +charging: boolean,99  +chargingTime: number,100  +dischargingTime: number,101  +level: number,102  onchargingchange: ?(event: any) => mixed,103  onchargingtimechange: ?(event: any) => mixed,104  ondischargingtimechange: ?(event: any) => mixed,105  onlevelchange: ?(event: any) => mixed,106  ...107};108109// https://wicg.github.io/web-share110type ShareData = {111  title?: string,112  text?: string,113  url?: string,114  ...115};116117type PermissionName =118  | 'geolocation'119  | 'notifications'120  | 'push'121  | 'midi'122  | 'camera'123  | 'microphone'124  | 'speaker'125  | 'usb'126  | 'device-info'127  | 'background-sync'128  | 'bluetooth'129  | 'persistent-storage'130  | 'ambient-light-sensor'131  | 'accelerometer'132  | 'gyroscope'133  | 'magnetometer'134  | 'clipboard-read'135  | 'clipboard-write';136137type PermissionState = 'granted' | 'denied' | 'prompt';138139type PermissionDescriptor = {|140  name: PermissionName,141|};142143type DevicePermissionDescriptor = {|144  deviceId?: string,145  name: 'camera' | 'microphone' | 'speaker',146|};147148type MidiPermissionDescriptor = {|149  name: 'midi',150  sysex?: boolean,151|};152153type PushPermissionDescriptor = {|154  name: 'push',155  userVisibleOnly?: boolean,156|};157158type ClipboardPermissionDescriptor = {|159  name: 'clipboard-read' | 'clipboard-write',160  allowWithoutGesture: boolean,161|};162163type USBPermissionDescriptor = {|164  name: 'usb',165  filters: Array<USBDeviceFilter>,166  exclusionFilters: Array<USBDeviceFilter>,167|};168169type FileSystemHandlePermissionDescriptor = {|170  mode: 'read' | 'readwrite',171|};172173declare class PermissionStatus extends EventTarget {174  onchange: ?(event: any) => mixed;175  +state: PermissionState;176}177178declare class Permissions {179  query(180    permissionDesc:181      | DevicePermissionDescriptor182      | MidiPermissionDescriptor183      | PushPermissionDescriptor184      | ClipboardPermissionDescriptor185      | USBPermissionDescriptor186      | PermissionDescriptor187  ): Promise<PermissionStatus>;188}189190type MIDIPortType = 'input' | 'output';191type MIDIPortDeviceState = 'connected' | 'disconnected';192type MIDIPortConnectionState = 'open' | 'closed' | 'pending';193194type MIDIOptions = {|195  sysex: boolean,196  software: boolean,197|};198199type MIDIMessageEvent$Init = Event$Init & {200  data: Uint8Array,201  ...202};203204declare class MIDIMessageEvent extends Event {205  constructor(type: string, eventInitDict: MIDIMessageEvent$Init): void;206  +data: Uint8Array;207}208209type MIDIConnectionEvent$Init = Event$Init & {210  port: MIDIPort,211  ...212};213214declare class MIDIConnectionEvent extends Event {215  constructor(type: string, eventInitDict: MIDIConnectionEvent$Init): void;216  +port: MIDIPort;217}218219declare class MIDIPort extends EventTarget {220  +id: string;221  +manufacturer?: string;222  +name?: string;223  +type: MIDIPortType;224  +version?: string;225  +state: MIDIPortDeviceState;226  +connection: MIDIPortConnectionState;227  onstatechange: ?(ev: MIDIConnectionEvent) => mixed;228  open(): Promise<MIDIPort>;229  close(): Promise<MIDIPort>;230}231232declare class MIDIInput extends MIDIPort {233  onmidimessage: ?(ev: MIDIMessageEvent) => mixed;234}235236declare class MIDIOutput extends MIDIPort {237  send(data: Iterable<number>, timestamp?: number): void;238  clear(): void;239}240241declare class MIDIInputMap extends $ReadOnlyMap<string, MIDIInput> {}242243declare class MIDIOutputMap extends $ReadOnlyMap<string, MIDIOutput> {}244245declare class MIDIAccess extends EventTarget {246  +inputs: MIDIInputMap;247  +outputs: MIDIOutputMap;248  +sysexEnabled: boolean;249  onstatechange: ?(ev: MIDIConnectionEvent) => mixed;250}251252declare class NavigatorID {253  appName: 'Netscape';254  appCodeName: 'Mozilla';255  product: 'Gecko';256  appVersion: string;257  platform: string;258  userAgent: string;259}260261declare class NavigatorLanguage {262  +language: string;263  +languages: $ReadOnlyArray<string>;264}265266declare class NavigatorContentUtils {267  registerContentHandler(mimeType: string, uri: string, title: string): void;268  registerProtocolHandler(protocol: string, uri: string, title: string): void;269}270271declare class NavigatorCookies {272  +cookieEnabled: boolean;273}274275declare class NavigatorPlugins {276  +plugins: PluginArray;277  +mimeTypes: MimeTypeArray;278  javaEnabled(): boolean;279}280281declare class NavigatorOnLine {282  +onLine: boolean;283}284285declare class NavigatorConcurrentHardware {286  +hardwareConcurrency: number;287}288289declare class NavigatorStorage {290  storage?: StorageManager;291}292293declare class StorageManager {294  persist: () => Promise<boolean>;295  persisted: () => Promise<boolean>;296  estimate?: () => Promise<StorageEstimate>;297  getDirectory: () => Promise<FileSystemDirectoryHandle>;298}299300type StorageManagerRegisteredEndpoint =301  | 'caches'302  | 'indexedDB'303  | 'localStorage'304  | 'serviceWorkerRegistrations'305  | 'sessionStorage';306307type StorageManagerUsageDetails = {[StorageManagerRegisteredEndpoint]: number};308309declare class StorageEstimate {310  constructor(311    usage: number,312    quota: number,313    usageDetails?: StorageManagerUsageDetails314  ): void;315  +usage: number;316  +quota: number;317318  // Not a part of the standard319  +usageDetails?: StorageManagerUsageDetails;320}321322declare class Navigator323  mixins324    NavigatorID,325    NavigatorLanguage,326    NavigatorOnLine,327    NavigatorContentUtils,328    NavigatorCookies,329    NavigatorPlugins,330    NavigatorConcurrentHardware,331    NavigatorStorage332{333  productSub: '20030107' | '20100101';334  vendor: '' | 'Google Inc.' | 'Apple Computer, Inc';335  vendorSub: '';336337  activeVRDisplays?: VRDisplay[];338  appCodeName: 'Mozilla';339  buildID: string;340  doNotTrack: string | null;341  geolocation: Geolocation;342  mediaDevices?: MediaDevices;343  usb?: USB;344  maxTouchPoints: number;345  permissions: Permissions;346  serviceWorker?: ServiceWorkerContainer;347  getGamepads?: () => Array<Gamepad | null>;348  webkitGetGamepads?: Function;349  mozGetGamepads?: Function;350  mozGamepads?: any;351  gamepads?: any;352  webkitGamepads?: any;353  getVRDisplays?: () => Promise<VRDisplay[]>;354  registerContentHandler(mimeType: string, uri: string, title: string): void;355  registerProtocolHandler(protocol: string, uri: string, title: string): void;356  requestMIDIAccess?: (options?: MIDIOptions) => Promise<MIDIAccess>;357  requestMediaKeySystemAccess?: (358    keySystem: string,359    supportedConfigurations: any[]360  ) => Promise<any>;361  sendBeacon?: (url: string, data?: BodyInit) => boolean;362  vibrate?: (pattern: number | number[]) => boolean;363  mozVibrate?: (pattern: number | number[]) => boolean;364  webkitVibrate?: (pattern: number | number[]) => boolean;365  canShare?: (shareData?: ShareData) => boolean;366  share?: (shareData: ShareData) => Promise<void>;367  clipboard: Clipboard;368  credentials?: CredMgmtCredentialsContainer;369  globalPrivacyControl?: boolean;370371  // deprecated372  getBattery?: () => Promise<BatteryManager>;373  mozGetBattery?: () => Promise<BatteryManager>;374375  // deprecated376  getUserMedia?: Function;377  webkitGetUserMedia?: Function;378  mozGetUserMedia?: Function;379  msGetUserMedia?: Function;380381  // Gecko382  taintEnabled?: () => false;383  oscpu: string;384}385386declare class Clipboard extends EventTarget {387  read(): Promise<DataTransfer>;388  readText(): Promise<string>;389  write(data: $ReadOnlyArray<ClipboardItem>): Promise<void>;390  writeText(data: string): Promise<void>;391}392393declare var navigator: Navigator;394395declare class MimeType {396  type: string;397  description: string;398  suffixes: string;399  enabledPlugin: Plugin;400}401402declare class MimeTypeArray {403  length: number;404  item(index: number): MimeType;405  namedItem(name: string): MimeType;406  [key: number | string]: MimeType;407}408409declare class Plugin {410  description: string;411  filename: string;412  name: string;413  version?: string; // Gecko only414  length: number;415  item(index: number): MimeType;416  namedItem(name: string): MimeType;417  [key: number | string]: MimeType;418}419420declare class PluginArray {421  length: number;422  item(index: number): Plugin;423  namedItem(name: string): Plugin;424  refresh(): void;425  [key: number | string]: Plugin;426}427428// https://www.w3.org/TR/hr-time-2/#dom-domhighrestimestamp429// https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp430declare type DOMHighResTimeStamp = number;431432// https://www.w3.org/TR/navigation-timing-2/433declare class PerformanceTiming {434  connectEnd: number;435  connectStart: number;436  domainLookupEnd: number;437  domainLookupStart: number;438  domComplete: number;439  domContentLoadedEventEnd: number;440  domContentLoadedEventStart: number;441  domInteractive: number;442  domLoading: number;443  fetchStart: number;444  loadEventEnd: number;445  loadEventStart: number;446  navigationStart: number;447  redirectEnd: number;448  redirectStart: number;449  requestStart: number;450  responseEnd: number;451  responseStart: number;452  secureConnectionStart: number;453  unloadEventEnd: number;454  unloadEventStart: number;455}456457declare class PerformanceNavigation {458  TYPE_NAVIGATE: 0;459  TYPE_RELOAD: 1;460  TYPE_BACK_FORWARD: 2;461  TYPE_RESERVED: 255;462463  type: 0 | 1 | 2 | 255;464  redirectCount: number;465}466467type PerformanceEntryFilterOptions = {468  name: string,469  entryType: string,470  initiatorType: string,471  ...472};473474// https://www.w3.org/TR/performance-timeline-2/475declare class PerformanceEntry {476  name: string;477  entryType: string;478  startTime: DOMHighResTimeStamp;479  duration: DOMHighResTimeStamp;480  toJSON(): string;481}482483// https://w3c.github.io/server-timing/#the-performanceservertiming-interface484declare class PerformanceServerTiming {485  description: string;486  duration: DOMHighResTimeStamp;487  name: string;488  toJSON(): string;489}490491// https://www.w3.org/TR/resource-timing-2/#sec-performanceresourcetiming492// https://w3c.github.io/server-timing/#extension-to-the-performanceresourcetiming-interface493declare class PerformanceResourceTiming extends PerformanceEntry {494  initiatorType: string;495  nextHopProtocol: string;496  workerStart: number;497  redirectStart: number;498  redirectEnd: number;499  fetchStart: number;500  domainLookupStart: number;501  domainLookupEnd: number;502  connectStart: number;503  connectEnd: number;504  secureConnectionStart: number;505  requestStart: number;506  responseStart: number;507  responseEnd: number;508  transferSize: string;509  encodedBodySize: number;510  decodedBodySize: number;511  serverTiming: Array<PerformanceServerTiming>;512}513514// https://w3c.github.io/event-timing/#sec-performance-event-timing515declare class PerformanceEventTiming extends PerformanceEntry {516  processingStart: number;517  processingEnd: number;518  cancelable: boolean;519  target: ?Node;520  interactionId: number;521}522523// https://w3c.github.io/longtasks/#taskattributiontiming524declare class TaskAttributionTiming extends PerformanceEntry {525  containerType: string;526  containerSrc: string;527  containerId: string;528  containerName: string;529}530531// https://w3c.github.io/longtasks/#sec-PerformanceLongTaskTiming532declare class PerformanceLongTaskTiming extends PerformanceEntry {533  attribution: $ReadOnlyArray<TaskAttributionTiming>;534}535536// https://www.w3.org/TR/navigation-timing-2/537declare class PerformanceNavigationTiming extends PerformanceResourceTiming {538  unloadEventStart: number;539  unloadEventEnd: number;540  domInteractive: number;541  domContentLoadedEventStart: number;542  domContentLoadedEventEnd: number;543  domComplete: number;544  loadEventStart: number;545  loadEventEnd: number;546  type: 'navigate' | 'reload' | 'back_forward' | 'prerender';547  redirectCount: number;548}549550// https://www.w3.org/TR/user-timing/#extensions-performance-interface551declare type PerformanceMarkOptions = {|552  detail?: mixed,553  startTime?: number,554|};555556declare type PerformanceMeasureOptions = {|557  detail?: mixed,558  start?: number | string,559  end?: number | string,560  duration?: number,561|};562563type EventCountsForEachCallbackType =564  | (() => void)565  | ((value: number) => void)566  | ((value: number, key: string) => void)567  | ((value: number, key: string, map: Map<string, number>) => void);568569// https://www.w3.org/TR/event-timing/#eventcounts570declare interface EventCounts {571  size: number;572573  entries(): Iterator<[string, number]>;574  forEach(callback: EventCountsForEachCallbackType): void;575  get(key: string): ?number;576  has(key: string): boolean;577  keys(): Iterator<string>;578  values(): Iterator<number>;579}580581declare class Performance {582  eventCounts: EventCounts;583584  // deprecated585  navigation: PerformanceNavigation;586  timing: PerformanceTiming;587588  onresourcetimingbufferfull: (ev: any) => mixed;589  clearMarks(name?: string): void;590  clearMeasures(name?: string): void;591  clearResourceTimings(): void;592  getEntries(options?: PerformanceEntryFilterOptions): Array<PerformanceEntry>;593  getEntriesByName(name: string, type?: string): Array<PerformanceEntry>;594  getEntriesByType(type: string): Array<PerformanceEntry>;595  mark(name: string, options?: PerformanceMarkOptions): void;596  measure(597    name: string,598    startMarkOrOptions?: string | PerformanceMeasureOptions,599    endMark?: string600  ): void;601  now(): DOMHighResTimeStamp;602  setResourceTimingBufferSize(maxSize: number): void;603  toJSON(): string;604}605606declare var performance: Performance;607608type PerformanceEntryList = PerformanceEntry[];609610declare interface PerformanceObserverEntryList {611  getEntries(): PerformanceEntryList;612  getEntriesByType(type: string): PerformanceEntryList;613  getEntriesByName(name: string, type: ?string): PerformanceEntryList;614}615616type PerformanceObserverInit = {617  entryTypes?: string[],618  type?: string,619  buffered?: boolean,620  ...621};622623declare class PerformanceObserver {624  constructor(625    callback: (626      entries: PerformanceObserverEntryList,627      observer: PerformanceObserver628    ) => mixed629  ): void;630631  observe(options: ?PerformanceObserverInit): void;632  disconnect(): void;633  takeRecords(): PerformanceEntryList;634635  static supportedEntryTypes: string[];636}637638declare class History {639  length: number;640  scrollRestoration: 'auto' | 'manual';641  state: any;642  back(): void;643  forward(): void;644  go(delta?: number): void;645  pushState(statedata: any, title: string, url?: string): void;646  replaceState(statedata: any, title: string, url?: string): void;647}648649declare var history: History;650651declare class Location {652  ancestorOrigins: string[];653  hash: string;654  host: string;655  hostname: string;656  href: string;657  origin: string;658  pathname: string;659  port: string;660  protocol: string;661  search: string;662  assign(url: string): void;663  reload(flag?: boolean): void;664  replace(url: string): void;665  toString(): string;666}667668declare var location: Location;669670///////////////////////////////////////////////////////////////////////////////671672declare class DOMParser {673  parseFromString(source: string | TrustedHTML, mimeType: string): Document;674}675676type FormDataEntryValue = string | File;677678declare class FormData {679  constructor(form?: HTMLFormElement, submitter?: HTMLElement | null): void;680681  has(name: string): boolean;682  get(name: string): ?FormDataEntryValue;683  getAll(name: string): Array<FormDataEntryValue>;684685  set(name: string, value: FormDataEntryValue): void;686  set(name: string, value: Blob, filename?: string): void;687  set(name: string, value: File, filename?: string): void;688689  append(name: string, value: FormDataEntryValue): void;690  append(name: string, value: Blob, filename?: string): void;691  append(name: string, value: File, filename?: string): void;692693  delete(name: string): void;694695  keys(): Iterator<string>;696  values(): Iterator<FormDataEntryValue>;697  entries(): Iterator<[string, FormDataEntryValue]>;698}699700declare type IntersectionObserverEntry = {701  boundingClientRect: DOMRectReadOnly,702  intersectionRatio: number,703  intersectionRect: DOMRectReadOnly,704  isIntersecting: boolean,705  rootBounds: DOMRectReadOnly,706  target: Element,707  time: DOMHighResTimeStamp,708  ...709};710711declare type IntersectionObserverCallback = (712  entries: Array<IntersectionObserverEntry>,713  observer: IntersectionObserver714) => mixed;715716declare type IntersectionObserverOptions = {717  root?: Node | null,718  rootMargin?: string,719  threshold?: number | Array<number>,720  ...721};722723declare class IntersectionObserver {724  constructor(725    callback: IntersectionObserverCallback,726    options?: IntersectionObserverOptions727  ): void;728  root: Element | null;729  rootMargin: string;730  scrollMargin: string;731  thresholds: number[];732  observe(target: Element): void;733  unobserve(target: Element): void;734  takeRecords(): Array<IntersectionObserverEntry>;735  disconnect(): void;736}737738declare interface ResizeObserverSize {739  +inlineSize: number;740  +blockSize: number;741}742743declare interface ResizeObserverEntry {744  /**745   * The Element whose size has changed.746   */747  +target: Element;748  /**749   * Element's content rect when ResizeObserverCallback is invoked.750   *751   * Legacy, may be deprecated in the future.752   */753  +contentRect: DOMRectReadOnly;754  /**755   * An array containing the Element's border box size when756   * ResizeObserverCallback is invoked.757   */758  +borderBoxSize: $ReadOnlyArray<ResizeObserverSize>;759  /**760   * An array containing the Element's content rect size when761   * ResizeObserverCallback is invoked.762   */763  +contentBoxSize: $ReadOnlyArray<ResizeObserverSize>;764  /**765   * An array containing the Element's content rect size in integral device766   * pixels when ResizeObserverCallback is invoked.767   *768   * Not implemented in Firefox or Safari as of July 2021769   */770  +devicePixelContentBoxSize?: $ReadOnlyArray<ResizeObserverSize> | void;771}772773/**774 * ResizeObserver can observe different kinds of CSS sizes:775 * - border-box : size of box border area as defined in CSS2.776 * - content-box : size of content area as defined in CSS2.777 * - device-pixel-content-box : size of content area as defined in CSS2, in device778 *     pixels, before applying any CSS transforms on the element or its ancestors.779 *     This size must contain integer values.780 */781type ResizeObserverBoxOptions =782  | 'border-box'783  | 'content-box'784  | 'device-pixel-content-box';785786declare type ResizeObserverOptions = {787  box?: ResizeObserverBoxOptions,788  ...789};790791/**792 * The ResizeObserver interface is used to observe changes to Element's size.793 */794declare class ResizeObserver {795  constructor(796    callback: (797      entries: ResizeObserverEntry[],798      observer: ResizeObserver799    ) => mixed800  ): void;801  /**802   * Adds target to the list of observed elements.803   */804  observe(target: Element, options?: ResizeObserverOptions): void;805  /**806   * Removes target from the list of observed elements.807   */808  unobserve(target: Element): void;809  disconnect(): void;810}811812declare class CloseEvent extends Event {813  code: number;814  reason: string;815  wasClean: boolean;816}817818declare class WebSocket extends EventTarget {819  static CONNECTING: 0;820  static OPEN: 1;821  static CLOSING: 2;822  static CLOSED: 3;823  constructor(url: string, protocols?: string | Array<string>): void;824  protocol: string;825  readyState: number;826  bufferedAmount: number;827  extensions: string;828  onopen: (ev: any) => mixed;829  onmessage: (ev: MessageEvent<>) => mixed;830  onclose: (ev: CloseEvent) => mixed;831  onerror: (ev: any) => mixed;832  binaryType: 'blob' | 'arraybuffer';833  url: string;834  close(code?: number, reason?: string): void;835  send(data: string): void;836  send(data: Blob): void;837  send(data: ArrayBuffer): void;838  send(data: $ArrayBufferView): void;839  CONNECTING: 0;840  OPEN: 1;841  CLOSING: 2;842  CLOSED: 3;843}844845type WorkerOptions = {846  type?: WorkerType,847  credentials?: CredentialsType,848  name?: string,849  ...850};851852declare class Worker extends EventTarget {853  constructor(854    stringUrl: string | TrustedScriptURL,855    workerOptions?: WorkerOptions856  ): void;857  onerror: null | ((ev: any) => mixed);858  onmessage: null | ((ev: MessageEvent<>) => mixed);859  onmessageerror: null | ((ev: MessageEvent<>) => mixed);860  postMessage(message: any, ports?: any): void;861  terminate(): void;862}863864declare class SharedWorker extends EventTarget {865  constructor(stringUrl: string | TrustedScriptURL, name?: string): void;866  constructor(867    stringUrl: string | TrustedScriptURL,868    workerOptions?: WorkerOptions869  ): void;870  port: MessagePort;871  onerror: (ev: any) => mixed;872}873874declare function importScripts(...urls: Array<string | TrustedScriptURL>): void;875876declare class WorkerGlobalScope extends EventTarget {877  // $FlowFixMe[incompatible-variance]878  self: this;879  location: WorkerLocation;880  navigator: WorkerNavigator;881  close(): void;882  importScripts(...urls: Array<string | TrustedScriptURL>): void;883  onerror: (ev: any) => mixed;884  onlanguagechange: (ev: any) => mixed;885  onoffline: (ev: any) => mixed;886  ononline: (ev: any) => mixed;887  onrejectionhandled: (ev: PromiseRejectionEvent) => mixed;888  onunhandledrejection: (ev: PromiseRejectionEvent) => mixed;889}890891declare class DedicatedWorkerGlobalScope extends WorkerGlobalScope {892  onmessage: (ev: MessageEvent<>) => mixed;893  onmessageerror: (ev: MessageEvent<>) => mixed;894  postMessage(message: any, transfer?: Iterable<any>): void;895}896897declare class SharedWorkerGlobalScope extends WorkerGlobalScope {898  name: string;899  onconnect: (ev: MessageEvent<>) => mixed;900}901902declare class WorkerLocation {903  origin: string;904  protocol: string;905  host: string;906  hostname: string;907  port: string;908  pathname: string;909  search: string;910  hash: string;911}912913declare class WorkerNavigator914  mixins915    NavigatorID,916    NavigatorLanguage,917    NavigatorOnLine,918    NavigatorConcurrentHardware,919    NavigatorStorage920{921  permissions: Permissions;922}923924// deprecated925declare class XDomainRequest {926  timeout: number;927  onerror: () => mixed;928  onload: () => mixed;929  onprogress: () => mixed;930  ontimeout: () => mixed;931  +responseText: string;932  +contentType: string;933  open(method: 'GET' | 'POST', url: string): void;934  abort(): void;935  send(data?: string): void;936937  statics: {create(): XDomainRequest, ...};938}939940declare class XMLHttpRequest extends EventTarget {941  static LOADING: number;942  static DONE: number;943  static UNSENT: number;944  static OPENED: number;945  static HEADERS_RECEIVED: number;946  responseBody: any;947  status: number;948  readyState: number;949  responseText: string;950  responseXML: any;951  responseURL: string;952  ontimeout: ProgressEventHandler;953  statusText: string;954  onreadystatechange: (ev: any) => mixed;955  timeout: number;956  onload: ProgressEventHandler;957  response: any;958  withCredentials: boolean;959  onprogress: ProgressEventHandler;960  onabort: ProgressEventHandler;961  responseType: string;962  onloadend: ProgressEventHandler;963  upload: XMLHttpRequestEventTarget;964  onerror: ProgressEventHandler;965  onloadstart: ProgressEventHandler;966  msCaching: string;967  open(968    method: string,969    url: string,970    async?: boolean,971    user?: string,972    password?: string973  ): void;974  send(data?: any): void;975  abort(): void;976  getAllResponseHeaders(): string;977  setRequestHeader(header: string, value: string): void;978  getResponseHeader(header: string): string;979  msCachingEnabled(): boolean;980  overrideMimeType(mime: string): void;981  LOADING: number;982  DONE: number;983  UNSENT: number;984  OPENED: number;985  HEADERS_RECEIVED: number;986987  statics: {create(): XMLHttpRequest, ...};988}989990declare class XMLHttpRequestEventTarget extends EventTarget {991  onprogress: ProgressEventHandler;992  onerror: ProgressEventHandler;993  onload: ProgressEventHandler;994  ontimeout: ProgressEventHandler;995  onabort: ProgressEventHandler;996  onloadstart: ProgressEventHandler;997  onloadend: ProgressEventHandler;998}9991000declare class XMLSerializer {1001  serializeToString(target: Node): string;1002}10031004declare class Geolocation {1005  getCurrentPosition(1006    success: (position: Position) => mixed,1007    error?: (error: PositionError) => mixed,1008    options?: PositionOptions1009  ): void;1010  watchPosition(1011    success: (position: Position) => mixed,1012    error?: (error: PositionError) => mixed,1013    options?: PositionOptions1014  ): number;1015  clearWatch(id: number): void;1016}10171018declare class Position {1019  coords: Coordinates;1020  timestamp: number;1021}10221023declare class Coordinates {1024  latitude: number;1025  longitude: number;1026  altitude?: number;1027  accuracy: number;1028  altitudeAccuracy?: number;1029  heading?: number;1030  speed?: number;1031}10321033declare class PositionError {1034  code: number;1035  message: string;1036  PERMISSION_DENIED: 1;1037  POSITION_UNAVAILABLE: 2;1038  TIMEOUT: 3;1039}10401041type PositionOptions = {1042  enableHighAccuracy?: boolean,1043  timeout?: number,1044  maximumAge?: number,1045  ...1046};10471048type AudioContextState = 'suspended' | 'running' | 'closed';10491050// deprecated1051type AudioProcessingEvent$Init = Event$Init & {1052  playbackTime: number,1053  inputBuffer: AudioBuffer,1054  outputBuffer: AudioBuffer,1055  ...1056};10571058// deprecated1059declare class AudioProcessingEvent extends Event {1060  constructor(type: string, eventInitDict: AudioProcessingEvent$Init): void;10611062  +playbackTime: number;1063  +inputBuffer: AudioBuffer;1064  +outputBuffer: AudioBuffer;1065}10661067type OfflineAudioCompletionEvent$Init = Event$Init & {1068  renderedBuffer: AudioBuffer,1069  ...1070};10711072declare class OfflineAudioCompletionEvent extends Event {1073  constructor(1074    type: string,1075    eventInitDict: OfflineAudioCompletionEvent$Init1076  ): void;10771078  +renderedBuffer: AudioBuffer;1079}10801081declare class BaseAudioContext extends EventTarget {1082  currentTime: number;1083  destination: AudioDestinationNode;1084  listener: AudioListener;1085  sampleRate: number;1086  state: AudioContextState;1087  onstatechange: (ev: any) => mixed;1088  createBuffer(1089    numOfChannels: number,1090    length: number,1091    sampleRate: number1092  ): AudioBuffer;1093  createBufferSource(myMediaElement?: HTMLMediaElement): AudioBufferSourceNode;1094  createMediaElementSource(1095    myMediaElement: HTMLMediaElement1096  ): MediaElementAudioSourceNode;1097  createMediaStreamSource(stream: MediaStream): MediaStreamAudioSourceNode;1098  createMediaStreamDestination(): MediaStreamAudioDestinationNode;10991100  // deprecated1101  createScriptProcessor(1102    bufferSize: number,1103    numberOfInputChannels: number,1104    numberOfOutputChannels: number1105  ): ScriptProcessorNode;11061107  createAnalyser(): AnalyserNode;1108  createBiquadFilter(): BiquadFilterNode;1109  createChannelMerger(numberOfInputs?: number): ChannelMergerNode;1110  createChannelSplitter(numberOfInputs?: number): ChannelSplitterNode;1111  createConstantSource(): ConstantSourceNode;1112  createConvolver(): ConvolverNode;1113  createDelay(maxDelayTime?: number): DelayNode;1114  createDynamicsCompressor(): DynamicsCompressorNode;1115  createGain(): GainNode;1116  createIIRFilter(1117    feedforward: Float32Array,1118    feedback: Float32Array1119  ): IIRFilterNode;1120  createOscillator(): OscillatorNode;1121  createPanner(): PannerNode;1122  createStereoPanner(): StereoPannerNode;1123  createPeriodicWave(1124    real: Float32Array,1125    img: Float32Array,1126    options?: {disableNormalization: boolean, ...}1127  ): PeriodicWave;1128  createStereoPanner(): StereoPannerNode;1129  createWaveShaper(): WaveShaperNode;1130  decodeAudioData(1131    arrayBuffer: ArrayBuffer,1132    decodeSuccessCallback: (decodedData: AudioBuffer) => mixed,1133    decodeErrorCallback: (err: DOMError) => mixed1134  ): void;1135  decodeAudioData(arrayBuffer: ArrayBuffer): Promise<AudioBuffer>;1136}11371138declare class AudioTimestamp {1139  contextTime: number;1140  performanceTime: number;1141}11421143declare class AudioContext extends BaseAudioContext {1144  constructor(options?: {|1145    latencyHint?: 'balanced' | 'interactive' | 'playback' | number,1146    sampleRate?: number,1147  |}): AudioContext;1148  baseLatency: number;1149  outputLatency: number;1150  getOutputTimestamp(): AudioTimestamp;1151  resume(): Promise<void>;1152  suspend(): Promise<void>;1153  close(): Promise<void>;1154  createMediaElementSource(1155    myMediaElement: HTMLMediaElement1156  ): MediaElementAudioSourceNode;1157  createMediaStreamSource(1158    myMediaStream: MediaStream1159  ): MediaStreamAudioSourceNode;1160  createMediaStreamTrackSource(1161    myMediaStreamTrack: MediaStreamTrack1162  ): MediaStreamTrackAudioSourceNode;1163  createMediaStreamDestination(): MediaStreamAudioDestinationNode;1164}11651166declare class OfflineAudioContext extends BaseAudioContext {1167  startRendering(): Promise<AudioBuffer>;1168  suspend(suspendTime: number): Promise<void>;1169  length: number;1170  oncomplete: (ev: OfflineAudioCompletionEvent) => mixed;1171}11721173declare class AudioNode extends EventTarget {1174  context: AudioContext;1175  numberOfInputs: number;1176  numberOfOutputs: number;1177  channelCount: number;1178  channelCountMode: 'max' | 'clamped-max' | 'explicit';1179  channelInterpretation: 'speakers' | 'discrete';1180  connect(audioNode: AudioNode, output?: number, input?: number): AudioNode;1181  connect(destination: AudioParam, output?: number): void;1182  disconnect(destination?: AudioNode, output?: number, input?: number): void;1183}11841185declare class AudioParam extends AudioNode {1186  value: number;1187  defaultValue: number;1188  setValueAtTime(value: number, startTime: number): this;1189  linearRampToValueAtTime(value: number, endTime: number): this;1190  exponentialRampToValueAtTime(value: number, endTime: number): this;1191  setTargetAtTime(1192    target: number,1193    startTime: number,1194    timeConstant: number1195  ): this;1196  setValueCurveAtTime(1197    values: Float32Array,1198    startTime: number,1199    duration: number1200  ): this;1201  cancelScheduledValues(startTime: number): this;1202}12031204declare class AudioDestinationNode extends AudioNode {1205  maxChannelCount: number;1206}12071208declare class AudioListener extends AudioNode {1209  positionX: AudioParam;1210  positionY: AudioParam;1211  positionZ: AudioParam;1212  forwardX: AudioParam;1213  forwardY: AudioParam;1214  forwardZ: AudioParam;1215  upX: AudioParam;1216  upY: AudioParam;1217  upZ: AudioParam;1218  setPosition(x: number, y: number, c: number): void;1219  setOrientation(1220    x: number,1221    y: number,1222    z: number,1223    xUp: number,1224    yUp: number,1225    zUp: number1226  ): void;1227}12281229declare class AudioBuffer {1230  sampleRate: number;1231  length: number;1232  duration: number;1233  numberOfChannels: number;1234  getChannelData(channel: number): Float32Array;1235  copyFromChannel(1236    destination: Float32Array,1237    channelNumber: number,1238    startInChannel?: number1239  ): void;1240  copyToChannel(1241    source: Float32Array,1242    channelNumber: number,1243    startInChannel?: number1244  ): void;1245}12461247declare class AudioBufferSourceNode extends AudioNode {1248  buffer: AudioBuffer;1249  detune: AudioParam;1250  loop: boolean;1251  loopStart: number;1252  loopEnd: number;1253  playbackRate: AudioParam;1254  onended: (ev: any) => mixed;1255  start(when?: number, offset?: number, duration?: number): void;1256  stop(when?: number): void;1257}12581259declare class CanvasCaptureMediaStream extends MediaStream {1260  canvas: HTMLCanvasElement;1261  requestFrame(): void;1262}12631264type DoubleRange = {1265  max?: number,1266  min?: number,1267  ...1268};12691270type LongRange = {1271  max?: number,1272  min?: number,1273  ...1274};12751276type ConstrainBooleanParameters = {1277  exact?: boolean,1278  ideal?: boolean,1279  ...1280};12811282type ConstrainDOMStringParameters = {1283  exact?: string | string[],1284  ideal?: string | string[],1285  ...1286};12871288type ConstrainDoubleRange = {1289  ...DoubleRange,1290  exact?: number,1291  ideal?: number,1292  ...1293};12941295type ConstrainLongRange = {1296  ...LongRange,1297  exact?: number,1298  ideal?: number,1299  ...1300};13011302type MediaTrackSupportedConstraints = {|1303  width: boolean,1304  height: boolean,1305  aspectRatio: boolean,1306  frameRate: boolean,1307  facingMode: boolean,1308  resizeMode: boolean,1309  volume: boolean,1310  sampleRate: boolean,1311  sampleSize: boolean,1312  echoCancellation: boolean,1313  autoGainControl: boolean,1314  noiseSuppression: boolean,1315  latency: boolean,1316  channelCount: boolean,1317  deviceId: boolean,1318  groupId: boolean,1319|};13201321type MediaTrackConstraintSet = {1322  width?: number | ConstrainLongRange,1323  height?: number | ConstrainLongRange,1324  aspectRatio?: number | ConstrainDoubleRange,1325  frameRate?: number | ConstrainDoubleRange,1326  facingMode?: string | string[] | ConstrainDOMStringParameters,1327  resizeMode?: string | string[] | ConstrainDOMStringParameters,1328  volume?: number | ConstrainDoubleRange,1329  sampleRate?: number | ConstrainLongRange,1330  sampleSize?: number | ConstrainLongRange,1331  echoCancellation?: boolean | ConstrainBooleanParameters,1332  autoGainControl?: boolean | ConstrainBooleanParameters,1333  noiseSuppression?: boolean | ConstrainBooleanParameters,1334  latency?: number | ConstrainDoubleRange,1335  channelCount?: number | ConstrainLongRange,1336  deviceId?: string | string[] | ConstrainDOMStringParameters,1337  groupId?: string | string[] | ConstrainDOMStringParameters,1338  ...1339};13401341type MediaTrackConstraints = {1342  ...MediaTrackConstraintSet,1343  advanced?: Array<MediaTrackConstraintSet>,1344  ...1345};13461347type DisplayMediaStreamConstraints = {1348  video?: boolean | MediaTrackConstraints,1349  audio?: boolean | MediaTrackConstraints,1350  ...1351};13521353type MediaStreamConstraints = {1354  audio?: boolean | MediaTrackConstraints,1355  video?: boolean | MediaTrackConstraints,1356  peerIdentity?: string,1357  ...1358};13591360type MediaTrackSettings = {1361  aspectRatio?: number,1362  deviceId?: string,1363  displaySurface?: 'application' | 'browser' | 'monitor' | 'window',1364  echoCancellation?: boolean,1365  facingMode?: string,1366  frameRate?: number,1367  groupId?: string,1368  height?: number,1369  logicalSurface?: boolean,1370  sampleRate?: number,1371  sampleSize?: number,1372  volume?: number,1373  width?: number,1374  ...1375};13761377type MediaTrackCapabilities = {1378  aspectRatio?: number | DoubleRange,1379  deviceId?: string,1380  echoCancellation?: boolean[],1381  facingMode?: string,1382  frameRate?: number | DoubleRange,1383  groupId?: string,1384  height?: number | LongRange,1385  sampleRate?: number | LongRange,1386  sampleSize?: number | LongRange,1387  volume?: number | DoubleRange,1388  width?: number | LongRange,1389  ...1390};13911392declare class MediaDevices extends EventTarget {1393  ondevicechange: (ev: any) => mixed;1394  enumerateDevices: () => Promise<Array<MediaDeviceInfo>>;1395  getSupportedConstraints: () => MediaTrackSupportedConstraints;1396  getDisplayMedia: (1397    constraints?: DisplayMediaStreamConstraints1398  ) => Promise<MediaStream>;1399  getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream>;1400}14011402declare class MediaDeviceInfo {1403  +deviceId: string;1404  +groupId: string;1405  +kind: 'videoinput' | 'audioinput' | 'audiooutput';1406  +label: string;1407}14081409type MediaRecorderOptions = {1410  mimeType?: string,1411  audioBitsPerSecond?: number,1412  videoBitsPerSecond?: number,1413  bitsPerSecond?: number,1414  audioBitrateMode?: 'cbr' | 'vbr',1415  ...1416};14171418declare class MediaRecorder extends EventTarget {1419  constructor(stream: MediaStream, options?: MediaRecorderOptions): void;1420  +stream: MediaStream;1421  +mimeType: string;1422  +state: 'inactive' | 'recording' | 'paused';14231424  onstart: (ev: any) => mixed;1425  onstop: (ev: any) => mixed;1426  ondataavailable: (ev: any) => mixed;1427  onpause: (ev: any) => mixed;1428  onresume: (ev: any) => mixed;1429  onerror: (ev: any) => mixed;14301431  +videoBitsPerSecond: number;1432  +audioBitsPerSecond: number;1433  +audioBitrateMode: 'cbr' | 'vbr';14341435  start(timeslice?: number): void;1436  stop(): void;1437  pause(): void;1438  resume(): void;1439  requestData(): void;14401441  static isTypeSupported(type: string): boolean;1442}14431444declare class MediaStream extends EventTarget {1445  active: boolean;1446  ended: boolean;1447  id: string;1448  onactive: (ev: any) => mixed;1449  oninactive: (ev: any) => mixed;1450  onended: (ev: any) => mixed;1451  onaddtrack: (ev: MediaStreamTrackEvent) => mixed;1452  onremovetrack: (ev: MediaStreamTrackEvent) => mixed;1453  addTrack(track: MediaStreamTrack): void;1454  clone(): MediaStream;1455  getAudioTracks(): MediaStreamTrack[];1456  getTrackById(trackid?: string): ?MediaStreamTrack;1457  getTracks(): MediaStreamTrack[];1458  getVideoTracks(): MediaStreamTrack[];1459  removeTrack(track: MediaStreamTrack): void;1460}14611462declare class MediaStreamTrack extends EventTarget {1463  enabled: boolean;1464  id: string;1465  kind: string;1466  label: string;1467  muted: boolean;1468  readonly: boolean;1469  readyState: 'live' | 'ended';1470  remote: boolean;1471  contentHint?: string;1472  onstarted: (ev: any) => mixed;1473  onmute: (ev: any) => mixed;1474  onunmute: (ev: any) => mixed;1475  onoverconstrained: (ev: any) => mixed;1476  onended: (ev: any) => mixed;1477  getConstraints(): MediaTrackConstraints;1478  applyConstraints(constraints?: MediaTrackConstraints): Promise<void>;1479  getSettings(): MediaTrackSettings;1480  getCapabilities(): MediaTrackCapabilities;1481  clone(): MediaStreamTrack;1482  stop(): void;1483}14841485declare class MediaStreamTrackEvent extends Event {1486  track: MediaStreamTrack;1487}14881489declare class MediaElementAudioSourceNode extends AudioNode {}1490declare class MediaStreamAudioSourceNode extends AudioNode {}1491declare class MediaStreamTrackAudioSourceNode extends AudioNode {}14921493declare class MediaStreamAudioDestinationNode extends AudioNode {1494  stream: MediaStream;1495}14961497// deprecated1498declare class ScriptProcessorNode extends AudioNode {1499  bufferSize: number;1500  onaudioprocess: (ev: AudioProcessingEvent) => mixed;1501}15021503declare class AnalyserNode extends AudioNode {1504  fftSize: number;1505  frequencyBinCount: number;1506  minDecibels: number;1507  maxDecibels: number;1508  smoothingTimeConstant: number;1509  getFloatFrequencyData(array: Float32Array): Float32Array;1510  getByteFrequencyData(array: Uint8Array): Uint8Array;1511  getFloatTimeDomainData(array: Float32Array): Float32Array;1512  getByteTimeDomainData(array: Uint8Array): Uint8Array;1513}15141515declare class BiquadFilterNode extends AudioNode {1516  frequency: AudioParam;1517  detune: AudioParam;1518  Q: AudioParam;1519  gain: AudioParam;1520  type:1521    | 'lowpass'1522    | 'highpass'1523    | 'bandpass'1524    | 'lowshelf'1525    | 'highshelf'1526    | 'peaking'1527    | 'notch'1528    | 'allpass';1529  getFrequencyResponse(1530    frequencyHz: Float32Array,1531    magResponse: Float32Array,1532    phaseResponse: Float32Array1533  ): void;1534}15351536declare class ChannelMergerNode extends AudioNode {}1537declare class ChannelSplitterNode extends AudioNode {}15381539type ConstantSourceOptions = {offset?: number, ...};1540declare class ConstantSourceNode extends AudioNode {1541  constructor(context: BaseAudioContext, options?: ConstantSourceOptions): void;1542  offset: AudioParam;1543  onended: (ev: any) => mixed;1544  start(when?: number): void;1545  stop(when?: number): void;1546}15471548declare class ConvolverNode extends AudioNode {1549  buffer: AudioBuffer;1550  normalize: boolean;1551}15521553declare class DelayNode extends AudioNode {1554  delayTime: number;1555}15561557declare class DynamicsCompressorNode extends AudioNode {1558  threshold: AudioParam;1559  knee: AudioParam;1560  ratio: AudioParam;1561  reduction: AudioParam;1562  attack: AudioParam;1563  release: AudioParam;1564}15651566declare class GainNode extends AudioNode {1567  gain: AudioParam;1568}15691570declare class IIRFilterNode extends AudioNode {1571  getFrequencyResponse(1572    frequencyHz: Float32Array,1573    magResponse: Float32Array,1574    phaseResponse: Float32Array1575  ): void;1576}15771578declare class OscillatorNode extends AudioNode {1579  frequency: AudioParam;1580  detune: AudioParam;1581  type: 'sine' | 'square' | 'sawtooth' | 'triangle' | 'custom';1582  start(when?: number): void;1583  stop(when?: number): void;1584  setPeriodicWave(periodicWave: PeriodicWave): void;1585  onended: (ev: any) => mixed;1586}15871588declare class StereoPannerNode extends AudioNode {1589  pan: AudioParam;1590}15911592declare class PannerNode extends AudioNode {1593  panningModel: 'equalpower' | 'HRTF';1594  distanceModel: 'linear' | 'inverse' | 'exponential';1595  refDistance: number;1596  maxDistance: number;1597  rolloffFactor: number;1598  coneInnerAngle: number;1599  coneOuterAngle: number;1600  coneOuterGain: number;1601  setPosition(x: number, y: number, z: number): void;1602  setOrientation(x: number, y: number, z: number): void;1603}16041605declare class PeriodicWave extends AudioNode {}1606declare class WaveShaperNode extends AudioNode {1607  curve: Float32Array;1608  oversample: 'none' | '2x' | '4x';1609}16101611// this part of spec is not finished yet, apparently1612// https://stackoverflow.com/questions/35296664/can-fetch-get-object-as-headers1613type HeadersInit =1614  | Headers1615  | Array<[string, string]>1616  | {[key: string]: string, ...};16171618// TODO Heades and URLSearchParams are almost the same thing.1619// Could it somehow be abstracted away?1620declare class Headers {1621  @@iterator(): Iterator<[string, string]>;1622  constructor(init?: HeadersInit): void;1623  append(name: string, value: string): void;1624  delete(name: string): void;1625  entries(): Iterator<[string, string]>;1626  forEach<This>(1627    callback: (1628      this: This,1629      value: string,1630      name: string,1631      headers: Headers1632    ) => mixed,1633    thisArg: This1634  ): void;1635  get(name: string): null | string;1636  has(name: string): boolean;1637  keys(): Iterator<string>;1638  set(name: string, value: string): void;1639  values(): Iterator<string>;1640}16411642declare class URLSearchParams {1643  @@iterator(): Iterator<[string, string]>;16441645  size: number;16461647  constructor(1648    init?:1649      | string1650      | URLSearchParams1651      | Array<[string, string]>1652      | {[string]: string, ...}1653  ): void;1654  append(name: string, value: string): void;1655  delete(name: string, value?: string): void;1656  entries(): Iterator<[string, string]>;1657  forEach<This>(1658    callback: (1659      this: This,1660      value: string,1661      name: string,1662      params: URLSearchParams1663    ) => mixed,1664    thisArg: This1665  ): void;1666  get(name: string): null | string;1667  getAll(name: string): Array<string>;1668  has(name: string, value?: string): boolean;1669  keys(): Iterator<string>;1670  set(name: string, value: string): void;1671  sort(): void;1672  values(): Iterator<string>;1673  toString(): string;1674}16751676type CacheType =1677  | 'default'1678  | 'no-store'1679  | 'reload'1680  | 'no-cache'1681  | 'force-cache'1682  | 'only-if-cached';1683type CredentialsType = 'omit' | 'same-origin' | 'include';1684type ModeType = 'cors' | 'no-cors' | 'same-origin' | 'navigate';1685type RedirectType = 'follow' | 'error' | 'manual';1686type ReferrerPolicyType =1687  | ''1688  | 'no-referrer'1689  | 'no-referrer-when-downgrade'1690  | 'same-origin'1691  | 'origin'1692  | 'strict-origin'1693  | 'origin-when-cross-origin'1694  | 'strict-origin-when-cross-origin'1695  | 'unsafe-url';16961697type ResponseType =1698  | 'basic'1699  | 'cors'1700  | 'default'1701  | 'error'1702  | 'opaque'1703  | 'opaqueredirect';17041705type BodyInit =1706  | string1707  | URLSearchParams1708  | FormData1709  | Blob1710  | ArrayBuffer1711  | $ArrayBufferView1712  | ReadableStream;17131714type RequestInfo = Request | URL | string;17151716type RequestOptions = {1717  body?: ?BodyInit,1718  cache?: CacheType,1719  credentials?: CredentialsType,1720  headers?: HeadersInit,1721  integrity?: string,1722  keepalive?: boolean,1723  method?: string,1724  mode?: ModeType,1725  redirect?: RedirectType,1726  referrer?: string,1727  referrerPolicy?: ReferrerPolicyType,1728  signal?: ?AbortSignal,1729  window?: any,1730  ...1731};17321733type ResponseOptions = {1734  status?: number,1735  statusText?: string,1736  headers?: HeadersInit,1737  ...1738};17391740declare class Response {1741  constructor(input?: ?BodyInit, init?: ResponseOptions): void;1742  clone(): Response;1743  static error(): Response;1744  static redirect(url: string, status?: number): Response;17451746  redirected: boolean;1747  type: ResponseType;1748  url: string;1749  ok: boolean;1750  status: number;1751  statusText: string;1752  headers: Headers;1753  trailer: Promise<Headers>;17541755  // Body methods and attributes1756  bodyUsed: boolean;1757  body: ?ReadableStream;17581759  arrayBuffer(): Promise<ArrayBuffer>;1760  blob(): Promise<Blob>;1761  formData(): Promise<FormData>;1762  json(): Promise<any>;1763  text(): Promise<string>;1764}17651766declare class Request {1767  constructor(input: RequestInfo, init?: RequestOptions): void;1768  clone(): Request;17691770  url: string;17711772  cache: CacheType;1773  credentials: CredentialsType;1774  headers: Headers;1775  integrity: string;1776  method: string;1777  mode: ModeType;1778  redirect: RedirectType;1779  referrer: string;1780  referrerPolicy: ReferrerPolicyType;1781  +signal: AbortSignal;17821783  // Body methods and attributes1784  bodyUsed: boolean;17851786  arrayBuffer(): Promise<ArrayBuffer>;1787  blob(): Promise<Blob>;1788  formData(): Promise<FormData>;1789  json(): Promise<any>;1790  text(): Promise<string>;1791}17921793declare function fetch(1794  input: RequestInfo,1795  init?: RequestOptions1796): Promise<Response>;17971798type TextEncoder$availableEncodings =1799  | 'utf-8'1800  | 'utf8'1801  | 'unicode-1-1-utf-8'1802  | 'utf-16be'1803  | 'utf-16'1804  | 'utf-16le';18051806declare class TextEncoder {1807  constructor(encoding?: TextEncoder$availableEncodings): void;1808  encode(buffer: string, options?: {stream: boolean, ...}): Uint8Array;1809  encoding: TextEncoder$availableEncodings;1810}18111812type TextDecoder$availableEncodings =1813  | '866'1814  | 'ansi_x3.4-1968'1815  | 'arabic'1816  | 'ascii'1817  | 'asmo-708'1818  | 'big5-hkscs'1819  | 'big5'1820  | 'chinese'1821  | 'cn-big5'1822  | 'cp1250'1823  | 'cp1251'1824  | 'cp1252'1825  | 'cp1253'1826  | 'cp1254'1827  | 'cp1255'1828  | 'cp1256'1829  | 'cp1257'1830  | 'cp1258'1831  | 'cp819'1832  | 'cp866'1833  | 'csbig5'1834  | 'cseuckr'1835  | 'cseucpkdfmtjapanese'1836  | 'csgb2312'1837  | 'csibm866'1838  | 'csiso2022jp'1839  | 'csiso2022kr'1840  | 'csiso58gb231280'1841  | 'csiso88596e'1842  | 'csiso88596i'1843  | 'csiso88598e'1844  | 'csiso88598i'1845  | 'csisolatin1'1846  | 'csisolatin2'1847  | 'csisolatin3'1848  | 'csisolatin4'1849  | 'csisolatin5'1850  | 'csisolatin6'1851  | 'csisolatin9'1852  | 'csisolatinarabic'1853  | 'csisolatincyrillic'1854  | 'csisolatingreek'1855  | 'csisolatinhebrew'1856  | 'cskoi8r'1857  | 'csksc56011987'1858  | 'csmacintosh'1859  | 'csshiftjis'1860  | 'cyrillic'1861  | 'dos-874'1862  | 'ecma-114'1863  | 'ecma-118'1864  | 'elot_928'1865  | 'euc-jp'1866  | 'euc-kr'1867  | 'gb_2312-80'1868  | 'gb_2312'1869  | 'gb18030'1870  | 'gb2312'1871  | 'gbk'1872  | 'greek'1873  | 'greek8'1874  | 'hebrew'1875  | 'hz-gb-2312'1876  | 'ibm819'1877  | 'ibm866'1878  | 'iso_8859-1:1987'1879  | 'iso_8859-1'1880  | 'iso_8859-2:1987'1881  | 'iso_8859-2'1882  | 'iso_8859-3:1988'1883  | 'iso_8859-3'1884  | 'iso_8859-4:1988'1885  | 'iso_8859-4'1886  | 'iso_8859-5:1988'1887  | 'iso_8859-5'1888  | 'iso_8859-6:1987'1889  | 'iso_8859-6'1890  | 'iso_8859-7:1987'1891  | 'iso_8859-7'1892  | 'iso_8859-8:1988'1893  | 'iso_8859-8'1894  | 'iso_8859-9:1989'1895  | 'iso_8859-9'1896  | 'iso-2022-cn-ext'1897  | 'iso-2022-cn'1898  | 'iso-2022-jp'1899  | 'iso-2022-kr'1900  | 'iso-8859-1'1901  | 'iso-8859-10'1902  | 'iso-8859-11'1903  | 'iso-8859-13'1904  | 'iso-8859-14'1905  | 'iso-8859-15'1906  | 'iso-8859-16'1907  | 'iso-8859-2'1908  | 'iso-8859-3'1909  | 'iso-8859-4'1910  | 'iso-8859-5'1911  | 'iso-8859-6-e'1912  | 'iso-8859-6-i'1913  | 'iso-8859-6'1914  | 'iso-8859-7'1915  | 'iso-8859-8-e'1916  | 'iso-8859-8-i'1917  | 'iso-8859-8'1918  | 'iso-8859-9'1919  | 'iso-ir-100'1920  | 'iso-ir-101'1921  | 'iso-ir-109'1922  | 'iso-ir-110'1923  | 'iso-ir-126'1924  | 'iso-ir-127'1925  | 'iso-ir-138'1926  | 'iso-ir-144'1927  | 'iso-ir-148'1928  | 'iso-ir-149'1929  | 'iso-ir-157'1930  | 'iso-ir-58'1931  | 'iso8859-1'1932  | 'iso8859-10'1933  | 'iso8859-11'1934  | 'iso8859-13'1935  | 'iso8859-14'1936  | 'iso8859-15'1937  | 'iso8859-2'1938  | 'iso8859-3'1939  | 'iso8859-4'1940  | 'iso8859-6'1941  | 'iso8859-7'1942  | 'iso8859-8'1943  | 'iso8859-9'1944  | 'iso88591'1945  | 'iso885910'1946  | 'iso885911'1947  | 'iso885913'1948  | 'iso885914'1949  | 'iso885915'1950  | 'iso88592'1951  | 'iso88593'1952  | 'iso88594'1953  | 'iso88595'1954  | 'iso88596'1955  | 'iso88597'1956  | 'iso88598'1957  | 'iso88599'1958  | 'koi'1959  | 'koi8_r'1960  | 'koi8-r'1961  | 'koi8-u'1962  | 'koi8'1963  | 'korean'1964  | 'ks_c_5601-1987'1965  | 'ks_c_5601-1989'1966  | 'ksc_5601'1967  | 'ksc5601'1968  | 'l1'1969  | 'l2'1970  | 'l3'1971  | 'l4'1972  | 'l5'1973  | 'l6'1974  | 'l9'1975  | 'latin1'1976  | 'latin2'1977  | 'latin3'1978  | 'latin4'1979  | 'latin5'1980  | 'latin6'1981  | 'latin9'1982  | 'logical'1983  | 'mac'1984  | 'macintosh'1985  | 'ms_kanji'1986  | 'shift_jis'1987  | 'shift-jis'1988  | 'sjis'1989  | 'sun_eu_greek'1990  | 'tis-620'1991  | 'unicode-1-1-utf-8'1992  | 'us-ascii'1993  | 'utf-16'1994  | 'utf-16be'1995  | 'utf-16le'1996  | 'utf-8'1997  | 'utf8'1998  | 'visual'1999  | 'windows-1250'2000  | 'windows-1251'