/*! *****************************************************************************

Copyright (c) Microsoft Corporation. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use

this file except in compliance with the License. You may obtain a copy of the

License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED

WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,

MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions

and limitations under the License.

***************************************************************************** */

/// <reference no-default-lib="true"/>

/////////////////////////////

/// Worker APIs

/////////////////////////////

interface AddEventListenerOptions extends EventListenerOptions {

once?: boolean;

passive?: boolean;

}

interface AesCbcParams extends Algorithm {

iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;

}

interface AesCtrParams extends Algorithm {

counter: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;

length: number;

}

interface AesDerivedKeyParams extends Algorithm {

length: number;

}

interface AesGcmParams extends Algorithm {

additionalData?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;

iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;

tagLength?: number;

}

interface AesKeyAlgorithm extends KeyAlgorithm {

length: number;

}

interface AesKeyGenParams extends Algorithm {

length: number;

}

interface Algorithm {

name: string;

}

interface BlobPropertyBag {

endings?: EndingType;

type?: string;

}

interface CacheQueryOptions {

cacheName?: string;

ignoreMethod?: boolean;

ignoreSearch?: boolean;

ignoreVary?: boolean;

}

interface ClientQueryOptions {

includeUncontrolled?: boolean;

type?: ClientTypes;

}

interface CloseEventInit extends EventInit {

code?: number;

reason?: string;

wasClean?: boolean;

}

interface CryptoKeyPair {

privateKey?: CryptoKey;

publicKey?: CryptoKey;

}

interface CustomEventInit<T = any> extends EventInit {

detail?: T;

}

interface DOMMatrix2DInit {

a?: number;

b?: number;

c?: number;

d?: number;

e?: number;

f?: number;

m11?: number;

m12?: number;

m21?: number;

m22?: number;

m41?: number;

m42?: number;

}

interface DOMMatrixInit extends DOMMatrix2DInit {

is2D?: boolean;

m13?: number;

m14?: number;

m23?: number;

m24?: number;

m31?: number;

m32?: number;

m33?: number;

m34?: number;

m43?: number;

m44?: number;

}

interface DOMPointInit {

w?: number;

x?: number;

y?: number;

z?: number;

}

interface DOMQuadInit {

p1?: DOMPointInit;

p2?: DOMPointInit;

p3?: DOMPointInit;

p4?: DOMPointInit;

}

interface DOMRectInit {

height?: number;

width?: number;

x?: number;

y?: number;

}

interface EcKeyGenParams extends Algorithm {

namedCurve: NamedCurve;

}

interface EcKeyImportParams extends Algorithm {

namedCurve: NamedCurve;

}

interface EcdhKeyDeriveParams extends Algorithm {

public: CryptoKey;

}

interface EcdsaParams extends Algorithm {

hash: HashAlgorithmIdentifier;

}

interface ErrorEventInit extends EventInit {

colno?: number;

error?: any;

filename?: string;

lineno?: number;

message?: string;

}

interface EventInit {

bubbles?: boolean;

cancelable?: boolean;

composed?: boolean;

}

interface EventListenerOptions {

capture?: boolean;

}

interface EventSourceInit {

withCredentials?: boolean;

}

interface ExtendableEventInit extends EventInit {

}

interface ExtendableMessageEventInit extends ExtendableEventInit {

data?: any;

lastEventId?: string;

origin?: string;

ports?: MessagePort[];

source?: Client | ServiceWorker | MessagePort | null;

}

interface FetchEventInit extends ExtendableEventInit {

clientId?: string;

preloadResponse?: Promise<any>;

request: Request;

resultingClientId?: string;

targetClientId?: string;

}

interface FilePropertyBag extends BlobPropertyBag {

lastModified?: number;

}

interface GetNotificationOptions {

tag?: string;

}

interface HmacImportParams extends Algorithm {

hash: HashAlgorithmIdentifier;

length?: number;

}

interface HmacKeyGenParams extends Algorithm {

hash: HashAlgorithmIdentifier;

length?: number;

}

interface IDBIndexParameters {

multiEntry?: boolean;

unique?: boolean;

}

interface IDBObjectStoreParameters {

autoIncrement?: boolean;

keyPath?: string | string[] | null;

}

interface IDBVersionChangeEventInit extends EventInit {

newVersion?: number | null;

oldVersion?: number;

}

