2625 lines
93 KiB
TypeScript
2625 lines
93 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 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 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 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;
|
|
}
|
|
|
|
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 IDBIndexParameters {
|
|
multiEntry?: boolean;
|
|
unique?: boolean;
|
|
}
|
|
|
|
interface IDBObjectStoreParameters {
|
|
autoIncrement?: boolean;
|
|
keyPath?: string | string[];
|
|
}
|
|
|
|
interface IDBVersionChangeEventInit extends EventInit {
|
|
newVersion?: number | null;
|
|
oldVersion?: number;
|
|
}
|
|
|
|
interface KeyAlgorithm {
|
|
name: string;
|
|
}
|
|
|
|
interface MessageEventInit extends EventInit {
|
|
channel?: string;
|
|
data?: any;
|
|
lastEventId?: string;
|
|
origin?: string;
|
|
ports?: MessagePort[];
|
|
source?: object | 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 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;
|
|
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?: object | null;
|
|
window?: any;
|
|
}
|
|
|
|
interface ResponseInit {
|
|
headers?: HeadersInit;
|
|
status?: number;
|
|
statusText?: string;
|
|
}
|
|
|
|
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 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 Client {
|
|
readonly id: string;
|
|
readonly type: ClientTypes;
|
|
readonly url: string;
|
|
postMessage(message: any, transfer?: any[]): 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;
|
|
msIsIndependentlyComposed(element: object): boolean;
|
|
profile(reportName?: string): void;
|
|
profileEnd(): void;
|
|
select(element: object): 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 CryptoKey {
|
|
readonly algorithm: KeyAlgorithm;
|
|
readonly extractable: boolean;
|
|
readonly type: string;
|
|
readonly usages: string[];
|
|
}
|
|
|
|
declare var CryptoKey: {
|
|
prototype: CryptoKey;
|
|
new(): CryptoKey;
|
|
};
|
|
|
|
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?: any[]): 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;
|
|
initErrorEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, messageArg: string, filenameArg: string, linenoArg: number): void;
|
|
}
|
|
|
|
declare var ErrorEvent: {
|
|
prototype: ErrorEvent;
|
|
new(typeArg: string, eventInitDict?: ErrorEventInit): ErrorEvent;
|
|
};
|
|
|
|
interface Event {
|
|
readonly bubbles: boolean;
|
|
cancelBubble: boolean;
|
|
readonly cancelable: boolean;
|
|
readonly composed: boolean;
|
|
readonly currentTarget: EventTarget | null;
|
|
readonly defaultPrevented: boolean;
|
|
readonly eventPhase: number;
|
|
readonly isTrusted: boolean;
|
|
returnValue: boolean;
|
|
readonly srcElement: object | null;
|
|
readonly target: EventTarget | null;
|
|
readonly timeStamp: number;
|
|
readonly type: string;
|
|
deepPath(): EventTarget[];
|
|
initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
|
|
preventDefault(): void;
|
|
stopImmediatePropagation(): void;
|
|
stopPropagation(): void;
|
|
readonly AT_TARGET: number;
|
|
readonly BUBBLING_PHASE: number;
|
|
readonly CAPTURING_PHASE: number;
|
|
readonly NONE: number;
|
|
}
|
|
|
|
declare var Event: {
|
|
prototype: Event;
|
|
new(typeArg: 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 {
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
|
|
dispatchEvent(evt: Event): boolean;
|
|
removeEventListener(type: string, listener?: 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(form?: object): FormData;
|
|
};
|
|
|
|
interface GlobalFetch {
|
|
fetch(input?: Request | string, 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;
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
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;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
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;
|
|
/**
|
|
* Deletes all records in store.
|
|
* If successful, request's result will
|
|
* be undefined.
|
|
*/
|
|
clear(): IDBRequest;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* 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;
|
|
/**
|
|
* 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;
|
|
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;
|
|
/**
|
|
* 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;
|
|
put(value: any, key?: IDBValidKey | IDBKeyRange): IDBRequest;
|
|
}
|
|
|
|
declare var IDBObjectStore: {
|
|
prototype: IDBObjectStore;
|
|
new(): IDBObjectStore;
|
|
};
|
|
|
|
interface IDBOpenDBRequestEventMap extends IDBRequestEventMap {
|
|
"blocked": Event;
|
|
"upgradeneeded": IDBVersionChangeEvent;
|
|
}
|
|
|
|
interface IDBOpenDBRequest extends IDBRequest {
|
|
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 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, ev: Event) => any) | null;
|
|
onsuccess: ((this: IDBRequest, 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: any;
|
|
/**
|
|
* 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, 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, 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 {
|
|
readonly height: number;
|
|
readonly width: number;
|
|
close(): void;
|
|
}
|
|
|
|
interface ImageBitmapOptions {
|
|
colorSpaceConversion?: "none" | "default";
|
|
imageOrientation?: "none" | "flipY";
|
|
premultiplyAlpha?: "none" | "premultiply" | "default";
|
|
resizeHeight?: number;
|
|
resizeQuality?: "pixelated" | "low" | "medium" | "high";
|
|
resizeWidth?: number;
|
|
}
|
|
|
|
interface ImageData {
|
|
}
|
|
|
|
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 {
|
|
readonly data: any;
|
|
readonly origin: string;
|
|
readonly ports: ReadonlyArray<MessagePort>;
|
|
readonly source: MessageEventSource;
|
|
initMessageEvent(type: string, bubbles: boolean, cancelable: boolean, data: any, origin: string, lastEventId: string, source: object): void;
|
|
}
|
|
|
|
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?: any[]): 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 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: PromiseLike<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: object;
|
|
/**
|
|
* 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?: any[]): 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 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 WorkerEventMap extends AbstractWorkerEventMap {
|
|
"message": MessageEvent;
|
|
}
|
|
|
|
interface Worker extends EventTarget, AbstractWorker {
|
|
onmessage: ((this: Worker, ev: MessageEvent) => any) | null;
|
|
postMessage(message: any, transfer?: any[]): 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 {
|
|
readonly caches: CacheStorage;
|
|
readonly isSecureContext: boolean;
|
|
readonly location: WorkerLocation;
|
|
onerror: ((this: WorkerGlobalScope, ev: ErrorEvent) => any) | null;
|
|
readonly performance: Performance;
|
|
readonly self: WorkerGlobalScope;
|
|
createImageBitmap(image: ImageBitmap | ImageData | Blob, options?: ImageBitmapOptions): Promise<ImageBitmap>;
|
|
createImageBitmap(image: ImageBitmap | ImageData | Blob, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
|
|
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;
|
|
clearImmediate(handle: number): void;
|
|
clearInterval(handle: number): void;
|
|
clearTimeout(handle: number): void;
|
|
importScripts(...urls: string[]): void;
|
|
setImmediate(handler: any, ...args: any[]): number;
|
|
setInterval(handler: any, timeout?: any, ...args: any[]): number;
|
|
setTimeout(handler: any, timeout?: any, ...args: any[]): number;
|
|
}
|
|
|
|
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?: object | BodyInit): 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?: any[]): void;
|
|
declare function dispatchEvent(evt: 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 createImageBitmap(image: ImageBitmap | ImageData | Blob, options?: ImageBitmapOptions): Promise<ImageBitmap>;
|
|
declare function createImageBitmap(image: ImageBitmap | ImageData | Blob, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise<ImageBitmap>;
|
|
declare function msWriteProfilerMark(profilerMarkName: string): void;
|
|
declare function dispatchEvent(evt: Event): boolean;
|
|
declare var indexedDB: IDBFactory;
|
|
declare var msIndexedDB: IDBFactory;
|
|
declare var navigator: WorkerNavigator;
|
|
declare function clearImmediate(handle: number): void;
|
|
declare function clearInterval(handle: number): void;
|
|
declare function clearTimeout(handle: number): void;
|
|
declare function setImmediate(handler: any, ...args: any[]): number;
|
|
declare function setInterval(handler: any, timeout?: any, ...args: any[]): number;
|
|
declare function setTimeout(handler: any, timeout?: any, ...args: any[]): number;
|
|
declare function atob(encodedString: string): string;
|
|
declare function btoa(rawString: string): string;
|
|
declare var console: Console;
|
|
declare function fetch(input?: Request | string, init?: RequestInit): Promise<Response>;
|
|
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 PerformanceEntryList = PerformanceEntry[];
|
|
type PushMessageDataInit = BufferSource | string;
|
|
type VibratePattern = number | number[];
|
|
type BufferSource = ArrayBufferView | ArrayBuffer;
|
|
type DOMTimeStamp = number;
|
|
type FormDataEntryValue = File | string;
|
|
type IDBValidKey = number | string | Date | BufferSource | IDBArrayKey;
|
|
type MessageEventSource = object | MessagePort | ServiceWorker;
|
|
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 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" | "unloaded";
|
|
type WorkerType = "classic" | "module";
|
|
type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text"; |