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

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 {

ignoreMethod?: boolean;

ignoreSearch?: boolean;

ignoreVary?: boolean;

}

interface CanvasRenderingContext2DSettings {

alpha?: boolean;

desynchronized?: 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 DevicePermissionDescriptor extends PermissionDescriptor {

deviceId?: string;

name: "camera" | "microphone" | "speaker";

}

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>;

replacesClientId?: string;

request: Request;

resultingClientId?: 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 ImageBitmapRenderingContextSettings {

alpha?: boolean;

}

interface ImageEncodeOptions {

quality?: number;

type?: string;

}

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 MidiPermissionDescriptor extends PermissionDescriptor {

name: "midi";

sysex?: boolean;

}

interface MultiCacheQueryOptions extends CacheQueryOptions {

cacheName?: string;

}

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

type?: string;

}

interface PermissionDescriptor {

name: PermissionName;

}

interface PipeOptions {

preventAbort?: boolean;

preventCancel?: boolean;

preventClose?: boolean;

signal?: AbortSignal;

}

interface PostMessageOptions {

transfer?: any[];

}

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 PushPermissionDescriptor extends PermissionDescriptor {

name: "push";

userVisibleOnly?: boolean;

}

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 {

/**

* A BodyInit object or null to set request's body.

*/

body?: BodyInit | null;

/**

* A string indicating how the request will interact with the browser's cache to set request's cache.

*/

cache?: RequestCache;

/**

* A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials.

*/

credentials?: RequestCredentials;

/**

* A Headers object, an object literal, or an array of two-item arrays to set request's headers.

*/

headers?: HeadersInit;

/**

* A cryptographic hash of the resource to be fetched by request. Sets request's integrity.

*/

integrity?: string;

/**

* A boolean to set request's keepalive.

*/

keepalive?: boolean;

/**

* A string to set request's method.

*/

method?: string;

/**

* A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.

*/

mode?: RequestMode;

/**

* A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect.

*/

redirect?: RequestRedirect;

/**

* A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.

*/

referrer?: string;

/**

* A referrer policy to set request's referrerPolicy.

*/

referrerPolicy?: ReferrerPolicy;

/**

* An AbortSignal to set request's signal.

*/

signal?: AbortSignal | null;

/**

* Can only be null. Used to disassociate request from any Window.

*/

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 TextEncoderEncodeIntoResult {

read?: number;

written?: number;

}

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?: boolean;

antialias?: boolean;

depth?: boolean;

desynchronized?: boolean;

failIfMajorPerformanceCaveat?: boolean;

powerPreference?: WebGLPowerPreference;

premultipliedAlpha?: boolean;

preserveDrawingBuffer?: boolean;

stencil?: boolean;

}

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;

}

/** 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;

}

/** 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;

}

interface AnimationFrameProvider {

cancelAnimationFrame(handle: number): void;

requestAnimationFrame(callback: FrameRequestCallback): number;

}

/** 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;

};

/** This Streams API interface 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;

};

/** 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 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;

};

interface CanvasCompositing {

globalAlpha: number;

globalCompositeOperation: string;

}

interface CanvasDrawImage {

drawImage(image: CanvasImageSource, dx: number, dy: number): void;

drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;

drawImage(image: CanvasImageSource, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;

}

interface CanvasDrawPath {

beginPath(): void;

clip(fillRule?: CanvasFillRule): void;

clip(path: Path2D, fillRule?: CanvasFillRule): void;

fill(fillRule?: CanvasFillRule): void;

fill(path: Path2D, fillRule?: CanvasFillRule): void;

isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean;

isPointInPath(path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean;

isPointInStroke(x: number, y: number): boolean;

isPointInStroke(path: Path2D, x: number, y: number): boolean;

stroke(): void;

stroke(path: Path2D): void;

}

interface CanvasFillStrokeStyles {

fillStyle: string | CanvasGradient | CanvasPattern;

strokeStyle: string | CanvasGradient | CanvasPattern;

createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;

createPattern(image: CanvasImageSource, repetition: string): CanvasPattern | null;

createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;

}

interface CanvasFilters {

filter: string;

}

/** 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 CanvasImageData {

createImageData(sw: number, sh: number): ImageData;

createImageData(imagedata: ImageData): ImageData;

getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;

putImageData(imagedata: ImageData, dx: number, dy: number): void;

putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX: number, dirtyY: number, dirtyWidth: number, dirtyHeight: number): void;

}

interface CanvasImageSmoothing {

imageSmoothingEnabled: boolean;

imageSmoothingQuality: ImageSmoothingQuality;

}

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;

}

interface CanvasPathDrawingStyles {

lineCap: CanvasLineCap;

lineDashOffset: number;

lineJoin: CanvasLineJoin;

lineWidth: number;

miterLimit: number;

getLineDash(): number[];

setLineDash(segments: number[]): void;

}

/** 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;

};

interface CanvasRect {

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

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

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

}

interface CanvasShadowStyles {

shadowBlur: number;

shadowColor: string;

shadowOffsetX: number;

shadowOffsetY: number;

}

interface CanvasState {

restore(): void;

save(): void;

}

interface CanvasText {

fillText(text: string, x: number, y: number, maxWidth?: number): void;

measureText(text: string): TextMetrics;

strokeText(text: string, x: number, y: number, maxWidth?: number): void;

}

interface CanvasTextDrawingStyles {

direction: CanvasDirection;

font: string;

textAlign: CanvasTextAlign;

textBaseline: CanvasTextBaseline;

}

interface CanvasTransform {

getTransform(): DOMMatrix;

resetTransform(): void;

rotate(angle: number): void;

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

setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;

setTransform(transform?: DOMMatrix2DInit): void;

transform(a: number, b: number, c: number, d: number, e: number, f: number): void;

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

}

/** 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 frameType: FrameType;

readonly id: string;

readonly type: ClientTypes;

readonly url: string;

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

}

declare var Client: {

prototype: Client;

new(): Client;

};

/** 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;

}

/** 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;

};

/** This Streams API interface 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;

};

/** 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 dictionary of the Web Crypto API represents a cryptographic key. */

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;