interface JsonWebKey {

alg?: string;

crv?: string;

d?: string;

dp?: string;

dq?: string;

e?: string;

ext?: boolean;

k?: string;

key_ops?: string[];

kty?: string;

n?: string;

oth?: RsaOtherPrimesInfo[];

p?: string;

q?: string;

qi?: string;

use?: string;

x?: string;

y?: string;

}

interface KeyAlgorithm {

name: string;

}

interface MessageEventInit extends EventInit {

data?: any;

lastEventId?: string;

origin?: string;

ports?: MessagePort[];

source?: MessageEventSource | null;

}

interface NavigationPreloadState {

enabled?: boolean;

headerValue?: string;

}

interface NotificationAction {

action: string;

icon?: string;

title: string;

}

interface NotificationEventInit extends ExtendableEventInit {

action?: string;

notification: Notification;

}

interface NotificationOptions {

actions?: NotificationAction[];

badge?: string;

body?: string;

data?: any;

dir?: NotificationDirection;

icon?: string;

image?: string;

lang?: string;

renotify?: boolean;

requireInteraction?: boolean;

silent?: boolean;

tag?: string;

timestamp?: number;

vibrate?: VibratePattern;

}

interface Pbkdf2Params extends Algorithm {

hash: HashAlgorithmIdentifier;

iterations: number;

salt: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;

}

interface PerformanceObserverInit {

buffered?: boolean;

entryTypes: string[];

}

interface PipeOptions {

preventAbort?: boolean;

preventCancel?: boolean;

preventClose?: boolean;

}

interface ProgressEventInit extends EventInit {

lengthComputable?: boolean;

loaded?: number;

total?: number;

}

interface PromiseRejectionEventInit extends EventInit {

promise: Promise<any>;

reason?: any;

}

interface PushEventInit extends ExtendableEventInit {

data?: PushMessageDataInit;

}

interface PushSubscriptionChangeInit extends ExtendableEventInit {

newSubscription?: PushSubscription;

oldSubscription?: PushSubscription;

}

interface PushSubscriptionJSON {

endpoint?: string;

expirationTime?: number | null;

keys?: Record<string, string>;

}

interface PushSubscriptionOptionsInit {

applicationServerKey?: BufferSource | string | null;

userVisibleOnly?: boolean;

}

interface QueuingStrategy<T = any> {

highWaterMark?: number;

size?: QueuingStrategySizeCallback<T>;

}

interface RegistrationOptions {

scope?: string;

type?: WorkerType;

updateViaCache?: ServiceWorkerUpdateViaCache;

}

interface RequestInit {

body?: BodyInit | null;

cache?: RequestCache;

credentials?: RequestCredentials;

headers?: HeadersInit;

integrity?: string;

keepalive?: boolean;

method?: string;

mode?: RequestMode;

redirect?: RequestRedirect;

referrer?: string;

referrerPolicy?: ReferrerPolicy;

signal?: AbortSignal | null;

window?: any;

}

interface ResponseInit {

headers?: HeadersInit;

status?: number;

statusText?: string;

}

interface RsaHashedImportParams extends Algorithm {

hash: HashAlgorithmIdentifier;

}

interface RsaHashedKeyGenParams extends RsaKeyGenParams {

hash: HashAlgorithmIdentifier;

}

interface RsaKeyGenParams extends Algorithm {

modulusLength: number;

publicExponent: BigInteger;

}

interface RsaOaepParams extends Algorithm {

label?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;

}

interface RsaOtherPrimesInfo {

d?: string;

r?: string;

t?: string;

}

interface RsaPssParams extends Algorithm {

saltLength: number;

}

interface StorageEstimate {

quota?: number;

usage?: number;

}

interface SyncEventInit extends ExtendableEventInit {

lastChance?: boolean;

tag: string;

}

interface TextDecodeOptions {

stream?: boolean;

}

interface TextDecoderOptions {

fatal?: boolean;

ignoreBOM?: boolean;

}

interface Transformer<I = any, O = any> {

flush?: TransformStreamDefaultControllerCallback<O>;

readableType?: undefined;

start?: TransformStreamDefaultControllerCallback<O>;

transform?: TransformStreamDefaultControllerTransformCallback<I, O>;

writableType?: undefined;

}

interface UnderlyingByteSource {

autoAllocateChunkSize?: number;

cancel?: ReadableStreamErrorCallback;

pull?: ReadableByteStreamControllerCallback;

start?: ReadableByteStreamControllerCallback;

type: "bytes";

}

