onstatechange: (this: AudioContext, ev: Event) => any;

readonly sampleRate: number;

readonly state: string;

createAnalyser(): AnalyserNode;

createBiquadFilter(): BiquadFilterNode;

createBuffer(numberOfChannels: number, length: number, sampleRate: number): AudioBuffer;

createScriptProcessor(bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number): ScriptProcessorNode;

createStereoPanner(): StereoPannerNode;

createWaveShaper(): WaveShaperNode;

addEventListener<K extends keyof AudioContextEventMap>(type: K, listener: (this: AudioContext, ev: AudioContextEventMap[K]) => any, useCapture?: boolean): void;

addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;

}

interface AudioContext extends AudioContextBase {

}

declare var AudioContext: {

}

interface Cache {

keys(request?: RequestInfo, options?: CacheQueryOptions): any;

matchAll(request?: RequestInfo, options?: CacheQueryOptions): any;

}

declare var Cache: {

}

interface CacheStorage {

keys(): any;

}

declare var CacheStorage: {

* Loads and starts playback of a media resource.

*/

play(): void;

readonly HAVE_CURRENT_DATA: number;

readonly HAVE_ENOUGH_DATA: number;

readonly HAVE_FUTURE_DATA: number;

execAsyncAtPriority(asynchronousCallback: MSExecAtPriorityFunctionCallback, priority: string, ...args: any[]): void;

execAtPriority(synchronousCallback: MSExecAtPriorityFunctionCallback, priority: string, ...args: any[]): any;

getCurrentPriority(): string;

getViewId(view: any): any;

isTaskScheduledAtPriorityOrHigher(priority: string): boolean;

pageHandlesAllApplicationActivations(enabled: boolean): void;

}

interface MSCredentials {

}

declare var MSCredentials: {

ondevicechange: (this: MediaDevices, ev: Event) => any;

enumerateDevices(): any;

getSupportedConstraints(): MediaTrackSupportedConstraints;

addEventListener<K extends keyof MediaDevicesEventMap>(type: K, listener: (this: MediaDevices, ev: MediaDevicesEventMap[K]) => any, useCapture?: boolean): void;

addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;

}

}

interface MediaKeySession extends EventTarget {

readonly expiration: number;

readonly keyStatuses: MediaKeyStatusMap;

readonly sessionId: string;

}

declare var MediaKeySession: {

interface MediaKeySystemAccess {

readonly keySystem: string;

getConfiguration(): MediaKeySystemConfiguration;

}

interface MediaKeys {

createSession(sessionType?: string): MediaKeySession;

}

declare var MediaKeys: {

readonly readonly: boolean;

readonly readyState: string;

readonly remote: boolean;

clone(): MediaStreamTrack;

getCapabilities(): MediaTrackCapabilities;

getConstraints(): MediaTrackConstraints;

getGamepads(): Gamepad[];

javaEnabled(): boolean;

msLaunchUri(uri: string, successCallback?: MSLaunchUriCallback, noHandlerCallback?: MSLaunchUriCallback): void;

vibrate(pattern: number | number[]): boolean;

}

declare var Notification: {

prototype: Notification;

new(title: string, options?: NotificationOptions): Notification;

}

interface OES_element_index_uint {

interface OfflineAudioContext extends AudioContextBase {

readonly length: number;

oncomplete: (this: OfflineAudioContext, ev: OfflineAudioCompletionEvent) => any;

addEventListener<K extends keyof OfflineAudioContextEventMap>(type: K, listener: (this: OfflineAudioContext, ev: OfflineAudioContextEventMap[K]) => any, useCapture?: boolean): void;

addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;

}

readonly shippingAddress: PaymentAddress | null;

readonly shippingOption: string | null;

readonly shippingType: string | null;

addEventListener<K extends keyof PaymentRequestEventMap>(type: K, listener: (this: PaymentRequest, ev: PaymentRequestEventMap[K]) => any, useCapture?: boolean): void;

addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;

}

}

interface PaymentRequestUpdateEvent extends Event {

}

declare var PaymentRequestUpdateEvent: {

readonly payerPhone: string | null;

readonly shippingAddress: PaymentAddress | null;

readonly shippingOption: string | null;

toJSON(): any;

}

}

interface PushManager {

}

declare var PushManager: {

readonly options: PushSubscriptionOptions;

getKey(name: string): ArrayBuffer | null;

toJSON(): any;

}

declare var PushSubscription: {

onsignalingstatechange: (this: RTCPeerConnection, ev: Event) => any;

readonly remoteDescription: RTCSessionDescription | null;

readonly signalingState: string;

addStream(stream: MediaStream): void;

close(): void;

getConfiguration(): RTCConfiguration;

getLocalStreams(): MediaStream[];

getRemoteStreams(): MediaStream[];

getStreamById(streamId: string): MediaStream | null;

removeStream(stream: MediaStream): void;

addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, ev: RTCPeerConnectionEventMap[K]) => any, useCapture?: boolean): void;

addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;

}

}

interface RTCStatsProvider extends EventTarget {

}

declare var RTCStatsProvider: {

interface ReadableStream {

readonly locked: boolean;

getReader(): ReadableStreamReader;

}

}

interface ReadableStreamReader {

releaseLock(): void;

}

readonly controller: ServiceWorker | null;

oncontrollerchange: (this: ServiceWorkerContainer, ev: Event) => any;

onmessage: (this: ServiceWorkerContainer, ev: ServiceWorkerMessageEvent) => any;

getRegistrations(): any;

addEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, useCapture?: boolean): void;

addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;

}

readonly sync: SyncManager;

readonly waiting: ServiceWorker | null;

getNotifications(filter?: GetNotificationOptions): any;

addEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, useCapture?: boolean): void;

addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;

}

interface SyncManager {

getTags(): any;

}

declare var SyncManager: {

}

interface WebAuthentication {

}

declare var WebAuthentication: {

interface Body {

readonly bodyUsed: boolean;

}

interface CanvasPathMethods {

}

interface GlobalFetch {

}

interface HTMLTableAlignment {

declare var indexedDB: IDBFactory;

declare function atob(encodedString: string): string;

declare function btoa(rawString: string): string;

declare function addEventListener<K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, useCapture?: boolean): void;

declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;

type AAGUID = string;