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

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 HkdfParams extends Algorithm {

hash: HashAlgorithmIdentifier;

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

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

}

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

colorSpaceConversion?: ColorSpaceConversion;

imageOrientation?: ImageOrientation;

premultiplyAlpha?: PremultiplyAlpha;

resizeHeight?: number;

resizeQuality?: ResizeQuality;

resizeWidth?: number;

}

interface ImageBitmapRenderingContextSettings {

alpha?: boolean;

}

interface ImageEncodeOptions {

quality?: number;

type?: string;

}

interface ImportMeta {

url: 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<T = any> extends EventInit {

data?: T;

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 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 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?: QueuingStrategySize<T>;

}

interface QueuingStrategyInit {

/**

* Creates a new ByteLengthQueuingStrategy with the provided high water mark.

*

* Note that the provided high water mark will not be validated ahead of time. Instead, if it is negative, NaN, or not a number, the resulting ByteLengthQueuingStrategy will cause the corresponding stream constructor to throw.

*/

highWaterMark: number;

}

interface ReadableStreamDefaultReadDoneResult {

done: true;

value?: undefined;

}

interface ReadableStreamDefaultReadValueResult<T> {

done: false;

value: T;

}

interface ReadableWritablePair<R = any, W = any> {

readable: ReadableStream<R>;

/**

* Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.

*

* Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.

*/

writable: WritableStream<W>;

}

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

preventAbort?: boolean;

preventCancel?: boolean;

/**

* Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.

*

* Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.

*

* Errors and closures of the source and destination streams propagate as follows:

*

* An error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination.

*

* An error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source.

*

* When this source readable stream closes, destination will be closed, unless preventClose is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error.

*

* If destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source.

*

* The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.

*/

preventClose?: boolean;

signal?: AbortSignal;

}

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?: TransformerFlushCallback<O>;

readableType?: undefined;

start?: TransformerStartCallback<O>;

transform?: TransformerTransformCallback<I, O>;

writableType?: undefined;

}

interface UnderlyingSink<W = any> {

abort?: UnderlyingSinkAbortCallback;

close?: UnderlyingSinkCloseCallback;

start?: UnderlyingSinkStartCallback;

type?: undefined;

write?: UnderlyingSinkWriteCallback<W>;

}

interface UnderlyingSource<R = any> {

cancel?: UnderlyingSourceCancelCallback;

pull?: UnderlyingSourcePullCallback<R>;

start?: UnderlyingSourceStartCallback<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;

arrayBuffer(): Promise<ArrayBuffer>;

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

stream(): ReadableStream;

text(): Promise<string>;

}

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

readonly highWaterMark: number;

readonly size: QueuingStrategySize<ArrayBufferView>;

}

declare var ByteLengthQueuingStrategy: {

prototype: ByteLengthQueuingStrategy;

new(init: QueuingStrategyInit): 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?: MultiCacheQueryOptions): 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 | null): 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<Client | undefined>;

matchAll<T extends ClientQueryOptions>(options?: T): Promise<ReadonlyArray<T["type"] extends "window" ? WindowClient : 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 {

/**

* Returns the WebSocket connection close code provided by the server.

*/

readonly code: number;

/**

* Returns the WebSocket connection close reason provided by the server.

*/

readonly reason: string;

/**

* Returns true if the connection closed cleanly; false otherwise.

*/

readonly wasClean: boolean;

}

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;

}

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

interface CountQueuingStrategy extends QueuingStrategy {

readonly highWaterMark: number;

readonly size: QueuingStrategySize;

}

declare var CountQueuingStrategy: {

prototype: CountQueuingStrategy;

new(init: QueuingStrategyInit): CountQueuingStrategy;

};

/** Basic cryptography features available in the current context. It allows access to a cryptographically strong random number generator and to cryptographic primitives. */