interface UnderlyingSink<W = any> {

abort?: WritableStreamErrorCallback;

close?: WritableStreamDefaultControllerCloseCallback;

start?: WritableStreamDefaultControllerStartCallback;

type?: undefined;

write?: WritableStreamDefaultControllerWriteCallback<W>;

}

interface UnderlyingSource<R = any> {

cancel?: ReadableStreamErrorCallback;

pull?: ReadableStreamDefaultControllerCallback<R>;

start?: ReadableStreamDefaultControllerCallback<R>;

type?: undefined;

}

interface WebGLContextAttributes {

alpha?: GLboolean;

antialias?: GLboolean;

depth?: GLboolean;

failIfMajorPerformanceCaveat?: boolean;

powerPreference?: WebGLPowerPreference;

premultipliedAlpha?: GLboolean;

preserveDrawingBuffer?: GLboolean;

stencil?: GLboolean;

}

interface WebGLContextEventInit extends EventInit {

statusMessage?: string;

}

interface WorkerOptions {

credentials?: RequestCredentials;

name?: string;

type?: WorkerType;

}

interface EventListener {

(evt: Event): void;

}

/** The ANGLE_instanced_arrays extension is part of the WebGL API and allows to draw the same object, or groups of similar objects multiple times, if they share the same vertex data, primitive count and type. */

interface ANGLE_instanced_arrays {

drawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei): void;

drawElementsInstancedANGLE(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, primcount: GLsizei): void;

vertexAttribDivisorANGLE(index: GLuint, divisor: GLuint): void;

readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: GLenum;

}

/** The AbortController interface represents a controller object that allows you to abort one or more DOM requests as and when desired. */

interface AbortController {

/**

* Returns the AbortSignal object associated with this object.

*/

readonly signal: AbortSignal;

/**

* Invoking this method will set this object's AbortSignal's aborted flag and

* signal to any observers that the associated activity is to be aborted.

*/

abort(): void;

}

declare var AbortController: {

prototype: AbortController;

new(): AbortController;

};

interface AbortSignalEventMap {

"abort": Event;

}

/** The AbortSignal interface represents a signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */

interface AbortSignal extends EventTarget {

/**

* Returns true if this AbortSignal's AbortController has signaled to abort, and false

* otherwise.

*/

readonly aborted: boolean;

onabort: ((this: AbortSignal, ev: Event) => any) | null;

addEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;

addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;

removeEventListener<K extends keyof AbortSignalEventMap>(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | EventListenerOptions): void;

removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;

}

declare var AbortSignal: {

prototype: AbortSignal;

new(): AbortSignal;

};

interface AbstractWorkerEventMap {

"error": ErrorEvent;

}

interface AbstractWorker {

onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;

addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;

addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;

removeEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;

removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;

}

interface AesCfbParams extends Algorithm {

iv: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;

}

interface AesCmacParams extends Algorithm {

length: number;

}

/** A Blob object represents a file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The File interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system. */

interface Blob {

readonly size: number;

readonly type: string;

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

}

declare var Blob: {

prototype: Blob;

new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;

};

interface Body {

readonly body: ReadableStream<Uint8Array> | null;

readonly bodyUsed: boolean;

arrayBuffer(): Promise<ArrayBuffer>;

blob(): Promise<Blob>;

formData(): Promise<FormData>;

json(): Promise<any>;

text(): Promise<string>;

}

interface BroadcastChannelEventMap {

"message": MessageEvent;

"messageerror": MessageEvent;

}

interface BroadcastChannel extends EventTarget {

/**

* Returns the channel name (as passed to the constructor).

*/

readonly name: string;

onmessage: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;

onmessageerror: ((this: BroadcastChannel, ev: MessageEvent) => any) | null;

/**

* Closes the BroadcastChannel object, opening it up to garbage collection.

*/

close(): void;

/**

* Sends the given message to other BroadcastChannel objects set up for this channel. Messages can be structured objects, e.g. nested objects and arrays.

*/

postMessage(message: any): void;

addEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;

addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;

removeEventListener<K extends keyof BroadcastChannelEventMap>(type: K, listener: (this: BroadcastChannel, ev: BroadcastChannelEventMap[K]) => any, options?: boolean | EventListenerOptions): void;

removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;

}

declare var BroadcastChannel: {

prototype: BroadcastChannel;

new(name: string): BroadcastChannel;

};

interface BroadcastChannelEventMap {

message: MessageEvent;

messageerror: MessageEvent;

}

