3012 lines
110 KiB
TypeScript
3012 lines
110 KiB
TypeScript
/*! *****************************************************************************
|
|
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 {
|
|
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 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 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 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 EventListener {
|
|
(evt: Event): void;
|
|
}
|
|
|
|
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": ProgressEvent;
|
|
}
|
|
|
|
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: ProgressEvent) => 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 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 | 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;
|
|
}
|
|
|
|
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;
|
|
};
|
|
|
|
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 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;
|
|
}
|
|
|
|
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 Client {
|
|
readonly id: string;
|
|
readonly type: ClientTypes;
|
|
readonly url: string;
|
|
postMessage(message: any, transfer?: Transferable[]): void;
|
|
}
|
|
|
|
declare var Client: {
|
|
prototype: Client;
|
|
new(): Client;
|
|
};
|
|
|
|
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;
|
|
};
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
};
|
|
|
|
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;
|
|
};
|
|
|
|
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>;
|
|
};
|
|
|
|
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;
|
|
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;
|
|
readonly z: number;
|
|
matrixTransform(matrix?: DOMMatrixInit): DOMPoint;
|
|
toJSON(): any;
|
|
}
|
|
|
|
declare var DOMPointReadOnly: {
|
|
prototype: DOMPointReadOnly;
|
|
new(x?: number, y?: number, z?: number, w?: number): DOMPointReadOnly;
|
|
fromPoint(other?: DOMPointInit): DOMPointReadOnly;
|
|
};
|
|
|
|
interface DOMQuad {
|
|
readonly p1: DOMPoint;
|
|
readonly p2: DOMPoint;
|
|
readonly p3: DOMPoint;
|
|
readonly p4: DOMPoint;
|
|
getBounds(): DOMRect;
|
|
toJSON(): any;
|
|
}
|
|
|
|
declare var DOMQuad: {
|
|
prototype: DOMQuad;
|
|
new(p1?: DOMPointInit, p2?: DOMPointInit, p3?: DOMPointInit, p4?: DOMPointInit): DOMQuad;
|
|
fromQuad(other?: DOMQuadInit): DOMQuad;
|
|
fromRect(other?: DOMRectInit): DOMQuad;
|
|
};
|
|
|
|
interface DOMRect extends DOMRectReadOnly {
|
|
height: number;
|
|
width: number;
|
|
x: number;
|
|
y: number;
|
|
}
|
|
|
|
declare var DOMRect: {
|
|
prototype: DOMRect;
|
|
new(x?: number, y?: number, width?: number, height?: number): DOMRect;
|
|
fromRect(other?: DOMRectInit): DOMRect;
|
|
};
|
|
|
|
interface DOMRectReadOnly {
|
|
readonly bottom: number;
|
|
readonly height: number;
|
|
readonly left: number;
|
|
readonly right: number;
|
|
readonly top: number;
|
|
readonly width: number;
|
|
readonly x: number;
|
|
readonly y: number;
|
|
toJSON(): any;
|
|
}
|
|
|
|
declare var DOMRectReadOnly: {
|
|
prototype: DOMRectReadOnly;
|
|
new(x?: number, y?: number, width?: number, height?: number): DOMRectReadOnly;
|
|
fromRect(other?: DOMRectInit): DOMRectReadOnly;
|
|
};
|
|
|
|
interface DOMStringList {
|
|
/**
|
|
* Returns the number of strings in strings.
|
|
*/
|
|
readonly length: number;
|
|
/**
|
|
* Returns true if strings contains string, and false
|
|
* otherwise.
|
|
*/
|
|
contains(string: string): boolean;
|
|
/**
|
|
* Returns the string with index index from strings.
|
|
*/
|
|
item(index: number): string | null;
|
|
[index: number]: string;
|
|
}
|
|
|
|
declare var DOMStringList: {
|
|
prototype: DOMStringList;
|
|
new(): DOMStringList;
|
|
};
|
|
|
|
interface DedicatedWorkerGlobalScopeEventMap extends WorkerGlobalScopeEventMap {
|
|
"message": MessageEvent;
|
|
}
|
|
|
|
interface DedicatedWorkerGlobalScope extends WorkerGlobalScope {
|
|
onmessage: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;
|
|
close(): void;
|
|
postMessage(message: any, transfer?: Transferable[]): void;
|
|
addEventListener<K extends keyof DedicatedWorkerGlobalScopeEventMap>(type: K, listener: (this: DedicatedWorkerGlobalScope, ev: DedicatedWorkerGlobalScopeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof DedicatedWorkerGlobalScopeEventMap>(type: K, listener: (this: DedicatedWorkerGlobalScope, ev: DedicatedWorkerGlobalScopeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var DedicatedWorkerGlobalScope: {
|
|
prototype: DedicatedWorkerGlobalScope;
|
|
new(): DedicatedWorkerGlobalScope;
|
|
};
|
|
|
|
interface DhImportKeyParams extends Algorithm {
|
|
generator: Uint8Array;
|
|
prime: Uint8Array;
|
|
}
|
|
|
|
interface DhKeyAlgorithm extends KeyAlgorithm {
|
|
generator: Uint8Array;
|
|
prime: Uint8Array;
|
|
}
|
|
|
|
interface DhKeyDeriveParams extends Algorithm {
|
|
public: CryptoKey;
|
|
}
|
|
|
|
interface DhKeyGenParams extends Algorithm {
|
|
generator: Uint8Array;
|
|
prime: Uint8Array;
|
|
}
|
|
|
|
interface ErrorEvent extends Event {
|
|
readonly colno: number;
|
|
readonly error: any;
|
|
readonly filename: string;
|
|
readonly lineno: number;
|
|
readonly message: string;
|
|
}
|
|
|
|
declare var ErrorEvent: {
|
|
prototype: ErrorEvent;
|
|
new(type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
|
|
};
|
|
|
|
interface Event {
|
|
/**
|
|
* Returns true or false depending on how event was initialized. True if event goes through its target's ancestors in reverse tree order, and false otherwise.
|
|
*/
|
|
readonly bubbles: boolean;
|
|
cancelBubble: boolean;
|
|
readonly cancelable: boolean;
|
|
/**
|
|
* Returns true or false depending on how event was initialized. True if event invokes listeners past a ShadowRoot node that is the root of its target, and false otherwise.
|
|
*/
|
|
readonly composed: boolean;
|
|
/**
|
|
* Returns the object whose event listener's callback is currently being
|
|
* invoked.
|
|
*/
|
|
readonly currentTarget: EventTarget | null;
|
|
readonly defaultPrevented: boolean;
|
|
readonly eventPhase: number;
|
|
/**
|
|
* Returns true if event was dispatched by the user agent, and
|
|
* false otherwise.
|
|
*/
|
|
readonly isTrusted: boolean;
|
|
returnValue: boolean;
|
|
readonly srcElement: object | null;
|
|
/**
|
|
* Returns the object to which event is dispatched (its target).
|
|
*/
|
|
readonly target: EventTarget | null;
|
|
/**
|
|
* Returns the event's timestamp as the number of milliseconds measured relative to
|
|
* the time origin.
|
|
*/
|
|
readonly timeStamp: number;
|
|
/**
|
|
* Returns the type of event, e.g.
|
|
* "click", "hashchange", or
|
|
* "submit".
|
|
*/
|
|
readonly type: string;
|
|
composedPath(): EventTarget[];
|
|
initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
|
|
preventDefault(): void;
|
|
/**
|
|
* Invoking this method prevents event from reaching
|
|
* any registered event listeners after the current one finishes running and, when dispatched in a tree, also prevents event from reaching any
|
|
* other objects.
|
|
*/
|
|
stopImmediatePropagation(): void;
|
|
/**
|
|
* When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
|
|
*/
|
|
stopPropagation(): void;
|
|
readonly AT_TARGET: number;
|
|
readonly BUBBLING_PHASE: number;
|
|
readonly CAPTURING_PHASE: number;
|
|
readonly NONE: number;
|
|
}
|
|
|
|
declare var Event: {
|
|
prototype: Event;
|
|
new(type: string, eventInitDict?: EventInit): Event;
|
|
readonly AT_TARGET: number;
|
|
readonly BUBBLING_PHASE: number;
|
|
readonly CAPTURING_PHASE: number;
|
|
readonly NONE: number;
|
|
};
|
|
|
|
interface EventListenerObject {
|
|
handleEvent(evt: Event): void;
|
|
}
|
|
|
|
interface EventSource extends EventTarget {
|
|
readonly CLOSED: number;
|
|
readonly CONNECTING: number;
|
|
readonly OPEN: number;
|
|
onerror: (evt: MessageEvent) => any;
|
|
onmessage: (evt: MessageEvent) => any;
|
|
onopen: (evt: MessageEvent) => any;
|
|
readonly readyState: number;
|
|
readonly url: string;
|
|
readonly withCredentials: boolean;
|
|
close(): void;
|
|
}
|
|
|
|
declare var EventSource: {
|
|
prototype: EventSource;
|
|
new(url: string, eventSourceInitDict?: EventSourceInit): EventSource;
|
|
};
|
|
|
|
interface EventSourceInit {
|
|
readonly withCredentials: boolean;
|
|
}
|
|
|
|
interface EventTarget {
|
|
/**
|
|
* Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.
|
|
* The options argument sets listener-specific options. For compatibility this can be a
|
|
* boolean, in which case the method behaves exactly as if the value was specified as options's capture.
|
|
* When set to true, options's capture prevents callback from being invoked when the event's eventPhase attribute value is BUBBLING_PHASE. When false (or not present), callback will not be invoked when event's eventPhase attribute value is CAPTURING_PHASE. Either way, callback will be invoked if event's eventPhase attribute value is AT_TARGET.
|
|
* When set to true, options's passive indicates that the callback will not cancel the event by invoking preventDefault(). This is used to enable performance optimizations described in §2.8 Observing event listeners.
|
|
* When set to true, options's once indicates that the callback will only be invoked once after which the event listener will
|
|
* be removed.
|
|
* The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.
|
|
*/
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
|
|
/**
|
|
* Dispatches a synthetic event event to target and returns true
|
|
* if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.
|
|
*/
|
|
dispatchEvent(event: Event): boolean;
|
|
/**
|
|
* Removes the event listener in target's event listener list with the same type, callback, and options.
|
|
*/
|
|
removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
|
|
}
|
|
|
|
declare var EventTarget: {
|
|
prototype: EventTarget;
|
|
new(): EventTarget;
|
|
};
|
|
|
|
interface ExtendableEvent extends Event {
|
|
waitUntil(f: Promise<any>): void;
|
|
}
|
|
|
|
declare var ExtendableEvent: {
|
|
prototype: ExtendableEvent;
|
|
new(type: string, eventInitDict?: ExtendableEventInit): ExtendableEvent;
|
|
};
|
|
|
|
interface ExtendableMessageEvent extends ExtendableEvent {
|
|
readonly data: any;
|
|
readonly lastEventId: string;
|
|
readonly origin: string;
|
|
readonly ports: ReadonlyArray<MessagePort>;
|
|
readonly source: Client | ServiceWorker | MessagePort | null;
|
|
}
|
|
|
|
declare var ExtendableMessageEvent: {
|
|
prototype: ExtendableMessageEvent;
|
|
new(type: string, eventInitDict?: ExtendableMessageEventInit): ExtendableMessageEvent;
|
|
};
|
|
|
|
interface FetchEvent extends ExtendableEvent {
|
|
readonly clientId: string;
|
|
readonly preloadResponse: Promise<any>;
|
|
readonly request: Request;
|
|
readonly resultingClientId: string;
|
|
readonly targetClientId: string;
|
|
respondWith(r: Promise<Response>): void;
|
|
}
|
|
|
|
declare var FetchEvent: {
|
|
prototype: FetchEvent;
|
|
new(type: string, eventInitDict: FetchEventInit): FetchEvent;
|
|
};
|
|
|
|
interface File extends Blob {
|
|
readonly lastModified: number;
|
|
readonly name: string;
|
|
}
|
|
|
|
declare var File: {
|
|
prototype: File;
|
|
new(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
|
|
};
|
|
|
|
interface FileList {
|
|
readonly length: number;
|
|
item(index: number): File | null;
|
|
[index: number]: File;
|
|
}
|
|
|
|
declare var FileList: {
|
|
prototype: FileList;
|
|
new(): FileList;
|
|
};
|
|
|
|
interface FileReaderEventMap {
|
|
"abort": ProgressEvent;
|
|
"error": ProgressEvent;
|
|
"load": ProgressEvent;
|
|
"loadend": ProgressEvent;
|
|
"loadstart": ProgressEvent;
|
|
"progress": ProgressEvent;
|
|
}
|
|
|
|
interface FileReader extends EventTarget {
|
|
readonly error: DOMException | null;
|
|
onabort: ((this: FileReader, ev: ProgressEvent) => any) | null;
|
|
onerror: ((this: FileReader, ev: ProgressEvent) => any) | null;
|
|
onload: ((this: FileReader, ev: ProgressEvent) => any) | null;
|
|
onloadend: ((this: FileReader, ev: ProgressEvent) => any) | null;
|
|
onloadstart: ((this: FileReader, ev: ProgressEvent) => any) | null;
|
|
onprogress: ((this: FileReader, ev: ProgressEvent) => any) | null;
|
|
readonly readyState: number;
|
|
readonly result: string | ArrayBuffer | null;
|
|
abort(): void;
|
|
readAsArrayBuffer(blob: Blob): void;
|
|
readAsBinaryString(blob: Blob): void;
|
|
readAsDataURL(blob: Blob): void;
|
|
readAsText(blob: Blob, label?: string): void;
|
|
readonly DONE: number;
|
|
readonly EMPTY: number;
|
|
readonly LOADING: number;
|
|
addEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof FileReaderEventMap>(type: K, listener: (this: FileReader, ev: FileReaderEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var FileReader: {
|
|
prototype: FileReader;
|
|
new(): FileReader;
|
|
readonly DONE: number;
|
|
readonly EMPTY: number;
|
|
readonly LOADING: number;
|
|
};
|
|
|
|
interface FileReaderSync {
|
|
readAsArrayBuffer(blob: Blob): ArrayBuffer;
|
|
readAsBinaryString(blob: Blob): string;
|
|
readAsDataURL(blob: Blob): string;
|
|
readAsText(blob: Blob, label?: string): string;
|
|
}
|
|
|
|
declare var FileReaderSync: {
|
|
prototype: FileReaderSync;
|
|
new(): FileReaderSync;
|
|
};
|
|
|
|
interface FormData {
|
|
append(name: string, value: string | Blob, fileName?: string): void;
|
|
delete(name: string): void;
|
|
get(name: string): FormDataEntryValue | null;
|
|
getAll(name: string): FormDataEntryValue[];
|
|
has(name: string): boolean;
|
|
set(name: string, value: string | Blob, fileName?: string): void;
|
|
forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
|
|
}
|
|
|
|
declare var FormData: {
|
|
prototype: FormData;
|
|
new(): FormData;
|
|
};
|
|
|
|
interface GlobalFetch {
|
|
fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
|
|
}
|
|
|
|
interface Headers {
|
|
append(name: string, value: string): void;
|
|
delete(name: string): void;
|
|
get(name: string): string | null;
|
|
has(name: string): boolean;
|
|
set(name: string, value: string): void;
|
|
forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
|
|
}
|
|
|
|
declare var Headers: {
|
|
prototype: Headers;
|
|
new(init?: HeadersInit): Headers;
|
|
};
|
|
|
|
interface HkdfCtrParams extends Algorithm {
|
|
context: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
|
|
hash: string | Algorithm;
|
|
label: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer;
|
|
}
|
|
|
|
interface IDBArrayKey extends Array<IDBValidKey> {
|
|
}
|
|
|
|
interface IDBCursor {
|
|
/**
|
|
* Returns the direction ("next", "nextunique", "prev" or "prevunique")
|
|
* of the cursor.
|
|
*/
|
|
readonly direction: IDBCursorDirection;
|
|
/**
|
|
* Returns the key of the cursor.
|
|
* Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
|
|
*/
|
|
readonly key: IDBValidKey | IDBKeyRange;
|
|
/**
|
|
* Returns the effective key of the cursor.
|
|
* Throws a "InvalidStateError" DOMException if the cursor is advancing or is finished.
|
|
*/
|
|
readonly primaryKey: IDBValidKey | IDBKeyRange;
|
|
/**
|
|
* Returns the IDBObjectStore or IDBIndex the cursor was opened from.
|
|
*/
|
|
readonly source: IDBObjectStore | IDBIndex;
|
|
/**
|
|
* Advances the cursor through the next count records in
|
|
* range.
|
|
*/
|
|
advance(count: number): void;
|
|
/**
|
|
* Advances the cursor to the next record in range matching or
|
|
* after key.
|
|
*/
|
|
continue(key?: IDBValidKey | IDBKeyRange): void;
|
|
/**
|
|
* Advances the cursor to the next record in range matching
|
|
* or after key and primaryKey. Throws an "InvalidAccessError" DOMException if the source is not an index.
|
|
*/
|
|
continuePrimaryKey(key: IDBValidKey | IDBKeyRange, primaryKey: IDBValidKey | IDBKeyRange): void;
|
|
/**
|
|
* Delete the record pointed at by the cursor with a new value.
|
|
* If successful, request's result will be undefined.
|
|
*/
|
|
delete(): IDBRequest<undefined>;
|
|
/**
|
|
* Updated the record pointed at by the cursor with a new value.
|
|
* Throws a "DataError" DOMException if the effective object store uses in-line keys and the key would have changed.
|
|
* If successful, request's result will be the record's key.
|
|
*/
|
|
update(value: any): IDBRequest<IDBValidKey>;
|
|
}
|
|
|
|
declare var IDBCursor: {
|
|
prototype: IDBCursor;
|
|
new(): IDBCursor;
|
|
};
|
|
|
|
interface IDBCursorWithValue extends IDBCursor {
|
|
/**
|
|
* Returns the cursor's current value.
|
|
*/
|
|
readonly value: any;
|
|
}
|
|
|
|
declare var IDBCursorWithValue: {
|
|
prototype: IDBCursorWithValue;
|
|
new(): IDBCursorWithValue;
|
|
};
|
|
|
|
interface IDBDatabaseEventMap {
|
|
"abort": Event;
|
|
"close": Event;
|
|
"error": Event;
|
|
"versionchange": IDBVersionChangeEvent;
|
|
}
|
|
|
|
interface IDBDatabase extends EventTarget {
|
|
/**
|
|
* Returns the name of the database.
|
|
*/
|
|
readonly name: string;
|
|
/**
|
|
* Returns a list of the names of object stores in the database.
|
|
*/
|
|
readonly objectStoreNames: DOMStringList;
|
|
onabort: ((this: IDBDatabase, ev: Event) => any) | null;
|
|
onclose: ((this: IDBDatabase, ev: Event) => any) | null;
|
|
onerror: ((this: IDBDatabase, ev: Event) => any) | null;
|
|
onversionchange: ((this: IDBDatabase, ev: IDBVersionChangeEvent) => any) | null;
|
|
/**
|
|
* Returns the version of the database.
|
|
*/
|
|
readonly version: number;
|
|
/**
|
|
* Closes the connection once all running transactions have finished.
|
|
*/
|
|
close(): void;
|
|
/**
|
|
* Creates a new object store with the given name and options and returns a new IDBObjectStore.
|
|
* Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
|
|
*/
|
|
createObjectStore(name: string, optionalParameters?: IDBObjectStoreParameters): IDBObjectStore;
|
|
/**
|
|
* Deletes the object store with the given name.
|
|
* Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
|
|
*/
|
|
deleteObjectStore(name: string): void;
|
|
/**
|
|
* Returns a new transaction with the given mode ("readonly" or "readwrite")
|
|
* and scope which can be a single object store name or an array of names.
|
|
*/
|
|
transaction(storeNames: string | string[], mode?: IDBTransactionMode): IDBTransaction;
|
|
addEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var IDBDatabase: {
|
|
prototype: IDBDatabase;
|
|
new(): IDBDatabase;
|
|
};
|
|
|
|
interface IDBFactory {
|
|
/**
|
|
* Compares two values as keys. Returns -1 if key1 precedes key2, 1 if key2 precedes key1, and 0 if
|
|
* the keys are equal.
|
|
* Throws a "DataError" DOMException if either input is not a valid key.
|
|
*/
|
|
cmp(first: any, second: any): number;
|
|
/**
|
|
* Attempts to delete the named database. If the
|
|
* database already exists and there are open connections that don't close in response to a versionchange event, the request will be blocked until all they close. If the request
|
|
* is successful request's result will be null.
|
|
*/
|
|
deleteDatabase(name: string): IDBOpenDBRequest;
|
|
/**
|
|
* Attempts to open a connection to the named database with the specified version. If the database already exists
|
|
* with a lower version and there are open connections that don't close in response to a versionchange event, the request will be blocked until all they close, then an upgrade
|
|
* will occur. If the database already exists with a higher
|
|
* version the request will fail. If the request is
|
|
* successful request's result will
|
|
* be the connection.
|
|
*/
|
|
open(name: string, version?: number): IDBOpenDBRequest;
|
|
}
|
|
|
|
declare var IDBFactory: {
|
|
prototype: IDBFactory;
|
|
new(): IDBFactory;
|
|
};
|
|
|
|
interface IDBIndex {
|
|
readonly keyPath: string | string[];
|
|
readonly multiEntry: boolean;
|
|
/**
|
|
* Updates the name of the store to newName.
|
|
* Throws an "InvalidStateError" DOMException if not called within an upgrade
|
|
* transaction.
|
|
*/
|
|
name: string;
|
|
/**
|
|
* Returns the IDBObjectStore the index belongs to.
|
|
*/
|
|
readonly objectStore: IDBObjectStore;
|
|
readonly unique: boolean;
|
|
/**
|
|
* Retrieves the number of records matching the given key or key range in query.
|
|
* If successful, request's result will be the
|
|
* count.
|
|
*/
|
|
count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
|
|
/**
|
|
* Retrieves the value of the first record matching the
|
|
* given key or key range in query.
|
|
* If successful, request's result will be the value, or undefined if there was no matching record.
|
|
*/
|
|
get(key: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
|
|
/**
|
|
* Retrieves the values of the records matching the given key or key range in query (up to count if given).
|
|
* If successful, request's result will be an Array of the values.
|
|
*/
|
|
getAll(query?: IDBValidKey | IDBKeyRange, count?: number): IDBRequest<any[]>;
|
|
/**
|
|
* Retrieves the keys of records matching the given key or key range in query (up to count if given).
|
|
* If successful, request's result will be an Array of the keys.
|
|
*/
|
|
getAllKeys(query?: IDBValidKey | IDBKeyRange, count?: number): IDBRequest<IDBValidKey[]>;
|
|
/**
|
|
* Retrieves the key of the first record matching the
|
|
* given key or key range in query.
|
|
* If successful, request's result will be the key, or undefined if there was no matching record.
|
|
*/
|
|
getKey(key: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
|
|
/**
|
|
* Opens a cursor over the records matching query,
|
|
* ordered by direction. If query is null, all records in index are matched.
|
|
* If successful, request's result will be an IDBCursorWithValue, or null if there were no matching records.
|
|
*/
|
|
openCursor(range?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
|
|
/**
|
|
* Opens a cursor with key only flag set over the records matching query, ordered by direction. If query is null, all records in index are matched.
|
|
* If successful, request's result will be an IDBCursor, or null if there were no matching records.
|
|
*/
|
|
openKeyCursor(range?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
|
|
}
|
|
|
|
declare var IDBIndex: {
|
|
prototype: IDBIndex;
|
|
new(): IDBIndex;
|
|
};
|
|
|
|
interface IDBKeyRange {
|
|
/**
|
|
* Returns lower bound, or undefined if none.
|
|
*/
|
|
readonly lower: any;
|
|
/**
|
|
* Returns true if the lower open flag is set, and false otherwise.
|
|
*/
|
|
readonly lowerOpen: boolean;
|
|
/**
|
|
* Returns upper bound, or undefined if none.
|
|
*/
|
|
readonly upper: any;
|
|
/**
|
|
* Returns true if the upper open flag is set, and false otherwise.
|
|
*/
|
|
readonly upperOpen: boolean;
|
|
/**
|
|
* Returns true if key is included in the range, and false otherwise.
|
|
*/
|
|
includes(key: any): boolean;
|
|
}
|
|
|
|
declare var IDBKeyRange: {
|
|
prototype: IDBKeyRange;
|
|
new(): IDBKeyRange;
|
|
/**
|
|
* Returns a new IDBKeyRange spanning from lower to upper.
|
|
* If lowerOpen is true, lower is not included in the range.
|
|
* If upperOpen is true, upper is not included in the range.
|
|
*/
|
|
bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
|
|
/**
|
|
* Returns a new IDBKeyRange starting at key with no
|
|
* upper bound. If open is true, key is not included in the
|
|
* range.
|
|
*/
|
|
lowerBound(lower: any, open?: boolean): IDBKeyRange;
|
|
/**
|
|
* Returns a new IDBKeyRange spanning only key.
|
|
*/
|
|
only(value: any): IDBKeyRange;
|
|
/**
|
|
* Returns a new IDBKeyRange with no lower bound and ending at key. If open is true, key is not included in the range.
|
|
*/
|
|
upperBound(upper: any, open?: boolean): IDBKeyRange;
|
|
};
|
|
|
|
interface IDBObjectStore {
|
|
/**
|
|
* Returns true if the store has a key generator, and false otherwise.
|
|
*/
|
|
readonly autoIncrement: boolean;
|
|
/**
|
|
* Returns a list of the names of indexes in the store.
|
|
*/
|
|
readonly indexNames: DOMStringList;
|
|
/**
|
|
* Returns the key path of the store, or null if none.
|
|
*/
|
|
readonly keyPath: string | string[];
|
|
/**
|
|
* Updates the name of the store to newName.
|
|
* Throws "InvalidStateError" DOMException if not called within an upgrade
|
|
* transaction.
|
|
*/
|
|
name: string;
|
|
/**
|
|
* Returns the associated transaction.
|
|
*/
|
|
readonly transaction: IDBTransaction;
|
|
add(value: any, key?: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey>;
|
|
/**
|
|
* Deletes all records in store.
|
|
* If successful, request's result will
|
|
* be undefined.
|
|
*/
|
|
clear(): IDBRequest<undefined>;
|
|
/**
|
|
* Retrieves the number of records matching the
|
|
* given key or key range in query.
|
|
* If successful, request's result will be the count.
|
|
*/
|
|
count(key?: IDBValidKey | IDBKeyRange): IDBRequest<number>;
|
|
/**
|
|
* Creates a new index in store with the given name, keyPath and options and returns a new IDBIndex. If the keyPath and options define constraints that cannot be
|
|
* satisfied with the data already in store the upgrade
|
|
* transaction will abort with
|
|
* a "ConstraintError" DOMException.
|
|
* Throws an "InvalidStateError" DOMException if not called within an upgrade
|
|
* transaction.
|
|
*/
|
|
createIndex(name: string, keyPath: string | string[], options?: IDBIndexParameters): IDBIndex;
|
|
/**
|
|
* Deletes records in store with the given key or in the given key range in query.
|
|
* If successful, request's result will
|
|
* be undefined.
|
|
*/
|
|
delete(key: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
|
|
/**
|
|
* Deletes the index in store with the given name.
|
|
* Throws an "InvalidStateError" DOMException if not called within an upgrade
|
|
* transaction.
|
|
*/
|
|
deleteIndex(name: string): void;
|
|
/**
|
|
* Retrieves the value of the first record matching the
|
|
* given key or key range in query.
|
|
* If successful, request's result will be the value, or undefined if there was no matching record.
|
|
*/
|
|
get(query: IDBValidKey | IDBKeyRange): IDBRequest<any | undefined>;
|
|
/**
|
|
* Retrieves the values of the records matching the
|
|
* given key or key range in query (up to count if given).
|
|
* If successful, request's result will
|
|
* be an Array of the values.
|
|
*/
|
|
getAll(query?: IDBValidKey | IDBKeyRange, count?: number): IDBRequest<any[]>;
|
|
/**
|
|
* Retrieves the keys of records matching the
|
|
* given key or key range in query (up to count if given).
|
|
* If successful, request's result will
|
|
* be an Array of the keys.
|
|
*/
|
|
getAllKeys(query?: IDBValidKey | IDBKeyRange, count?: number): IDBRequest<IDBValidKey[]>;
|
|
/**
|
|
* Retrieves the key of the first record matching the
|
|
* given key or key range in query.
|
|
* If successful, request's result will be the key, or undefined if there was no matching record.
|
|
*/
|
|
getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
|
|
index(name: string): IDBIndex;
|
|
/**
|
|
* Opens a cursor over the records matching query,
|
|
* ordered by direction. If query is null, all records in store are matched.
|
|
* If successful, request's result will be an IDBCursorWithValue pointing at the first matching record, or null if there were no matching records.
|
|
*/
|
|
openCursor(range?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection): IDBRequest<IDBCursorWithValue | null>;
|
|
/**
|
|
* Opens a cursor with key only flag set over the records matching query, ordered by direction. If query is null, all records in store are matched.
|
|
* If successful, request's result will be an IDBCursor pointing at the first matching record, or
|
|
* null if there were no matching records.
|
|
*/
|
|
openKeyCursor(query?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection): IDBRequest<IDBCursor | null>;
|
|
put(value: any, key?: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey>;
|
|
}
|
|
|
|
declare var IDBObjectStore: {
|
|
prototype: IDBObjectStore;
|
|
new(): IDBObjectStore;
|
|
};
|
|
|
|
interface IDBOpenDBRequestEventMap extends IDBRequestEventMap {
|
|
"blocked": Event;
|
|
"upgradeneeded": IDBVersionChangeEvent;
|
|
}
|
|
|
|
interface IDBOpenDBRequest extends IDBRequest<IDBDatabase> {
|
|
onblocked: ((this: IDBOpenDBRequest, ev: Event) => any) | null;
|
|
onupgradeneeded: ((this: IDBOpenDBRequest, ev: IDBVersionChangeEvent) => any) | null;
|
|
addEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var IDBOpenDBRequest: {
|
|
prototype: IDBOpenDBRequest;
|
|
new(): IDBOpenDBRequest;
|
|
};
|
|
|
|
interface IDBRequestEventMap {
|
|
"error": Event;
|
|
"success": Event;
|
|
}
|
|
|
|
interface IDBRequest<T = any> extends EventTarget {
|
|
/**
|
|
* When a request is completed, returns the error (a DOMException), or null if the request succeeded. Throws
|
|
* a "InvalidStateError" DOMException if the request is still pending.
|
|
*/
|
|
readonly error: DOMException | null;
|
|
onerror: ((this: IDBRequest<T>, ev: Event) => any) | null;
|
|
onsuccess: ((this: IDBRequest<T>, ev: Event) => any) | null;
|
|
/**
|
|
* Returns "pending" until a request is complete,
|
|
* then returns "done".
|
|
*/
|
|
readonly readyState: IDBRequestReadyState;
|
|
/**
|
|
* When a request is completed, returns the result,
|
|
* or undefined if the request failed. Throws a
|
|
* "InvalidStateError" DOMException if the request is still pending.
|
|
*/
|
|
readonly result: T;
|
|
/**
|
|
* Returns the IDBObjectStore, IDBIndex, or IDBCursor the request was made against, or null if is was an open
|
|
* request.
|
|
*/
|
|
readonly source: IDBObjectStore | IDBIndex | IDBCursor;
|
|
/**
|
|
* Returns the IDBTransaction the request was made within.
|
|
* If this as an open request, then it returns an upgrade transaction while it is running, or null otherwise.
|
|
*/
|
|
readonly transaction: IDBTransaction | null;
|
|
addEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest<T>, ev: IDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var IDBRequest: {
|
|
prototype: IDBRequest;
|
|
new(): IDBRequest;
|
|
};
|
|
|
|
interface IDBTransactionEventMap {
|
|
"abort": Event;
|
|
"complete": Event;
|
|
"error": Event;
|
|
}
|
|
|
|
interface IDBTransaction extends EventTarget {
|
|
/**
|
|
* Returns the transaction's connection.
|
|
*/
|
|
readonly db: IDBDatabase;
|
|
/**
|
|
* If the transaction was aborted, returns the
|
|
* error (a DOMException) providing the reason.
|
|
*/
|
|
readonly error: DOMException;
|
|
/**
|
|
* Returns the mode the transaction was created with
|
|
* ("readonly" or "readwrite"), or "versionchange" for
|
|
* an upgrade transaction.
|
|
*/
|
|
readonly mode: IDBTransactionMode;
|
|
/**
|
|
* Returns a list of the names of object stores in the
|
|
* transaction's scope. For an upgrade transaction this is all object stores in the database.
|
|
*/
|
|
readonly objectStoreNames: DOMStringList;
|
|
onabort: ((this: IDBTransaction, ev: Event) => any) | null;
|
|
oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
|
|
onerror: ((this: IDBTransaction, ev: Event) => any) | null;
|
|
/**
|
|
* Aborts the transaction. All pending requests will fail with
|
|
* a "AbortError" DOMException and all changes made to the database will be
|
|
* reverted.
|
|
*/
|
|
abort(): void;
|
|
/**
|
|
* Returns an IDBObjectStore in the transaction's scope.
|
|
*/
|
|
objectStore(name: string): IDBObjectStore;
|
|
addEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof IDBTransactionEventMap>(type: K, listener: (this: IDBTransaction, ev: IDBTransactionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var IDBTransaction: {
|
|
prototype: IDBTransaction;
|
|
new(): IDBTransaction;
|
|
};
|
|
|
|
interface IDBVersionChangeEvent extends Event {
|
|
readonly newVersion: number | null;
|
|
readonly oldVersion: number;
|
|
}
|
|
|
|
declare var IDBVersionChangeEvent: {
|
|
prototype: IDBVersionChangeEvent;
|
|
new(type: string, eventInitDict?: IDBVersionChangeEventInit): IDBVersionChangeEvent;
|
|
};
|
|
|
|
interface ImageBitmap {
|
|
/**
|
|
* Returns the intrinsic height of the image, in CSS
|
|
* pixels.
|
|
*/
|
|
readonly height: number;
|
|
/**
|
|
* Returns the intrinsic width of the image, in CSS
|
|
* pixels.
|
|
*/
|
|
readonly width: number;
|
|
/**
|
|
* Releases imageBitmap's underlying bitmap data.
|
|
*/
|
|
close(): void;
|
|
}
|
|
|
|
declare var ImageBitmap: {
|
|
prototype: ImageBitmap;
|
|
new(): ImageBitmap;
|
|
};
|
|
|
|
interface ImageBitmapOptions {
|
|
colorSpaceConversion?: "none" | "default";
|
|
imageOrientation?: "none" | "flipY";
|
|
premultiplyAlpha?: "none" | "premultiply" | "default";
|
|
resizeHeight?: number;
|
|
resizeQuality?: "pixelated" | "low" | "medium" | "high";
|
|
resizeWidth?: number;
|
|
}
|
|
|
|
interface ImageData {
|
|
/**
|
|
* Returns the one-dimensional array containing the data in RGBA order, as integers in the
|
|
* range 0 to 255.
|
|
*/
|
|
readonly data: Uint8ClampedArray;
|
|
/**
|
|
* Returns the actual dimensions of the data in the ImageData object, in
|
|
* pixels.
|
|
*/
|
|
readonly height: number;
|
|
readonly width: number;
|
|
}
|
|
|
|
declare var ImageData: {
|
|
prototype: ImageData;
|
|
new(width: number, height: number): ImageData;
|
|
new(array: Uint8ClampedArray, width: number, height: number): ImageData;
|
|
};
|
|
|
|
interface MessageChannel {
|
|
readonly port1: MessagePort;
|
|
readonly port2: MessagePort;
|
|
}
|
|
|
|
declare var MessageChannel: {
|
|
prototype: MessageChannel;
|
|
new(): MessageChannel;
|
|
};
|
|
|
|
interface MessageEvent extends Event {
|
|
/**
|
|
* Returns the data of the message.
|
|
*/
|
|
readonly data: any;
|
|
/**
|
|
* Returns the last event ID string, for
|
|
* server-sent events.
|
|
*/
|
|
readonly lastEventId: string;
|
|
/**
|
|
* Returns the origin of the message, for server-sent events and
|
|
* cross-document messaging.
|
|
*/
|
|
readonly origin: string;
|
|
/**
|
|
* Returns the MessagePort array sent with the message, for cross-document
|
|
* messaging and channel messaging.
|
|
*/
|
|
readonly ports: ReadonlyArray<MessagePort>;
|
|
/**
|
|
* Returns the WindowProxy of the source window, for cross-document
|
|
* messaging, and the MessagePort being attached, in the connect event fired at
|
|
* SharedWorkerGlobalScope objects.
|
|
*/
|
|
readonly source: MessageEventSource | null;
|
|
}
|
|
|
|
declare var MessageEvent: {
|
|
prototype: MessageEvent;
|
|
new(type: string, eventInitDict?: MessageEventInit): MessageEvent;
|
|
};
|
|
|
|
interface MessagePortEventMap {
|
|
"message": MessageEvent;
|
|
"messageerror": MessageEvent;
|
|
}
|
|
|
|
interface MessagePort extends EventTarget {
|
|
onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
|
|
onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
|
|
/**
|
|
* Disconnects the port, so that it is no longer active.
|
|
*/
|
|
close(): void;
|
|
/**
|
|
* Posts a message through the channel. Objects listed in transfer are
|
|
* transferred, not just cloned, meaning that they are no longer usable on the sending side.
|
|
* Throws a "DataCloneError" DOMException if
|
|
* transfer contains duplicate objects or port, or if message
|
|
* could not be cloned.
|
|
*/
|
|
postMessage(message: any, transfer?: Transferable[]): void;
|
|
/**
|
|
* Begins dispatching messages received on the port.
|
|
*/
|
|
start(): void;
|
|
addEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var MessagePort: {
|
|
prototype: MessagePort;
|
|
new(): MessagePort;
|
|
};
|
|
|
|
interface NavigationPreloadManager {
|
|
disable(): Promise<void>;
|
|
enable(): Promise<void>;
|
|
getState(): Promise<NavigationPreloadState>;
|
|
setHeaderValue(value: string): Promise<void>;
|
|
}
|
|
|
|
declare var NavigationPreloadManager: {
|
|
prototype: NavigationPreloadManager;
|
|
new(): NavigationPreloadManager;
|
|
};
|
|
|
|
interface NavigatorBeacon {
|
|
sendBeacon(url: string, data?: Blob | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | FormData | string | null): boolean;
|
|
}
|
|
|
|
interface NavigatorConcurrentHardware {
|
|
readonly hardwareConcurrency: number;
|
|
}
|
|
|
|
interface NavigatorID {
|
|
readonly appCodeName: string;
|
|
readonly appName: string;
|
|
readonly appVersion: string;
|
|
readonly platform: string;
|
|
readonly product: string;
|
|
readonly productSub: string;
|
|
readonly userAgent: string;
|
|
readonly vendor: string;
|
|
readonly vendorSub: string;
|
|
}
|
|
|
|
interface NavigatorOnLine {
|
|
readonly onLine: boolean;
|
|
}
|
|
|
|
interface NavigatorStorage {
|
|
readonly storage: StorageManager;
|
|
}
|
|
|
|
interface NotificationEventMap {
|
|
"click": Event;
|
|
"close": Event;
|
|
"error": Event;
|
|
"show": Event;
|
|
}
|
|
|
|
interface Notification extends EventTarget {
|
|
readonly actions: ReadonlyArray<NotificationAction>;
|
|
readonly badge: string;
|
|
readonly body: string;
|
|
readonly data: any;
|
|
readonly dir: NotificationDirection;
|
|
readonly icon: string;
|
|
readonly image: string;
|
|
readonly lang: string;
|
|
onclick: ((this: Notification, ev: Event) => any) | null;
|
|
onclose: ((this: Notification, ev: Event) => any) | null;
|
|
onerror: ((this: Notification, ev: Event) => any) | null;
|
|
onshow: ((this: Notification, ev: Event) => any) | null;
|
|
readonly renotify: boolean;
|
|
readonly requireInteraction: boolean;
|
|
readonly silent: boolean;
|
|
readonly tag: string;
|
|
readonly timestamp: number;
|
|
readonly title: string;
|
|
readonly vibrate: ReadonlyArray<number>;
|
|
close(): void;
|
|
addEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof NotificationEventMap>(type: K, listener: (this: Notification, ev: NotificationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var Notification: {
|
|
prototype: Notification;
|
|
new(title: string, options?: NotificationOptions): Notification;
|
|
readonly maxActions: number;
|
|
readonly permission: NotificationPermission;
|
|
};
|
|
|
|
interface NotificationEvent extends ExtendableEvent {
|
|
readonly action: string;
|
|
readonly notification: Notification;
|
|
}
|
|
|
|
declare var NotificationEvent: {
|
|
prototype: NotificationEvent;
|
|
new(type: string, eventInitDict: NotificationEventInit): NotificationEvent;
|
|
};
|
|
|
|
interface Path2D extends CanvasPath {
|
|
addPath(path: Path2D, transform?: DOMMatrix2DInit): void;
|
|
}
|
|
|
|
declare var Path2D: {
|
|
prototype: Path2D;
|
|
new(path?: Path2D | string): Path2D;
|
|
};
|
|
|
|
interface PerformanceEventMap {
|
|
"resourcetimingbufferfull": Event;
|
|
}
|
|
|
|
interface Performance extends EventTarget {
|
|
onresourcetimingbufferfull: ((this: Performance, ev: Event) => any) | null;
|
|
readonly timeOrigin: number;
|
|
clearMarks(markName?: string): void;
|
|
clearMeasures(measureName?: string): void;
|
|
clearResourceTimings(): void;
|
|
getEntries(): PerformanceEntryList;
|
|
getEntriesByName(name: string, type?: string): PerformanceEntryList;
|
|
getEntriesByType(type: string): PerformanceEntryList;
|
|
mark(markName: string): void;
|
|
measure(measureName: string, startMark?: string, endMark?: string): void;
|
|
now(): number;
|
|
setResourceTimingBufferSize(maxSize: number): void;
|
|
toJSON(): any;
|
|
addEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof PerformanceEventMap>(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var Performance: {
|
|
prototype: Performance;
|
|
new(): Performance;
|
|
};
|
|
|
|
interface PerformanceEntry {
|
|
readonly duration: number;
|
|
readonly entryType: string;
|
|
readonly name: string;
|
|
readonly startTime: number;
|
|
toJSON(): any;
|
|
}
|
|
|
|
declare var PerformanceEntry: {
|
|
prototype: PerformanceEntry;
|
|
new(): PerformanceEntry;
|
|
};
|
|
|
|
interface PerformanceMark extends PerformanceEntry {
|
|
}
|
|
|
|
declare var PerformanceMark: {
|
|
prototype: PerformanceMark;
|
|
new(): PerformanceMark;
|
|
};
|
|
|
|
interface PerformanceMeasure extends PerformanceEntry {
|
|
}
|
|
|
|
declare var PerformanceMeasure: {
|
|
prototype: PerformanceMeasure;
|
|
new(): PerformanceMeasure;
|
|
};
|
|
|
|
interface PerformanceObserver {
|
|
disconnect(): void;
|
|
observe(options: PerformanceObserverInit): void;
|
|
takeRecords(): PerformanceEntryList;
|
|
}
|
|
|
|
declare var PerformanceObserver: {
|
|
prototype: PerformanceObserver;
|
|
new(callback: PerformanceObserverCallback): PerformanceObserver;
|
|
};
|
|
|
|
interface PerformanceObserverEntryList {
|
|
getEntries(): PerformanceEntryList;
|
|
getEntriesByName(name: string, type?: string): PerformanceEntryList;
|
|
getEntriesByType(type: string): PerformanceEntryList;
|
|
}
|
|
|
|
declare var PerformanceObserverEntryList: {
|
|
prototype: PerformanceObserverEntryList;
|
|
new(): PerformanceObserverEntryList;
|
|
};
|
|
|
|
interface PerformanceResourceTiming extends PerformanceEntry {
|
|
readonly connectEnd: number;
|
|
readonly connectStart: number;
|
|
readonly decodedBodySize: number;
|
|
readonly domainLookupEnd: number;
|
|
readonly domainLookupStart: number;
|
|
readonly encodedBodySize: number;
|
|
readonly fetchStart: number;
|
|
readonly initiatorType: string;
|
|
readonly nextHopProtocol: string;
|
|
readonly redirectEnd: number;
|
|
readonly redirectStart: number;
|
|
readonly requestStart: number;
|
|
readonly responseEnd: number;
|
|
readonly responseStart: number;
|
|
readonly secureConnectionStart: number;
|
|
readonly transferSize: number;
|
|
readonly workerStart: number;
|
|
toJSON(): any;
|
|
}
|
|
|
|
declare var PerformanceResourceTiming: {
|
|
prototype: PerformanceResourceTiming;
|
|
new(): PerformanceResourceTiming;
|
|
};
|
|
|
|
interface ProgressEvent extends Event {
|
|
readonly lengthComputable: boolean;
|
|
readonly loaded: number;
|
|
readonly total: number;
|
|
}
|
|
|
|
declare var ProgressEvent: {
|
|
prototype: ProgressEvent;
|
|
new(type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
|
|
};
|
|
|
|
interface PromiseRejectionEvent extends Event {
|
|
readonly promise: Promise<any>;
|
|
readonly reason: any;
|
|
}
|
|
|
|
declare var PromiseRejectionEvent: {
|
|
prototype: PromiseRejectionEvent;
|
|
new(type: string, eventInitDict: PromiseRejectionEventInit): PromiseRejectionEvent;
|
|
};
|
|
|
|
interface PushEvent extends ExtendableEvent {
|
|
readonly data: PushMessageData | null;
|
|
}
|
|
|
|
declare var PushEvent: {
|
|
prototype: PushEvent;
|
|
new(type: string, eventInitDict?: PushEventInit): PushEvent;
|
|
};
|
|
|
|
interface PushManager {
|
|
getSubscription(): Promise<PushSubscription | null>;
|
|
permissionState(options?: PushSubscriptionOptionsInit): Promise<PushPermissionState>;
|
|
subscribe(options?: PushSubscriptionOptionsInit): Promise<PushSubscription>;
|
|
}
|
|
|
|
declare var PushManager: {
|
|
prototype: PushManager;
|
|
new(): PushManager;
|
|
readonly supportedContentEncodings: ReadonlyArray<string>;
|
|
};
|
|
|
|
interface PushMessageData {
|
|
arrayBuffer(): ArrayBuffer;
|
|
blob(): Blob;
|
|
json(): any;
|
|
text(): string;
|
|
}
|
|
|
|
declare var PushMessageData: {
|
|
prototype: PushMessageData;
|
|
new(): PushMessageData;
|
|
};
|
|
|
|
interface PushSubscription {
|
|
readonly endpoint: string;
|
|
readonly expirationTime: number | null;
|
|
readonly options: PushSubscriptionOptions;
|
|
getKey(name: PushEncryptionKeyName): ArrayBuffer | null;
|
|
toJSON(): PushSubscriptionJSON;
|
|
unsubscribe(): Promise<boolean>;
|
|
}
|
|
|
|
declare var PushSubscription: {
|
|
prototype: PushSubscription;
|
|
new(): PushSubscription;
|
|
};
|
|
|
|
interface PushSubscriptionChangeEvent extends ExtendableEvent {
|
|
readonly newSubscription: PushSubscription | null;
|
|
readonly oldSubscription: PushSubscription | null;
|
|
}
|
|
|
|
declare var PushSubscriptionChangeEvent: {
|
|
prototype: PushSubscriptionChangeEvent;
|
|
new(type: string, eventInitDict?: PushSubscriptionChangeInit): PushSubscriptionChangeEvent;
|
|
};
|
|
|
|
interface PushSubscriptionOptions {
|
|
readonly applicationServerKey: ArrayBuffer | null;
|
|
readonly userVisibleOnly: boolean;
|
|
}
|
|
|
|
declare var PushSubscriptionOptions: {
|
|
prototype: PushSubscriptionOptions;
|
|
new(): PushSubscriptionOptions;
|
|
};
|
|
|
|
interface ReadableStream {
|
|
readonly locked: boolean;
|
|
cancel(): Promise<void>;
|
|
getReader(): ReadableStreamReader;
|
|
}
|
|
|
|
declare var ReadableStream: {
|
|
prototype: ReadableStream;
|
|
new(): ReadableStream;
|
|
};
|
|
|
|
interface ReadableStreamReader {
|
|
cancel(): Promise<void>;
|
|
read(): Promise<any>;
|
|
releaseLock(): void;
|
|
}
|
|
|
|
declare var ReadableStreamReader: {
|
|
prototype: ReadableStreamReader;
|
|
new(): ReadableStreamReader;
|
|
};
|
|
|
|
interface Request extends Body {
|
|
/**
|
|
* Returns the cache mode associated with request, which is a string indicating
|
|
* how the the request will interact with the browser's cache when fetching.
|
|
*/
|
|
readonly cache: RequestCache;
|
|
/**
|
|
* Returns the credentials mode associated with request, which is a string
|
|
* indicating whether credentials will be sent with the request always, never, or only when sent to a
|
|
* same-origin URL.
|
|
*/
|
|
readonly credentials: RequestCredentials;
|
|
/**
|
|
* Returns the kind of resource requested by request, e.g., "document" or
|
|
* "script".
|
|
*/
|
|
readonly destination: RequestDestination;
|
|
/**
|
|
* Returns a Headers object consisting of the headers associated with request.
|
|
* Note that headers added in the network layer by the user agent will not be accounted for in this
|
|
* object, e.g., the "Host" header.
|
|
*/
|
|
readonly headers: Headers;
|
|
/**
|
|
* Returns request's subresource integrity metadata, which is a cryptographic hash of
|
|
* the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI]
|
|
*/
|
|
readonly integrity: string;
|
|
/**
|
|
* Returns a boolean indicating whether or not request is for a history
|
|
* navigation (a.k.a. back-foward navigation).
|
|
*/
|
|
readonly isHistoryNavigation: boolean;
|
|
/**
|
|
* Returns a boolean indicating whether or not request is for a reload navigation.
|
|
*/
|
|
readonly isReloadNavigation: boolean;
|
|
/**
|
|
* Returns a boolean indicating whether or not request can outlive the global in which
|
|
* it was created.
|
|
*/
|
|
readonly keepalive: boolean;
|
|
/**
|
|
* Returns request's HTTP method, which is "GET" by default.
|
|
*/
|
|
readonly method: string;
|
|
/**
|
|
* Returns the mode associated with request, which is a string indicating
|
|
* whether the request will use CORS, or will be restricted to same-origin URLs.
|
|
*/
|
|
readonly mode: RequestMode;
|
|
/**
|
|
* Returns the redirect mode associated with request, which is a string
|
|
* indicating how redirects for the request will be handled during fetching. A request will follow redirects by default.
|
|
*/
|
|
readonly redirect: RequestRedirect;
|
|
/**
|
|
* Returns the referrer of request. Its value can be a same-origin URL if
|
|
* explicitly set in init, the empty string to indicate no referrer, and
|
|
* "about:client" when defaulting to the global's default. This is used during
|
|
* fetching to determine the value of the `Referer` header of the request being made.
|
|
*/
|
|
readonly referrer: string;
|
|
/**
|
|
* Returns the referrer policy associated with request. This is used during
|
|
* fetching to compute the value of the request's referrer.
|
|
*/
|
|
readonly referrerPolicy: ReferrerPolicy;
|
|
/**
|
|
* Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort
|
|
* event handler.
|
|
*/
|
|
readonly signal: AbortSignal;
|
|
/**
|
|
* Returns the URL of request as a string.
|
|
*/
|
|
readonly url: string;
|
|
clone(): Request;
|
|
}
|
|
|
|
declare var Request: {
|
|
prototype: Request;
|
|
new(input: RequestInfo, init?: RequestInit): Request;
|
|
};
|
|
|
|
interface Response extends Body {
|
|
readonly headers: Headers;
|
|
readonly ok: boolean;
|
|
readonly redirected: boolean;
|
|
readonly status: number;
|
|
readonly statusText: string;
|
|
readonly trailer: Promise<Headers>;
|
|
readonly type: ResponseType;
|
|
readonly url: string;
|
|
clone(): Response;
|
|
}
|
|
|
|
declare var Response: {
|
|
prototype: Response;
|
|
new(body?: BodyInit | null, init?: ResponseInit): Response;
|
|
error(): Response;
|
|
redirect(url: string, status?: number): Response;
|
|
};
|
|
|
|
interface ServiceWorkerEventMap extends AbstractWorkerEventMap {
|
|
"statechange": Event;
|
|
}
|
|
|
|
interface ServiceWorker extends EventTarget, AbstractWorker {
|
|
onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
|
|
readonly scriptURL: string;
|
|
readonly state: ServiceWorkerState;
|
|
postMessage(message: any, transfer?: Transferable[]): void;
|
|
addEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var ServiceWorker: {
|
|
prototype: ServiceWorker;
|
|
new(): ServiceWorker;
|
|
};
|
|
|
|
interface ServiceWorkerContainerEventMap {
|
|
"controllerchange": Event;
|
|
"message": MessageEvent;
|
|
"messageerror": MessageEvent;
|
|
}
|
|
|
|
interface ServiceWorkerContainer extends EventTarget {
|
|
readonly controller: ServiceWorker | null;
|
|
oncontrollerchange: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
|
|
onmessage: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
|
|
onmessageerror: ((this: ServiceWorkerContainer, ev: MessageEvent) => any) | null;
|
|
readonly ready: Promise<ServiceWorkerRegistration>;
|
|
getRegistration(clientURL?: string): Promise<ServiceWorkerRegistration | undefined>;
|
|
getRegistrations(): Promise<ReadonlyArray<ServiceWorkerRegistration>>;
|
|
register(scriptURL: string, options?: RegistrationOptions): Promise<ServiceWorkerRegistration>;
|
|
startMessages(): void;
|
|
addEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof ServiceWorkerContainerEventMap>(type: K, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var ServiceWorkerContainer: {
|
|
prototype: ServiceWorkerContainer;
|
|
new(): ServiceWorkerContainer;
|
|
};
|
|
|
|
interface ServiceWorkerGlobalScopeEventMap extends WorkerGlobalScopeEventMap {
|
|
"activate": ExtendableEvent;
|
|
"fetch": FetchEvent;
|
|
"install": ExtendableEvent;
|
|
"message": ExtendableMessageEvent;
|
|
"messageerror": MessageEvent;
|
|
"notificationclick": NotificationEvent;
|
|
"notificationclose": NotificationEvent;
|
|
"push": PushEvent;
|
|
"pushsubscriptionchange": PushSubscriptionChangeEvent;
|
|
"sync": SyncEvent;
|
|
}
|
|
|
|
interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
|
|
readonly clients: Clients;
|
|
onactivate: ((this: ServiceWorkerGlobalScope, ev: ExtendableEvent) => any) | null;
|
|
onfetch: ((this: ServiceWorkerGlobalScope, ev: FetchEvent) => any) | null;
|
|
oninstall: ((this: ServiceWorkerGlobalScope, ev: ExtendableEvent) => any) | null;
|
|
onmessage: ((this: ServiceWorkerGlobalScope, ev: ExtendableMessageEvent) => any) | null;
|
|
onmessageerror: ((this: ServiceWorkerGlobalScope, ev: MessageEvent) => any) | null;
|
|
onnotificationclick: ((this: ServiceWorkerGlobalScope, ev: NotificationEvent) => any) | null;
|
|
onnotificationclose: ((this: ServiceWorkerGlobalScope, ev: NotificationEvent) => any) | null;
|
|
onpush: ((this: ServiceWorkerGlobalScope, ev: PushEvent) => any) | null;
|
|
onpushsubscriptionchange: ((this: ServiceWorkerGlobalScope, ev: PushSubscriptionChangeEvent) => any) | null;
|
|
onsync: ((this: ServiceWorkerGlobalScope, ev: SyncEvent) => any) | null;
|
|
readonly registration: ServiceWorkerRegistration;
|
|
skipWaiting(): Promise<void>;
|
|
addEventListener<K extends keyof ServiceWorkerGlobalScopeEventMap>(type: K, listener: (this: ServiceWorkerGlobalScope, ev: ServiceWorkerGlobalScopeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof ServiceWorkerGlobalScopeEventMap>(type: K, listener: (this: ServiceWorkerGlobalScope, ev: ServiceWorkerGlobalScopeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var ServiceWorkerGlobalScope: {
|
|
prototype: ServiceWorkerGlobalScope;
|
|
new(): ServiceWorkerGlobalScope;
|
|
};
|
|
|
|
interface ServiceWorkerRegistrationEventMap {
|
|
"updatefound": Event;
|
|
}
|
|
|
|
interface ServiceWorkerRegistration extends EventTarget {
|
|
readonly active: ServiceWorker | null;
|
|
readonly installing: ServiceWorker | null;
|
|
readonly navigationPreload: NavigationPreloadManager;
|
|
onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
|
|
readonly pushManager: PushManager;
|
|
readonly scope: string;
|
|
readonly sync: SyncManager;
|
|
readonly updateViaCache: ServiceWorkerUpdateViaCache;
|
|
readonly waiting: ServiceWorker | null;
|
|
getNotifications(filter?: GetNotificationOptions): Promise<Notification[]>;
|
|
showNotification(title: string, options?: NotificationOptions): Promise<void>;
|
|
unregister(): Promise<boolean>;
|
|
update(): Promise<void>;
|
|
addEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var ServiceWorkerRegistration: {
|
|
prototype: ServiceWorkerRegistration;
|
|
new(): ServiceWorkerRegistration;
|
|
};
|
|
|
|
interface StorageManager {
|
|
estimate(): Promise<StorageEstimate>;
|
|
persisted(): Promise<boolean>;
|
|
}
|
|
|
|
declare var StorageManager: {
|
|
prototype: StorageManager;
|
|
new(): StorageManager;
|
|
};
|
|
|
|
interface SubtleCrypto {
|
|
decrypt(algorithm: string | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): PromiseLike<ArrayBuffer>;
|
|
deriveBits(algorithm: string | EcdhKeyDeriveParams | DhKeyDeriveParams | ConcatParams | HkdfCtrParams | Pbkdf2Params, baseKey: CryptoKey, length: number): PromiseLike<ArrayBuffer>;
|
|
deriveKey(algorithm: string | EcdhKeyDeriveParams | DhKeyDeriveParams | ConcatParams | HkdfCtrParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: string | AesDerivedKeyParams | HmacImportParams | ConcatParams | HkdfCtrParams | Pbkdf2Params, extractable: boolean, keyUsages: string[]): PromiseLike<CryptoKey>;
|
|
digest(algorithm: string | Algorithm, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): PromiseLike<ArrayBuffer>;
|
|
encrypt(algorithm: string | RsaOaepParams | AesCtrParams | AesCbcParams | AesCmacParams | AesGcmParams | AesCfbParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): PromiseLike<ArrayBuffer>;
|
|
exportKey(format: "jwk", key: CryptoKey): PromiseLike<JsonWebKey>;
|
|
exportKey(format: "raw" | "pkcs8" | "spki", key: CryptoKey): PromiseLike<ArrayBuffer>;
|
|
exportKey(format: string, key: CryptoKey): PromiseLike<JsonWebKey | ArrayBuffer>;
|
|
generateKey(algorithm: string, extractable: boolean, keyUsages: string[]): PromiseLike<CryptoKeyPair | CryptoKey>;
|
|
generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams | DhKeyGenParams, extractable: boolean, keyUsages: string[]): PromiseLike<CryptoKeyPair>;
|
|
generateKey(algorithm: AesKeyGenParams | HmacKeyGenParams | Pbkdf2Params, extractable: boolean, keyUsages: string[]): PromiseLike<CryptoKey>;
|
|
importKey(format: "jwk", keyData: JsonWebKey, algorithm: string | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: string[]): PromiseLike<CryptoKey>;
|
|
importKey(format: "raw" | "pkcs8" | "spki", keyData: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, algorithm: string | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: string[]): PromiseLike<CryptoKey>;
|
|
importKey(format: string, keyData: JsonWebKey | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, algorithm: string | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | DhImportKeyParams | AesKeyAlgorithm, extractable: boolean, keyUsages: string[]): PromiseLike<CryptoKey>;
|
|
sign(algorithm: string | RsaPssParams | EcdsaParams | AesCmacParams, key: CryptoKey, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): PromiseLike<ArrayBuffer>;
|
|
unwrapKey(format: string, wrappedKey: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, unwrappingKey: CryptoKey, unwrapAlgorithm: string | Algorithm, unwrappedKeyAlgorithm: string | Algorithm, extractable: boolean, keyUsages: string[]): PromiseLike<CryptoKey>;
|
|
verify(algorithm: string | RsaPssParams | EcdsaParams | AesCmacParams, key: CryptoKey, signature: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer, data: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer): PromiseLike<boolean>;
|
|
wrapKey(format: string, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: string | Algorithm): PromiseLike<ArrayBuffer>;
|
|
}
|
|
|
|
declare var SubtleCrypto: {
|
|
prototype: SubtleCrypto;
|
|
new(): SubtleCrypto;
|
|
};
|
|
|
|
interface SyncEvent extends ExtendableEvent {
|
|
readonly lastChance: boolean;
|
|
readonly tag: string;
|
|
}
|
|
|
|
declare var SyncEvent: {
|
|
prototype: SyncEvent;
|
|
new(type: string, init: SyncEventInit): SyncEvent;
|
|
};
|
|
|
|
interface SyncManager {
|
|
getTags(): Promise<string[]>;
|
|
register(tag: string): Promise<void>;
|
|
}
|
|
|
|
declare var SyncManager: {
|
|
prototype: SyncManager;
|
|
new(): SyncManager;
|
|
};
|
|
|
|
interface TextDecoder {
|
|
/**
|
|
* Returns encoding's name, lowercased.
|
|
*/
|
|
readonly encoding: string;
|
|
/**
|
|
* Returns true if error mode is "fatal", and false
|
|
* otherwise.
|
|
*/
|
|
readonly fatal: boolean;
|
|
/**
|
|
* Returns true if ignore BOM flag is set, and false otherwise.
|
|
*/
|
|
readonly ignoreBOM: boolean;
|
|
/**
|
|
* Returns the result of running encoding's decoder. The
|
|
* method can be invoked zero or more times with options's stream set to
|
|
* true, and then once without options's stream (or set to false), to process
|
|
* a fragmented stream. If the invocation without options's stream (or set to
|
|
* false) has no input, it's clearest to omit both arguments.
|
|
* var string = "", decoder = new TextDecoder(encoding), buffer;
|
|
* while(buffer = next_chunk()) {
|
|
* string += decoder.decode(buffer, {stream:true});
|
|
* }
|
|
* string += decoder.decode(); // end-of-stream
|
|
* If the error mode is "fatal" and encoding's decoder returns error, throws a TypeError.
|
|
*/
|
|
decode(input?: BufferSource, options?: TextDecodeOptions): string;
|
|
}
|
|
|
|
declare var TextDecoder: {
|
|
prototype: TextDecoder;
|
|
new(label?: string, options?: TextDecoderOptions): TextDecoder;
|
|
};
|
|
|
|
interface TextEncoder {
|
|
/**
|
|
* Returns "utf-8".
|
|
*/
|
|
readonly encoding: string;
|
|
/**
|
|
* Returns the result of running UTF-8's encoder.
|
|
*/
|
|
encode(input?: string): Uint8Array;
|
|
}
|
|
|
|
declare var TextEncoder: {
|
|
prototype: TextEncoder;
|
|
new(): TextEncoder;
|
|
};
|
|
|
|
interface URL {
|
|
hash: string;
|
|
host: string;
|
|
hostname: string;
|
|
href: string;
|
|
readonly origin: string;
|
|
password: string;
|
|
pathname: string;
|
|
port: string;
|
|
protocol: string;
|
|
search: string;
|
|
readonly searchParams: URLSearchParams;
|
|
username: string;
|
|
toJSON(): string;
|
|
}
|
|
|
|
declare var URL: {
|
|
prototype: URL;
|
|
new(url: string, base?: string | URL): URL;
|
|
createObjectURL(object: any): string;
|
|
revokeObjectURL(url: string): void;
|
|
};
|
|
|
|
interface URLSearchParams {
|
|
/**
|
|
* Appends a specified key/value pair as a new search parameter.
|
|
*/
|
|
append(name: string, value: string): void;
|
|
/**
|
|
* Deletes the given search parameter, and its associated value, from the list of all search parameters.
|
|
*/
|
|
delete(name: string): void;
|
|
/**
|
|
* Returns the first value associated to the given search parameter.
|
|
*/
|
|
get(name: string): string | null;
|
|
/**
|
|
* Returns all the values association with a given search parameter.
|
|
*/
|
|
getAll(name: string): string[];
|
|
/**
|
|
* Returns a Boolean indicating if such a search parameter exists.
|
|
*/
|
|
has(name: string): boolean;
|
|
/**
|
|
* Sets the value associated to a given search parameter to the given value. If there were several values, delete the others.
|
|
*/
|
|
set(name: string, value: string): void;
|
|
sort(): void;
|
|
forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
|
|
}
|
|
|
|
declare var URLSearchParams: {
|
|
prototype: URLSearchParams;
|
|
new(init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
|
|
};
|
|
|
|
interface WebSocketEventMap {
|
|
"close": CloseEvent;
|
|
"error": Event;
|
|
"message": MessageEvent;
|
|
"open": Event;
|
|
}
|
|
|
|
interface WebSocket extends EventTarget {
|
|
binaryType: BinaryType;
|
|
readonly bufferedAmount: number;
|
|
readonly extensions: string;
|
|
onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
|
|
onerror: ((this: WebSocket, ev: Event) => any) | null;
|
|
onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
|
|
onopen: ((this: WebSocket, ev: Event) => any) | null;
|
|
readonly protocol: string;
|
|
readonly readyState: number;
|
|
readonly url: string;
|
|
close(code?: number, reason?: string): void;
|
|
send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
|
|
readonly CLOSED: number;
|
|
readonly CLOSING: number;
|
|
readonly CONNECTING: number;
|
|
readonly OPEN: number;
|
|
addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var WebSocket: {
|
|
prototype: WebSocket;
|
|
new(url: string, protocols?: string | string[]): WebSocket;
|
|
readonly CLOSED: number;
|
|
readonly CLOSING: number;
|
|
readonly CONNECTING: number;
|
|
readonly OPEN: number;
|
|
};
|
|
|
|
interface WindowBase64 {
|
|
atob(encodedString: string): string;
|
|
btoa(rawString: string): string;
|
|
}
|
|
|
|
interface WindowClient extends Client {
|
|
readonly ancestorOrigins: ReadonlyArray<string>;
|
|
readonly focused: boolean;
|
|
readonly visibilityState: VisibilityState;
|
|
focus(): Promise<WindowClient>;
|
|
navigate(url: string): Promise<WindowClient | null>;
|
|
}
|
|
|
|
declare var WindowClient: {
|
|
prototype: WindowClient;
|
|
new(): WindowClient;
|
|
};
|
|
|
|
interface WindowConsole {
|
|
readonly console: Console;
|
|
}
|
|
|
|
interface WindowOrWorkerGlobalScope {
|
|
readonly caches: CacheStorage;
|
|
readonly crypto: Crypto;
|
|
readonly indexedDB: IDBFactory;
|
|
readonly origin: string;
|
|
readonly performance: Performance;
|
|
atob(data: string): string;
|
|
btoa(data: string): string;
|
|
clearInterval(handle?: number): void;
|
|
clearTimeout(handle?: number): void;
|
|
createImageBitmap(image: ImageBitmapSource): Promise<ImageBitmap>;
|
|
createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number): Promise<ImageBitmap>;
|
|
fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
|
|
queueMicrotask(callback: Function): void;
|
|
setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
|
|
setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
|
|
}
|
|
|
|
interface WorkerEventMap extends AbstractWorkerEventMap {
|
|
"message": MessageEvent;
|
|
}
|
|
|
|
interface Worker extends EventTarget, AbstractWorker {
|
|
onmessage: ((this: Worker, ev: MessageEvent) => any) | null;
|
|
postMessage(message: any, transfer?: Transferable[]): void;
|
|
terminate(): void;
|
|
addEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var Worker: {
|
|
prototype: Worker;
|
|
new(stringUrl: string): Worker;
|
|
};
|
|
|
|
interface WorkerGlobalScopeEventMap {
|
|
"error": ErrorEvent;
|
|
}
|
|
|
|
interface WorkerGlobalScope extends EventTarget, WorkerUtils, WindowConsole, GlobalFetch, WindowOrWorkerGlobalScope {
|
|
readonly caches: CacheStorage;
|
|
readonly isSecureContext: boolean;
|
|
readonly location: WorkerLocation;
|
|
onerror: ((this: WorkerGlobalScope, ev: ErrorEvent) => any) | null;
|
|
readonly performance: Performance;
|
|
readonly self: WorkerGlobalScope;
|
|
msWriteProfilerMark(profilerMarkName: string): void;
|
|
addEventListener<K extends keyof WorkerGlobalScopeEventMap>(type: K, listener: (this: WorkerGlobalScope, ev: WorkerGlobalScopeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof WorkerGlobalScopeEventMap>(type: K, listener: (this: WorkerGlobalScope, ev: WorkerGlobalScopeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var WorkerGlobalScope: {
|
|
prototype: WorkerGlobalScope;
|
|
new(): WorkerGlobalScope;
|
|
};
|
|
|
|
interface WorkerLocation {
|
|
readonly hash: string;
|
|
readonly host: string;
|
|
readonly hostname: string;
|
|
readonly href: string;
|
|
readonly origin: string;
|
|
readonly pathname: string;
|
|
readonly port: string;
|
|
readonly protocol: string;
|
|
readonly search: string;
|
|
toString(): string;
|
|
}
|
|
|
|
declare var WorkerLocation: {
|
|
prototype: WorkerLocation;
|
|
new(): WorkerLocation;
|
|
};
|
|
|
|
interface WorkerNavigator extends NavigatorID, NavigatorOnLine, NavigatorBeacon, NavigatorConcurrentHardware, NavigatorStorage {
|
|
readonly serviceWorker: ServiceWorkerContainer;
|
|
}
|
|
|
|
declare var WorkerNavigator: {
|
|
prototype: WorkerNavigator;
|
|
new(): WorkerNavigator;
|
|
};
|
|
|
|
interface WorkerUtils extends WindowBase64 {
|
|
readonly indexedDB: IDBFactory;
|
|
readonly msIndexedDB: IDBFactory;
|
|
readonly navigator: WorkerNavigator;
|
|
importScripts(...urls: string[]): void;
|
|
}
|
|
|
|
interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
|
|
"readystatechange": Event;
|
|
}
|
|
|
|
interface XMLHttpRequest extends XMLHttpRequestEventTarget {
|
|
onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
|
|
/**
|
|
* Returns client's state.
|
|
*/
|
|
readonly readyState: number;
|
|
/**
|
|
* Returns the response's body.
|
|
*/
|
|
readonly response: any;
|
|
/**
|
|
* Returns the text response.
|
|
* Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
|
|
*/
|
|
readonly responseText: string;
|
|
/**
|
|
* Returns the response type.
|
|
* Can be set to change the response type. Values are:
|
|
* the empty string (default),
|
|
* "arraybuffer",
|
|
* "blob",
|
|
* "document",
|
|
* "json", and
|
|
* "text".
|
|
* When set: setting to "document" is ignored if current global object is not a Window object.
|
|
* When set: throws an "InvalidStateError" DOMException if state is loading or done.
|
|
* When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
|
|
*/
|
|
responseType: XMLHttpRequestResponseType;
|
|
readonly responseURL: string;
|
|
readonly status: number;
|
|
readonly statusText: string;
|
|
/**
|
|
* Can be set to a time in milliseconds. When set to a non-zero value will cause fetching to terminate after the given time has passed. When the time has passed, the
|
|
* request has not yet completed, and the synchronous flag is unset, a timeout event will then be dispatched, or a
|
|
* "TimeoutError" DOMException will be thrown otherwise (for the send() method).
|
|
* When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
|
|
*/
|
|
timeout: number;
|
|
/**
|
|
* Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is
|
|
* transferred to a server.
|
|
*/
|
|
readonly upload: XMLHttpRequestUpload;
|
|
/**
|
|
* True when credentials are to be included in a cross-origin request. False when they are
|
|
* to be excluded in a cross-origin request and when cookies are to be ignored in its response.
|
|
* Initially false.
|
|
* When set: throws an "InvalidStateError" DOMException if state is not unsent or opened, or if the send() flag is set.
|
|
*/
|
|
withCredentials: boolean;
|
|
/**
|
|
* Cancels any network activity.
|
|
*/
|
|
abort(): void;
|
|
getAllResponseHeaders(): string;
|
|
getResponseHeader(name: string): string | null;
|
|
/**
|
|
* Sets the request method, request URL, and synchronous flag.
|
|
* Throws a "SyntaxError" DOMException if either method is not a
|
|
* valid HTTP method or url cannot be parsed.
|
|
* Throws a "SecurityError" DOMException if method is a
|
|
* case-insensitive match for `CONNECT`, `TRACE`, or `TRACK`.
|
|
* Throws an "InvalidAccessError" DOMException if async is false, current global object is a Window object, and the timeout attribute is not zero or the responseType attribute is not the empty string.
|
|
*/
|
|
open(method: string, url: string): void;
|
|
open(method: string, url: string, async: boolean, username?: string | null, password?: string | null): void;
|
|
/**
|
|
* Acts as if the `Content-Type` header value for response is mime.
|
|
* (It does not actually change the header though.)
|
|
* Throws an "InvalidStateError" DOMException if state is loading or done.
|
|
*/
|
|
overrideMimeType(mime: string): void;
|
|
/**
|
|
* Initiates the request. The optional argument provides the request body. The argument is ignored if request method is GET or HEAD.
|
|
* Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
|
|
*/
|
|
send(body?: BodyInit | null): void;
|
|
/**
|
|
* Combines a header in author request headers.
|
|
* Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
|
|
* Throws a "SyntaxError" DOMException if name is not a header name
|
|
* or if value is not a header value.
|
|
*/
|
|
setRequestHeader(name: string, value: string): void;
|
|
readonly DONE: number;
|
|
readonly HEADERS_RECEIVED: number;
|
|
readonly LOADING: number;
|
|
readonly OPENED: number;
|
|
readonly UNSENT: number;
|
|
addEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var XMLHttpRequest: {
|
|
prototype: XMLHttpRequest;
|
|
new(): XMLHttpRequest;
|
|
readonly DONE: number;
|
|
readonly HEADERS_RECEIVED: number;
|
|
readonly LOADING: number;
|
|
readonly OPENED: number;
|
|
readonly UNSENT: number;
|
|
};
|
|
|
|
interface XMLHttpRequestEventTargetEventMap {
|
|
"abort": ProgressEvent;
|
|
"error": ProgressEvent;
|
|
"load": ProgressEvent;
|
|
"loadend": ProgressEvent;
|
|
"loadstart": ProgressEvent;
|
|
"progress": ProgressEvent;
|
|
"timeout": ProgressEvent;
|
|
}
|
|
|
|
interface XMLHttpRequestEventTarget extends EventTarget {
|
|
onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
|
onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
|
onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
|
onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
|
onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
|
onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
|
ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
|
addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var XMLHttpRequestEventTarget: {
|
|
prototype: XMLHttpRequestEventTarget;
|
|
new(): XMLHttpRequestEventTarget;
|
|
};
|
|
|
|
interface XMLHttpRequestUpload extends XMLHttpRequestEventTarget {
|
|
addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
}
|
|
|
|
declare var XMLHttpRequestUpload: {
|
|
prototype: XMLHttpRequestUpload;
|
|
new(): XMLHttpRequestUpload;
|
|
};
|
|
|
|
declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
|
|
|
|
interface EventHandlerNonNull {
|
|
(event: Event): any;
|
|
}
|
|
|
|
interface PerformanceObserverCallback {
|
|
(entries: PerformanceObserverEntryList, observer: PerformanceObserver): void;
|
|
}
|
|
|
|
declare var onmessage: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null;
|
|
declare function close(): void;
|
|
declare function postMessage(message: any, transfer?: Transferable[]): void;
|
|
/**
|
|
* Dispatches a synthetic event event to target and returns true
|
|
* if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.
|
|
*/
|
|
declare function dispatchEvent(event: Event): boolean;
|
|
declare var caches: CacheStorage;
|
|
declare var isSecureContext: boolean;
|
|
declare var location: WorkerLocation;
|
|
declare var onerror: ((this: DedicatedWorkerGlobalScope, ev: ErrorEvent) => any) | null;
|
|
declare var performance: Performance;
|
|
declare var self: WorkerGlobalScope;
|
|
declare function msWriteProfilerMark(profilerMarkName: string): void;
|
|
/**
|
|
* Dispatches a synthetic event event to target and returns true
|
|
* if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.
|
|
*/
|
|
declare function dispatchEvent(event: Event): boolean;
|
|
declare var indexedDB: IDBFactory;
|
|
declare var msIndexedDB: IDBFactory;
|
|
declare var navigator: WorkerNavigator;
|
|
declare function importScripts(...urls: string[]): void;
|
|
declare function atob(encodedString: string): string;
|
|
declare function btoa(rawString: string): string;
|
|
declare var console: Console;
|
|
declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
|
|
declare var caches: CacheStorage;
|
|
declare var crypto: Crypto;
|
|
declare var indexedDB: IDBFactory;
|
|
declare var origin: string;
|
|
declare var performance: Performance;
|
|
declare function atob(data: string): string;
|
|
declare function btoa(data: string): string;
|
|
declare function clearInterval(handle?: number): void;
|
|
declare function clearTimeout(handle?: number): void;
|
|
declare function createImageBitmap(image: ImageBitmapSource): Promise<ImageBitmap>;
|
|
declare function createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number): Promise<ImageBitmap>;
|
|
declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
|
|
declare function queueMicrotask(callback: Function): void;
|
|
declare function setInterval(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
|
|
declare function setTimeout(handler: TimerHandler, timeout?: number, ...arguments: any[]): number;
|
|
declare function addEventListener<K extends keyof DedicatedWorkerGlobalScopeEventMap>(type: K, listener: (this: DedicatedWorkerGlobalScope, ev: DedicatedWorkerGlobalScopeEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
|
|
declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
|
declare function removeEventListener<K extends keyof DedicatedWorkerGlobalScopeEventMap>(type: K, listener: (this: DedicatedWorkerGlobalScope, ev: DedicatedWorkerGlobalScopeEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
|
|
declare function removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
|
type BlobPart = BufferSource | Blob | string;
|
|
type HeadersInit = Headers | string[][] | Record<string, string>;
|
|
type BodyInit = Blob | BufferSource | FormData | URLSearchParams | ReadableStream | string;
|
|
type RequestInfo = Request | string;
|
|
type DOMHighResTimeStamp = number;
|
|
type CanvasImageSource = ImageBitmap;
|
|
type MessageEventSource = MessagePort | ServiceWorker;
|
|
type ImageBitmapSource = CanvasImageSource | Blob | ImageData;
|
|
type TimerHandler = string | Function;
|
|
type PerformanceEntryList = PerformanceEntry[];
|
|
type PushMessageDataInit = BufferSource | string;
|
|
type VibratePattern = number | number[];
|
|
type AlgorithmIdentifier = string | Algorithm;
|
|
type HashAlgorithmIdentifier = AlgorithmIdentifier;
|
|
type BigInteger = Uint8Array;
|
|
type NamedCurve = string;
|
|
type BufferSource = ArrayBufferView | ArrayBuffer;
|
|
type DOMTimeStamp = number;
|
|
type FormDataEntryValue = File | string;
|
|
type IDBValidKey = number | string | Date | BufferSource | IDBArrayKey;
|
|
type Transferable = ArrayBuffer | MessagePort | ImageBitmap;
|
|
type BinaryType = "blob" | "arraybuffer";
|
|
type ClientTypes = "window" | "worker" | "sharedworker" | "all";
|
|
type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique";
|
|
type IDBRequestReadyState = "pending" | "done";
|
|
type IDBTransactionMode = "readonly" | "readwrite" | "versionchange";
|
|
type KeyFormat = "raw" | "spki" | "pkcs8" | "jwk";
|
|
type KeyType = "public" | "private" | "secret";
|
|
type KeyUsage = "encrypt" | "decrypt" | "sign" | "verify" | "deriveKey" | "deriveBits" | "wrapKey" | "unwrapKey";
|
|
type NotificationDirection = "auto" | "ltr" | "rtl";
|
|
type NotificationPermission = "default" | "denied" | "granted";
|
|
type PushEncryptionKeyName = "p256dh" | "auth";
|
|
type PushPermissionState = "denied" | "granted" | "prompt";
|
|
type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin-only" | "origin-when-cross-origin" | "unsafe-url";
|
|
type RequestCache = "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached";
|
|
type RequestCredentials = "omit" | "same-origin" | "include";
|
|
type RequestDestination = "" | "audio" | "audioworklet" | "document" | "embed" | "font" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt";
|
|
type RequestMode = "navigate" | "same-origin" | "no-cors" | "cors";
|
|
type RequestRedirect = "follow" | "error" | "manual";
|
|
type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
|
|
type ServiceWorkerState = "installing" | "installed" | "activating" | "activated" | "redundant";
|
|
type ServiceWorkerUpdateViaCache = "imports" | "all" | "none";
|
|
type VisibilityState = "hidden" | "visible" | "prerender";
|
|
type WorkerType = "classic" | "module";
|
|
type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text";
|