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

/// Worker APIs

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

interface AddEventListenerOptions extends EventListenerOptions {

once?: boolean;

passive?: boolean;

signal?: AbortSignal;

}

interface AesCbcParams extends Algorithm {

iv: BufferSource;

}

interface AesCtrParams extends Algorithm {

counter: BufferSource;

length: number;

}

interface AesDerivedKeyParams extends Algorithm {

length: number;

}

interface AesGcmParams extends Algorithm {

additionalData?: BufferSource;

iv: BufferSource;

tagLength?: number;

}

interface AesKeyAlgorithm extends KeyAlgorithm {

length: number;

}

interface AesKeyGenParams extends Algorithm {

length: number;

}

interface Algorithm {

name: string;

}

interface AudioConfiguration {

bitrate?: number;

channels?: string;

contentType: string;

samplerate?: number;

spatialRendering?: boolean;

}

interface BlobPropertyBag {

endings?: EndingType;

type?: string;

}

interface CacheQueryOptions {

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;

handled?: Promise<undefined>;

preloadResponse?: Promise<any>;

replacesClientId?: string;

request: Request;

resultingClientId?: string;

}

interface FilePropertyBag extends BlobPropertyBag {

lastModified?: number;

}

interface FontFaceDescriptors {

display?: string;

featureSettings?: string;

stretch?: string;

style?: string;

unicodeRange?: string;

variant?: string;

weight?: string;

}

interface FontFaceSetLoadEventInit extends EventInit {

fontfaces?: FontFace[];

}

interface GetNotificationOptions {

tag?: string;

}

interface HkdfParams extends Algorithm {

hash: HashAlgorithmIdentifier;

info: BufferSource;

salt: BufferSource;

}

interface HmacImportParams extends Algorithm {

hash: HashAlgorithmIdentifier;

length?: number;

}

interface HmacKeyGenParams extends Algorithm {

hash: HashAlgorithmIdentifier;

length?: number;

}

interface IDBDatabaseInfo {

name?: string;

version?: 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 ImageDataSettings {

colorSpace?: PredefinedColorSpace;

}

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 MediaCapabilitiesDecodingInfo extends MediaCapabilitiesInfo {

configuration?: MediaDecodingConfiguration;

}

interface MediaCapabilitiesEncodingInfo extends MediaCapabilitiesInfo {

configuration?: MediaEncodingConfiguration;

}

interface MediaCapabilitiesInfo {

powerEfficient: boolean;

smooth: boolean;

supported: boolean;

}

interface MediaConfiguration {

audio?: AudioConfiguration;

video?: VideoConfiguration;

}

interface MediaDecodingConfiguration extends MediaConfiguration {

type: MediaDecodingType;

}

interface MediaEncodingConfiguration extends MediaConfiguration {

type: MediaEncodingType;

}

interface MessageEventInit<T = any> extends EventInit {

data?: T;

lastEventId?: string;

origin?: string;

ports?: MessagePort[];

source?: MessageEventSource | null;

}

interface MultiCacheQueryOptions extends CacheQueryOptions {

cacheName?: 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?: DOMTimeStamp;

vibrate?: VibratePattern;

}

interface Pbkdf2Params extends Algorithm {

hash: HashAlgorithmIdentifier;

iterations: number;

salt: BufferSource;

}

interface PerformanceMarkOptions {

detail?: any;

startTime?: DOMHighResTimeStamp;

}

interface PerformanceMeasureOptions {

detail?: any;

duration?: DOMHighResTimeStamp;

end?: string | DOMHighResTimeStamp;

start?: string | DOMHighResTimeStamp;

}

interface PerformanceObserverInit {

buffered?: boolean;

entryTypes?: string[];

type?: string;

}

interface PermissionDescriptor {

name: PermissionName;

}

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

endpoint?: string;

expirationTime?: DOMTimeStamp | 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?: null;

}

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

}

interface RsaOtherPrimesInfo {

d?: string;

r?: string;

t?: string;

}

interface RsaPssParams extends Algorithm {

saltLength: number;

}

interface SecurityPolicyViolationEventInit extends EventInit {

blockedURI?: string;

columnNumber?: number;

disposition: SecurityPolicyViolationEventDisposition;

documentURI: string;

effectiveDirective: string;

lineNumber?: number;

originalPolicy: string;

referrer?: string;

sample?: string;

sourceFile?: string;

statusCode: number;

violatedDirective: string;

}

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

transfer?: any[];

}

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

bitrate: number;

colorGamut?: ColorGamut;

contentType: string;

framerate: number;

hdrMetadataType?: HdrMetadataType;

height: number;

scalabilityMode?: string;

transferFunction?: TransferFunction;

width: number;

}

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;

}

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

// abort(): AbortSignal; - To be re-added in the future

};

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

* Available only in secure contexts.

*/

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.

* Available only in secure contexts.

*/

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;

};

/** 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, counterclockwise?: 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, counterclockwise?: 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;

}

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

readonly id: string;

readonly type: ClientTypes;

readonly url: string;

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

postMessage(message: any, options?: StructuredSerializeOptions): 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 | URL): 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;

};

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

interface Crypto {

/** Available only in secure contexts. */

readonly subtle: SubtleCrypto;

getRandomValues<T extends ArrayBufferView | null>(array: T): T;

}

declare var Crypto: {

prototype: Crypto;

new(): Crypto;

};

/**

* The CryptoKey dictionary of the Web Crypto API represents a cryptographic key.

* Available only in secure contexts.

*/

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;

/** @deprecated */

initCustomEvent(type: string, bubbles?: boolean, cancelable?: boolean, detail?: T): void;

}

declare var CustomEvent: {

prototype: CustomEvent;

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

};

/** 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 extends Error {

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;