/** The ByteLengthQueuingStrategy interface of the the Streams API provides a built-in byte length queuing strategy that can be used when constructing streams. */

interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {

highWaterMark: number;

size(chunk: ArrayBufferView): number;

}

declare var ByteLengthQueuingStrategy: {

prototype: ByteLengthQueuingStrategy;

new(options: { highWaterMark: number }): ByteLengthQueuingStrategy;

};

/** The Cache interface provides a storage mechanism for Request / Response object pairs that are cached, for example as part of the ServiceWorker life cycle. Note that the Cache interface is exposed to windowed scopes as well as workers. You don't have to use it in conjunction with service workers, even though it is defined in the service worker spec. */

interface Cache {

add(request: RequestInfo): Promise<void>;

addAll(requests: RequestInfo[]): Promise<void>;

delete(request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>;

keys(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Request>>;

match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>;

matchAll(request?: RequestInfo, options?: CacheQueryOptions): Promise<ReadonlyArray<Response>>;

put(request: RequestInfo, response: Response): Promise<void>;

}

declare var Cache: {

prototype: Cache;

new(): Cache;

};

/** The CacheStorage interface represents the storage for Cache objects. */

interface CacheStorage {

delete(cacheName: string): Promise<boolean>;

has(cacheName: string): Promise<boolean>;

keys(): Promise<string[]>;

match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>;

open(cacheName: string): Promise<Cache>;

}

declare var CacheStorage: {

prototype: CacheStorage;

new(): CacheStorage;

};

/** The CanvasGradient interface represents an opaque object describing a gradient. It is returned by the methods CanvasRenderingContext2D.createLinearGradient() or CanvasRenderingContext2D.createRadialGradient(). */

interface CanvasGradient {

/**

* Adds a color stop with the given color to the gradient at the given offset. 0.0 is the offset

* at one end of the gradient, 1.0 is the offset at the other end.

* Throws an "IndexSizeError" DOMException if the offset

* is out of range. Throws a "SyntaxError" DOMException if

* the color cannot be parsed.

*/

addColorStop(offset: number, color: string): void;

}

declare var CanvasGradient: {

prototype: CanvasGradient;

new(): CanvasGradient;

};

interface CanvasPath {

arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;

arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;

bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;

closePath(): void;

ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;

lineTo(x: number, y: number): void;

moveTo(x: number, y: number): void;

quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;

rect(x: number, y: number, w: number, h: number): void;

}

/** The CanvasPattern interface represents an opaque object describing a pattern, based on an image, a canvas, or a video, created by the CanvasRenderingContext2D.createPattern() method. */

interface CanvasPattern {

/**

* Sets the transformation matrix that will be used when rendering the pattern during a fill or

* stroke painting operation.

*/

setTransform(transform?: DOMMatrix2DInit): void;

}

declare var CanvasPattern: {

prototype: CanvasPattern;

new(): CanvasPattern;

};

/** The Client interface represents an executable context such as a Worker, or a SharedWorker. Window clients are represented by the more-specific WindowClient. You can get Client/WindowClient objects from methods such as Clients.matchAll() and Clients.get(). */

interface Client {

readonly id: string;

readonly type: ClientTypes;

readonly url: string;

postMessage(message: any, transfer?: Transferable[]): void;

}

declare var Client: {

prototype: Client;

new(): Client;

};

/** The Clients interface provides access to Client objects. Access it via self.clients within a service worker. */

interface Clients {

claim(): Promise<void>;

get(id: string): Promise<any>;

matchAll(options?: ClientQueryOptions): Promise<ReadonlyArray<Client>>;

openWindow(url: string): Promise<WindowClient | null>;

}

declare var Clients: {

prototype: Clients;

new(): Clients;

};

/** A CloseEvent is sent to clients using WebSockets when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute. */

interface CloseEvent extends Event {

readonly code: number;

readonly reason: string;

readonly wasClean: boolean;

/** @deprecated */

initCloseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, wasCleanArg: boolean, codeArg: number, reasonArg: string): void;

}

declare var CloseEvent: {

prototype: CloseEvent;

new(type: string, eventInitDict?: CloseEventInit): CloseEvent;

};

interface ConcatParams extends Algorithm {

algorithmId: Uint8Array;

hash?: string | Algorithm;

partyUInfo: Uint8Array;

partyVInfo: Uint8Array;

privateInfo?: Uint8Array;

publicInfo?: Uint8Array;

}

/** The Console object provides access to the browser's debugging console (e.g. the Web Console in Firefox). The specifics of how it works varies from browser to browser, but there is a de facto set of features that are typically provided. */

interface Console {

memory: any;

assert(condition?: boolean, message?: string, ...data: any[]): void;

clear(): void;

count(label?: string): void;

debug(message?: any, ...optionalParams: any[]): void;

dir(value?: any, ...optionalParams: any[]): void;

dirxml(value: any): void;

error(message?: any, ...optionalParams: any[]): void;

exception(message?: string, ...optionalParams: any[]): void;

group(groupTitle?: string, ...optionalParams: any[]): void;

groupCollapsed(groupTitle?: string, ...optionalParams: any[]): void;

groupEnd(): void;

info(message?: any, ...optionalParams: any[]): void;

log(message?: any, ...optionalParams: any[]): void;

markTimeline(label?: string): void;

profile(reportName?: string): void;

profileEnd(reportName?: string): void;

table(...tabularData: any[]): void;

time(label?: string): void;

timeEnd(label?: string): void;

timeStamp(label?: string): void;

timeline(label?: string): void;

timelineEnd(label?: string): void;

trace(message?: any, ...optionalParams: any[]): void;

warn(message?: any, ...optionalParams: any[]): void;

}

declare var Console: {

prototype: Console;

new(): Console;

};

/** The CountQueuingStrategy interface of the the Streams API provides a built-in byte length queuing strategy that can be used when constructing streams. */

interface CountQueuingStrategy extends QueuingStrategy {

highWaterMark: number;

size(chunk: any): 1;

}

declare var CountQueuingStrategy: {

prototype: CountQueuingStrategy;

new(options: { highWaterMark: number }): CountQueuingStrategy;

};

/** The Crypto interface represents basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives. */

interface Crypto {

readonly subtle: SubtleCrypto;

getRandomValues<T extends Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | null>(array: T): T;

}

declare var Crypto: {

prototype: Crypto;

new(): Crypto;

};

/** The CryptoKey interface represents a cryptographic key derived from a specific key algorithm. */

interface CryptoKey {

readonly algorithm: KeyAlgorithm;

readonly extractable: boolean;

readonly type: KeyType;

readonly usages: KeyUsage[];

}

declare var CryptoKey: {

prototype: CryptoKey;

new(): CryptoKey;

};

interface CustomEvent<T = any> extends Event {

/**

* Returns any custom data event was created with.

* Typically used for synthetic events.

*/

readonly detail: T;

initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: T): void;

}

declare var CustomEvent: {

prototype: CustomEvent;

new<T>(typeArg: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;

};

/** The DOMException interface represents an abnormal event (called an exception) which occurs as a result of calling a method or accessing a property of a web API. */

interface DOMException {

readonly code: number;

readonly message: string;

readonly name: string;

readonly ABORT_ERR: number;

readonly DATA_CLONE_ERR: number;

readonly DOMSTRING_SIZE_ERR: number;

readonly HIERARCHY_REQUEST_ERR: number;

readonly INDEX_SIZE_ERR: number;

readonly INUSE_ATTRIBUTE_ERR: number;

readonly INVALID_ACCESS_ERR: number;

readonly INVALID_CHARACTER_ERR: number;

readonly INVALID_MODIFICATION_ERR: number;

readonly INVALID_NODE_TYPE_ERR: number;

readonly INVALID_STATE_ERR: number;

readonly NAMESPACE_ERR: number;

readonly NETWORK_ERR: number;

readonly NOT_FOUND_ERR: number;

readonly NOT_SUPPORTED_ERR: number;

readonly NO_DATA_ALLOWED_ERR: number;

readonly NO_MODIFICATION_ALLOWED_ERR: number;

readonly QUOTA_EXCEEDED_ERR: number;

readonly SECURITY_ERR: number;

readonly SYNTAX_ERR: number;

readonly TIMEOUT_ERR: number;

readonly TYPE_MISMATCH_ERR: number;

readonly URL_MISMATCH_ERR: number;

readonly VALIDATION_ERR: number;

readonly WRONG_DOCUMENT_ERR: number;

}

declare var DOMException: {

prototype: DOMException;

new(message?: string, name?: string): DOMException;

readonly ABORT_ERR: number;

readonly DATA_CLONE_ERR: number;

readonly DOMSTRING_SIZE_ERR: number;

readonly HIERARCHY_REQUEST_ERR: number;

readonly INDEX_SIZE_ERR: number;

readonly INUSE_ATTRIBUTE_ERR: number;

readonly INVALID_ACCESS_ERR: number;

readonly INVALID_CHARACTER_ERR: number;

readonly INVALID_MODIFICATION_ERR: number;

readonly INVALID_NODE_TYPE_ERR: number;

readonly INVALID_STATE_ERR: number;

readonly NAMESPACE_ERR: number;

readonly NETWORK_ERR: number;

readonly NOT_FOUND_ERR: number;

readonly NOT_SUPPORTED_ERR: number;

readonly NO_DATA_ALLOWED_ERR: number;

readonly NO_MODIFICATION_ALLOWED_ERR: number;

readonly QUOTA_EXCEEDED_ERR: number;

readonly SECURITY_ERR: number;

readonly SYNTAX_ERR: number;

readonly TIMEOUT_ERR: number;

readonly TYPE_MISMATCH_ERR: number;

readonly URL_MISMATCH_ERR: number;

readonly VALIDATION_ERR: number;

readonly WRONG_DOCUMENT_ERR: number;

};

interface DOMMatrix extends DOMMatrixReadOnly {

a: number;

b: number;

c: number;

d: number;

e: number;

f: number;

m11: number;

m12: number;

m13: number;

m14: number;

m21: number;

m22: number;

m23: number;

m24: number;

m31: number;

m32: number;

m33: number;

m34: number;

m41: number;

m42: number;

m43: number;

m44: number;

invertSelf(): DOMMatrix;

multiplySelf(other?: DOMMatrixInit): DOMMatrix;

preMultiplySelf(other?: DOMMatrixInit): DOMMatrix;

rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;

rotateFromVectorSelf(x?: number, y?: number): DOMMatrix;

rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;

scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;

scaleSelf(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;

skewXSelf(sx?: number): DOMMatrix;

skewYSelf(sy?: number): DOMMatrix;

translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix;

}

declare var DOMMatrix: {

prototype: DOMMatrix;

new(init?: string | number[]): DOMMatrix;

fromFloat32Array(array32: Float32Array): DOMMatrix;

fromFloat64Array(array64: Float64Array): DOMMatrix;

fromMatrix(other?: DOMMatrixInit): DOMMatrix;

};

interface DOMMatrixReadOnly {

readonly a: number;

readonly b: number;

readonly c: number;

readonly d: number;

readonly e: number;

readonly f: number;

readonly is2D: boolean;

readonly isIdentity: boolean;

readonly m11: number;

readonly m12: number;

readonly m13: number;

readonly m14: number;

readonly m21: number;

readonly m22: number;

readonly m23: number;

readonly m24: number;

readonly m31: number;

readonly m32: number;

readonly m33: number;

readonly m34: number;

readonly m41: number;

readonly m42: number;

readonly m43: number;

readonly m44: number;

flipX(): DOMMatrix;

flipY(): DOMMatrix;

inverse(): DOMMatrix;

multiply(other?: DOMMatrixInit): DOMMatrix;

rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix;

rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix;

rotateFromVector(x?: number, y?: number): DOMMatrix;

scale(scaleX?: number, scaleY?: number, scaleZ?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;

scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix;

/** @deprecated */

scaleNonUniform(scaleX?: number, scaleY?: number): DOMMatrix;

skewX(sx?: number): DOMMatrix;

skewY(sy?: number): DOMMatrix;

toFloat32Array(): Float32Array;

toFloat64Array(): Float64Array;

toJSON(): any;

transformPoint(point?: DOMPointInit): DOMPoint;

translate(tx?: number, ty?: number, tz?: number): DOMMatrix;

}

declare var DOMMatrixReadOnly: {

prototype: DOMMatrixReadOnly;

new(init?: string | number[]): DOMMatrixReadOnly;

fromFloat32Array(array32: Float32Array): DOMMatrixReadOnly;

fromFloat64Array(array64: Float64Array): DOMMatrixReadOnly;

fromMatrix(other?: DOMMatrixInit): DOMMatrixReadOnly;

};

interface DOMPoint extends DOMPointReadOnly {

w: number;

x: number;

y: number;

z: number;

}

declare var DOMPoint: {

prototype: DOMPoint;

new(x?: number, y?: number, z?: number, w?: number): DOMPoint;

fromPoint(other?: DOMPointInit): DOMPoint;

};

interface DOMPointReadOnly {

readonly w: number;

readonly x: number;

readonly y: number;