1793 lines
64 KiB
TypeScript
1793 lines
64 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 CacheQueryOptions {
|
|
cacheName?: string;
|
|
ignoreMethod?: boolean;
|
|
ignoreSearch?: boolean;
|
|
ignoreVary?: boolean;
|
|
}
|
|
|
|
interface ClientQueryOptions {
|
|
includeReserved?: boolean;
|
|
includeUncontrolled?: boolean;
|
|
type?: ClientTypes;
|
|
}
|
|
|
|
interface CloseEventInit extends EventInit {
|
|
code?: number;
|
|
reason?: string;
|
|
wasClean?: boolean;
|
|
}
|
|
|
|
interface ErrorEventInit extends EventInit {
|
|
colno?: number;
|
|
error?: any;
|
|
filename?: string;
|
|
lineno?: number;
|
|
message?: string;
|
|
}
|
|
|
|
interface EventInit {
|
|
bubbles?: boolean;
|
|
cancelable?: boolean;
|
|
scoped?: boolean;
|
|
}
|
|
|
|
interface EventListenerOptions {
|
|
capture?: boolean;
|
|
}
|
|
|
|
interface ExtendableEventInit extends EventInit {
|
|
}
|
|
|
|
interface ExtendableMessageEventInit extends ExtendableEventInit {
|
|
data?: any;
|
|
lastEventId?: string;
|
|
origin?: string;
|
|
ports?: MessagePort[] | null;
|
|
source?: Client | ServiceWorker | MessagePort | null;
|
|
}
|
|
|
|
interface FetchEventInit extends ExtendableEventInit {
|
|
clientId?: string;
|
|
request: Request;
|
|
reservedClientId?: string;
|
|
targetClientId?: string;
|
|
}
|
|
|
|
interface GetNotificationOptions {
|
|
tag?: string;
|
|
}
|
|
|
|
interface IDBIndexParameters {
|
|
multiEntry?: boolean;
|
|
unique?: boolean;
|
|
}
|
|
|
|
interface IDBObjectStoreParameters {
|
|
autoIncrement?: boolean;
|
|
keyPath?: string | string[];
|
|
}
|
|
|
|
interface KeyAlgorithm {
|
|
name: string;
|
|
}
|
|
|
|
interface MessageEventInit extends EventInit {
|
|
channel?: string;
|
|
data?: any;
|
|
lastEventId?: string;
|
|
origin?: string;
|
|
ports?: MessagePort[];
|
|
source?: object | null;
|
|
}
|
|
|
|
interface NotificationEventInit extends ExtendableEventInit {
|
|
action?: string;
|
|
notification: Notification;
|
|
}
|
|
|
|
interface NotificationOptions {
|
|
body?: string;
|
|
data?: any;
|
|
dir?: NotificationDirection;
|
|
icon?: string;
|
|
lang?: string;
|
|
tag?: string;
|
|
}
|
|
|
|
interface ObjectURLOptions {
|
|
oneTimeOnly?: boolean;
|
|
}
|
|
|
|
interface ProgressEventInit extends EventInit {
|
|
lengthComputable?: boolean;
|
|
loaded?: number;
|
|
total?: number;
|
|
}
|
|
|
|
interface PushEventInit extends ExtendableEventInit {
|
|
data?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | string | null;
|
|
}
|
|
|
|
interface PushSubscriptionChangeInit extends ExtendableEventInit {
|
|
newSubscription?: PushSubscription;
|
|
oldSubscription?: PushSubscription;
|
|
}
|
|
|
|
interface PushSubscriptionOptionsInit {
|
|
applicationServerKey?: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | string | null;
|
|
userVisibleOnly?: boolean;
|
|
}
|
|
|
|
interface RequestInit {
|
|
body?: Blob | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | FormData | string | null;
|
|
cache?: RequestCache;
|
|
credentials?: RequestCredentials;
|
|
headers?: HeadersInit;
|
|
integrity?: string;
|
|
keepalive?: boolean;
|
|
method?: string;
|
|
mode?: RequestMode;
|
|
redirect?: RequestRedirect;
|
|
referrer?: string;
|
|
referrerPolicy?: ReferrerPolicy;
|
|
signal?: object;
|
|
window?: any;
|
|
}
|
|
|
|
interface ResponseInit {
|
|
headers?: HeadersInit;
|
|
status?: number;
|
|
statusText?: string;
|
|
}
|
|
|
|
interface SyncEventInit extends ExtendableEventInit {
|
|
lastChance?: boolean;
|
|
tag: string;
|
|
}
|
|
|
|
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 AudioBuffer {
|
|
readonly duration: number;
|
|
readonly length: number;
|
|
readonly numberOfChannels: number;
|
|
readonly sampleRate: number;
|
|
copyFromChannel(destination: Float32Array, channelNumber: number, startInChannel?: number): void;
|
|
copyToChannel(source: Float32Array, channelNumber: number, startInChannel?: number): void;
|
|
getChannelData(channel: number): Float32Array;
|
|
}
|
|
|
|
declare var AudioBuffer: {
|
|
prototype: AudioBuffer;
|
|
new(): AudioBuffer;
|
|
};
|
|
|
|
interface Blob {
|
|
readonly size: number;
|
|
readonly type: string;
|
|
msClose(): void;
|
|
msDetachStream(): any;
|
|
slice(start?: number, end?: number, contentType?: string): Blob;
|
|
}
|
|
|
|
declare var Blob: {
|
|
prototype: Blob;
|
|
new (blobParts?: any[], options?: BlobPropertyBag): Blob;
|
|
};
|
|
|
|
interface BlobPropertyBag {
|
|
endings?: string;
|
|
type?: string;
|
|
}
|
|
|
|
interface Body {
|
|
readonly bodyUsed: boolean;
|
|
arrayBuffer(): Promise<ArrayBuffer>;
|
|
blob(): Promise<Blob>;
|
|
formData(): Promise<FormData>;
|
|
json(): Promise<any>;
|
|
text(): Promise<string>;
|
|
}
|
|
|
|
interface Cache {
|
|
add(request: Request | string): Promise<void>;
|
|
addAll(requests: (Request | string)[]): Promise<void>;
|
|
delete(request: Request | string, options?: CacheQueryOptions): Promise<boolean>;
|
|
keys(request?: Request | string, options?: CacheQueryOptions): Promise<Request[]>;
|
|
match(request: Request | string, options?: CacheQueryOptions): Promise<Response>;
|
|
matchAll(request?: Request | string, options?: CacheQueryOptions): Promise<Response[]>;
|
|
put(request: Request | string, 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: Request | string, options?: CacheQueryOptions): Promise<any>;
|
|
open(cacheName: string): Promise<Cache>;
|
|
}
|
|
|
|
declare var CacheStorage: {
|
|
prototype: CacheStorage;
|
|
new(): CacheStorage;
|
|
};
|
|
|
|
interface Client {
|
|
readonly id: string;
|
|
readonly reserved: boolean;
|
|
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<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 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 Coordinates {
|
|
readonly accuracy: number;
|
|
readonly altitude: number | null;
|
|
readonly altitudeAccuracy: number | null;
|
|
readonly heading: number | null;
|
|
readonly latitude: number;
|
|
readonly longitude: number;
|
|
readonly speed: number | null;
|
|
}
|
|
|
|
declare var Coordinates: {
|
|
prototype: Coordinates;
|
|
new(): Coordinates;
|
|
};
|
|
|
|
interface CryptoKey {
|
|
readonly algorithm: KeyAlgorithm;
|
|
readonly extractable: boolean;
|
|
readonly type: string;
|
|
readonly usages: string[];
|
|
}
|
|
|
|
declare var CryptoKey: {
|
|
prototype: CryptoKey;
|
|
new(): CryptoKey;
|
|
};
|
|
|
|
interface DOMError {
|
|
readonly name: string;
|
|
toString(): string;
|
|
}
|
|
|
|
declare var DOMError: {
|
|
prototype: DOMError;
|
|
new(): DOMError;
|
|
};
|
|
|
|
interface DOMException {
|
|
readonly code: number;
|
|
readonly message: string;
|
|
readonly name: string;
|
|
toString(): 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 PARSE_ERR: number;
|
|
readonly QUOTA_EXCEEDED_ERR: number;
|
|
readonly SECURITY_ERR: number;
|
|
readonly SERIALIZE_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 PARSE_ERR: number;
|
|
readonly QUOTA_EXCEEDED_ERR: number;
|
|
readonly SECURITY_ERR: number;
|
|
readonly SERIALIZE_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 DOMStringList {
|
|
readonly length: number;
|
|
contains(str: string): boolean;
|
|
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 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 currentTarget: EventTarget | null;
|
|
readonly defaultPrevented: boolean;
|
|
readonly eventPhase: number;
|
|
readonly isTrusted: boolean;
|
|
returnValue: boolean;
|
|
readonly scoped: 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 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> | null;
|
|
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 request: Request;
|
|
readonly reservedClientId: 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;
|
|
/** @deprecated */
|
|
readonly lastModifiedDate: Date;
|
|
readonly name: string;
|
|
readonly webkitRelativePath: string;
|
|
}
|
|
|
|
declare var File: {
|
|
prototype: File;
|
|
new (parts: (ArrayBuffer | ArrayBufferView | Blob | string)[], filename: string, properties?: FilePropertyBag): File;
|
|
};
|
|
|
|
interface FileList {
|
|
readonly length: number;
|
|
item(index: number): File | null;
|
|
[index: number]: File;
|
|
}
|
|
|
|
declare var FileList: {
|
|
prototype: FileList;
|
|
new(): FileList;
|
|
};
|
|
|
|
interface FilePropertyBag extends BlobPropertyBag {
|
|
lastModified?: number;
|
|
}
|
|
|
|
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: FileReaderProgressEvent) => any) | null;
|
|
onerror: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
|
|
onload: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
|
|
onloadend: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
|
|
onloadstart: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
|
|
onprogress: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
|
|
readonly readyState: number;
|
|
readonly result: any;
|
|
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 FileReaderProgressEvent extends ProgressEvent {
|
|
readonly target: FileReader | null;
|
|
}
|
|
|
|
interface FileReaderSync {
|
|
readAsArrayBuffer(blob: Blob): any;
|
|
readAsBinaryString(blob: Blob): void;
|
|
readAsDataURL(blob: Blob): string;
|
|
readAsText(blob: Blob, encoding?: 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;
|
|
}
|
|
|
|
declare var FormData: {
|
|
prototype: FormData;
|
|
new(): 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;
|
|
forEach(callback: Function, thisArg?: any): void;
|
|
get(name: string): string | null;
|
|
has(name: string): boolean;
|
|
set(name: string, value: string): void;
|
|
}
|
|
|
|
declare var Headers: {
|
|
prototype: Headers;
|
|
new(init?: HeadersInit): Headers;
|
|
};
|
|
|
|
interface IDBArrayKey extends Array<number | string | Date | IDBArrayKey> {
|
|
}
|
|
|
|
interface IDBCursor {
|
|
readonly direction: IDBCursorDirection;
|
|
readonly key: IDBKeyRange | number | string | Date | IDBArrayKey;
|
|
readonly primaryKey: any;
|
|
readonly source: IDBObjectStore | IDBIndex;
|
|
advance(count: number): void;
|
|
continue(key?: IDBKeyRange | number | string | Date | IDBArrayKey): void;
|
|
delete(): IDBRequest;
|
|
update(value: any): IDBRequest;
|
|
readonly NEXT: string;
|
|
readonly NEXT_NO_DUPLICATE: string;
|
|
readonly PREV: string;
|
|
readonly PREV_NO_DUPLICATE: string;
|
|
}
|
|
|
|
declare var IDBCursor: {
|
|
prototype: IDBCursor;
|
|
new(): IDBCursor;
|
|
readonly NEXT: string;
|
|
readonly NEXT_NO_DUPLICATE: string;
|
|
readonly PREV: string;
|
|
readonly PREV_NO_DUPLICATE: string;
|
|
};
|
|
|
|
interface IDBCursorWithValue extends IDBCursor {
|
|
readonly value: any;
|
|
}
|
|
|
|
declare var IDBCursorWithValue: {
|
|
prototype: IDBCursorWithValue;
|
|
new(): IDBCursorWithValue;
|
|
};
|
|
|
|
interface IDBDatabaseEventMap {
|
|
"abort": Event;
|
|
"error": Event;
|
|
}
|
|
|
|
interface IDBDatabase extends EventTarget {
|
|
readonly name: string;
|
|
readonly objectStoreNames: DOMStringList;
|
|
onabort: ((this: IDBDatabase, ev: Event) => any) | null;
|
|
onerror: ((this: IDBDatabase, ev: Event) => any) | null;
|
|
onversionchange: ((this: IDBDatabase, ev: Event) => any) | null;
|
|
readonly version: number;
|
|
close(): void;
|
|
createObjectStore(name: string, optionalParameters?: IDBObjectStoreParameters): IDBObjectStore;
|
|
deleteObjectStore(name: string): void;
|
|
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 {
|
|
cmp(first: any, second: any): number;
|
|
deleteDatabase(name: string): IDBOpenDBRequest;
|
|
open(name: string, version?: number): IDBOpenDBRequest;
|
|
}
|
|
|
|
declare var IDBFactory: {
|
|
prototype: IDBFactory;
|
|
new(): IDBFactory;
|
|
};
|
|
|
|
interface IDBIndex {
|
|
readonly keyPath: string | string[];
|
|
multiEntry: boolean;
|
|
readonly name: string;
|
|
readonly objectStore: IDBObjectStore;
|
|
readonly unique: boolean;
|
|
count(key?: IDBKeyRange | number | string | Date | IDBArrayKey): IDBRequest;
|
|
get(key: IDBKeyRange | number | string | Date | IDBArrayKey): IDBRequest;
|
|
getKey(key: IDBKeyRange | number | string | Date | IDBArrayKey): IDBRequest;
|
|
openCursor(range?: IDBKeyRange | number | string | Date | IDBArrayKey, direction?: IDBCursorDirection): IDBRequest;
|
|
openKeyCursor(range?: IDBKeyRange | number | string | Date | IDBArrayKey, direction?: IDBCursorDirection): IDBRequest;
|
|
}
|
|
|
|
declare var IDBIndex: {
|
|
prototype: IDBIndex;
|
|
new(): IDBIndex;
|
|
};
|
|
|
|
interface IDBKeyRange {
|
|
readonly lower: any;
|
|
readonly lowerOpen: boolean;
|
|
readonly upper: any;
|
|
readonly upperOpen: boolean;
|
|
}
|
|
|
|
declare var IDBKeyRange: {
|
|
prototype: IDBKeyRange;
|
|
new(): IDBKeyRange;
|
|
bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
|
|
lowerBound(lower: any, open?: boolean): IDBKeyRange;
|
|
only(value: any): IDBKeyRange;
|
|
upperBound(upper: any, open?: boolean): IDBKeyRange;
|
|
};
|
|
|
|
interface IDBObjectStore {
|
|
autoIncrement: boolean;
|
|
readonly indexNames: DOMStringList;
|
|
readonly keyPath: string | string[] | null;
|
|
readonly name: string;
|
|
readonly transaction: IDBTransaction;
|
|
add(value: any, key?: IDBKeyRange | number | string | Date | IDBArrayKey): IDBRequest;
|
|
clear(): IDBRequest;
|
|
count(key?: IDBKeyRange | number | string | Date | IDBArrayKey): IDBRequest;
|
|
createIndex(name: string, keyPath: string | string[], optionalParameters?: IDBIndexParameters): IDBIndex;
|
|
delete(key: IDBKeyRange | number | string | Date | IDBArrayKey): IDBRequest;
|
|
deleteIndex(indexName: string): void;
|
|
get(key: any): IDBRequest;
|
|
index(name: string): IDBIndex;
|
|
openCursor(range?: IDBKeyRange | number | string | Date | IDBArrayKey, direction?: IDBCursorDirection): IDBRequest;
|
|
put(value: any, key?: IDBKeyRange | number | string | Date | IDBArrayKey): 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 {
|
|
readonly error: DOMException;
|
|
onerror: ((this: IDBRequest, ev: Event) => any) | null;
|
|
onsuccess: ((this: IDBRequest, ev: Event) => any) | null;
|
|
readonly readyState: IDBRequestReadyState;
|
|
readonly result: any;
|
|
readonly source: IDBObjectStore | IDBIndex | IDBCursor;
|
|
readonly transaction: IDBTransaction;
|
|
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 {
|
|
readonly db: IDBDatabase;
|
|
readonly error: DOMException;
|
|
readonly mode: IDBTransactionMode;
|
|
onabort: ((this: IDBTransaction, ev: Event) => any) | null;
|
|
oncomplete: ((this: IDBTransaction, ev: Event) => any) | null;
|
|
onerror: ((this: IDBTransaction, ev: Event) => any) | null;
|
|
abort(): void;
|
|
objectStore(name: string): IDBObjectStore;
|
|
readonly READ_ONLY: string;
|
|
readonly READ_WRITE: string;
|
|
readonly VERSION_CHANGE: string;
|
|
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;
|
|
readonly READ_ONLY: string;
|
|
readonly READ_WRITE: string;
|
|
readonly VERSION_CHANGE: string;
|
|
};
|
|
|
|
interface IDBVersionChangeEvent extends Event {
|
|
readonly newVersion: number | null;
|
|
readonly oldVersion: number;
|
|
}
|
|
|
|
declare var IDBVersionChangeEvent: {
|
|
prototype: IDBVersionChangeEvent;
|
|
new(): 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 {
|
|
readonly data: Uint8ClampedArray;
|
|
readonly height: number;
|
|
readonly width: number;
|
|
}
|
|
|
|
declare var ImageData: {
|
|
prototype: ImageData;
|
|
new(width: number, height: number): ImageData;
|
|
new(array: Uint8ClampedArray, width: number, height: number): ImageData;
|
|
};
|
|
|
|
interface MessageChannel {
|
|
readonly port1: MessagePort;
|
|
readonly port2: MessagePort;
|
|
}
|
|
|
|
declare var MessageChannel: {
|
|
prototype: MessageChannel;
|
|
new(): MessageChannel;
|
|
};
|
|
|
|
interface MessageEvent extends Event {
|
|
readonly data: any;
|
|
readonly origin: string;
|
|
readonly ports: ReadonlyArray<MessagePort>;
|
|
readonly source: object | null;
|
|
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;
|
|
}
|
|
|
|
interface MessagePort extends EventTarget {
|
|
onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
|
|
close(): void;
|
|
postMessage(message?: any, transfer?: any[]): void;
|
|
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 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 NotificationEventMap {
|
|
"click": Event;
|
|
"close": Event;
|
|
"error": Event;
|
|
"show": Event;
|
|
}
|
|
|
|
interface Notification extends EventTarget {
|
|
readonly body: string | null;
|
|
readonly data: any;
|
|
readonly dir: NotificationDirection;
|
|
readonly icon: string | null;
|
|
readonly lang: string | null;
|
|
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 permission: NotificationPermission;
|
|
readonly tag: string | null;
|
|
readonly title: string;
|
|
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;
|
|
requestPermission(callback?: NotificationPermissionCallback): Promise<NotificationPermission>;
|
|
};
|
|
|
|
interface NotificationEvent extends ExtendableEvent {
|
|
readonly action: string;
|
|
readonly notification: Notification;
|
|
}
|
|
|
|
declare var NotificationEvent: {
|
|
prototype: NotificationEvent;
|
|
new(type: string, eventInitDict: NotificationEventInit): NotificationEvent;
|
|
};
|
|
|
|
interface Performance {
|
|
/** @deprecated */
|
|
readonly navigation: PerformanceNavigation;
|
|
readonly timeOrigin: number;
|
|
/** @deprecated */
|
|
readonly timing: PerformanceTiming;
|
|
clearMarks(markName?: string): void;
|
|
clearMeasures(measureName?: string): void;
|
|
clearResourceTimings(): void;
|
|
getEntries(): any;
|
|
getEntriesByName(name: string, type?: string): any;
|
|
getEntriesByType(type: string): any;
|
|
/** @deprecated */
|
|
getMarks(markName?: string): any;
|
|
/** @deprecated */
|
|
getMeasures(measureName?: string): any;
|
|
mark(markName: string): void;
|
|
measure(measureName: string, startMarkName?: string, endMarkName?: string): void;
|
|
now(): number;
|
|
setResourceTimingBufferSize(maxSize: number): void;
|
|
toJSON(): any;
|
|
}
|
|
|
|
declare var Performance: {
|
|
prototype: Performance;
|
|
new(): Performance;
|
|
};
|
|
|
|
interface PerformanceNavigation {
|
|
readonly redirectCount: number;
|
|
readonly type: number;
|
|
toJSON(): any;
|
|
readonly TYPE_BACK_FORWARD: number;
|
|
readonly TYPE_NAVIGATE: number;
|
|
readonly TYPE_RELOAD: number;
|
|
readonly TYPE_RESERVED: number;
|
|
}
|
|
|
|
declare var PerformanceNavigation: {
|
|
prototype: PerformanceNavigation;
|
|
new(): PerformanceNavigation;
|
|
readonly TYPE_BACK_FORWARD: number;
|
|
readonly TYPE_NAVIGATE: number;
|
|
readonly TYPE_RELOAD: number;
|
|
readonly TYPE_RESERVED: number;
|
|
};
|
|
|
|
interface PerformanceTiming {
|
|
readonly connectEnd: number;
|
|
readonly connectStart: number;
|
|
readonly domComplete: number;
|
|
readonly domContentLoadedEventEnd: number;
|
|
readonly domContentLoadedEventStart: number;
|
|
readonly domInteractive: number;
|
|
readonly domLoading: number;
|
|
readonly domainLookupEnd: number;
|
|
readonly domainLookupStart: number;
|
|
readonly fetchStart: number;
|
|
readonly loadEventEnd: number;
|
|
readonly loadEventStart: number;
|
|
readonly msFirstPaint: number;
|
|
readonly navigationStart: number;
|
|
readonly redirectEnd: number;
|
|
readonly redirectStart: number;
|
|
readonly requestStart: number;
|
|
readonly responseEnd: number;
|
|
readonly responseStart: number;
|
|
readonly secureConnectionStart: number;
|
|
readonly unloadEventEnd: number;
|
|
readonly unloadEventStart: number;
|
|
toJSON(): any;
|
|
}
|
|
|
|
declare var PerformanceTiming: {
|
|
prototype: PerformanceTiming;
|
|
new(): PerformanceTiming;
|
|
};
|
|
|
|
interface Position {
|
|
readonly coords: Coordinates;
|
|
readonly timestamp: number;
|
|
}
|
|
|
|
declare var Position: {
|
|
prototype: Position;
|
|
new(): Position;
|
|
};
|
|
|
|
interface PositionError {
|
|
readonly code: number;
|
|
readonly message: string;
|
|
toString(): string;
|
|
readonly PERMISSION_DENIED: number;
|
|
readonly POSITION_UNAVAILABLE: number;
|
|
readonly TIMEOUT: number;
|
|
}
|
|
|
|
declare var PositionError: {
|
|
prototype: PositionError;
|
|
new(): PositionError;
|
|
readonly PERMISSION_DENIED: number;
|
|
readonly POSITION_UNAVAILABLE: number;
|
|
readonly TIMEOUT: number;
|
|
};
|
|
|
|
interface ProgressEvent extends Event {
|
|
readonly lengthComputable: boolean;
|
|
readonly loaded: number;
|
|
readonly total: number;
|
|
initProgressEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, lengthComputableArg: boolean, loadedArg: number, totalArg: number): void;
|
|
}
|
|
|
|
declare var ProgressEvent: {
|
|
prototype: ProgressEvent;
|
|
new(typeArg: string, eventInitDict?: ProgressEventInit): ProgressEvent;
|
|
};
|
|
|
|
interface PushEvent extends ExtendableEvent {
|
|
readonly data: PushMessageData | null;
|
|
}
|
|
|
|
declare var PushEvent: {
|
|
prototype: PushEvent;
|
|
new(type: string, eventInitDict?: PushEventInit): PushEvent;
|
|
};
|
|
|
|
interface PushManager {
|
|
readonly supportedContentEncodings: ReadonlyArray<string>;
|
|
getSubscription(): Promise<PushSubscription | null>;
|
|
permissionState(options?: PushSubscriptionOptionsInit): Promise<PushPermissionState>;
|
|
subscribe(options?: PushSubscriptionOptionsInit): Promise<PushSubscription>;
|
|
}
|
|
|
|
declare var PushManager: {
|
|
prototype: PushManager;
|
|
new(): PushManager;
|
|
};
|
|
|
|
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(): any;
|
|
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 {
|
|
readonly cache: RequestCache;
|
|
readonly credentials: RequestCredentials;
|
|
readonly destination: RequestDestination;
|
|
readonly headers: Headers;
|
|
readonly integrity: string;
|
|
readonly keepalive: boolean;
|
|
readonly method: string;
|
|
readonly mode: RequestMode;
|
|
readonly redirect: RequestRedirect;
|
|
readonly referrer: string;
|
|
readonly referrerPolicy: ReferrerPolicy;
|
|
readonly signal: object | null;
|
|
readonly type: RequestType;
|
|
readonly url: string;
|
|
clone(): Request;
|
|
}
|
|
|
|
declare var Request: {
|
|
prototype: Request;
|
|
new(input: Request | string, init?: RequestInit): Request;
|
|
};
|
|
|
|
interface Response extends Body {
|
|
readonly body: ReadableStream | null;
|
|
readonly headers: Headers;
|
|
readonly ok: boolean;
|
|
readonly redirected: boolean;
|
|
readonly status: number;
|
|
readonly statusText: string;
|
|
readonly type: ResponseType;
|
|
readonly url: string;
|
|
clone(): Response;
|
|
}
|
|
|
|
declare var Response: {
|
|
prototype: Response;
|
|
new(body?: Blob | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | FormData | string | 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 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;
|
|
onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
|
|
readonly pushManager: PushManager;
|
|
readonly scope: string;
|
|
readonly sync: SyncManager;
|
|
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 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 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;
|
|
toString(): string;
|
|
}
|
|
|
|
declare var URL: {
|
|
prototype: URL;
|
|
new(url: string, base?: string | URL): URL;
|
|
createObjectURL(object: any, options?: ObjectURLOptions): 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;
|
|
}
|
|
|
|
declare var URLSearchParams: {
|
|
prototype: URLSearchParams;
|
|
new (init?: 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>;
|
|
}
|
|
|
|
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;
|
|
/** @deprecated */
|
|
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 {
|
|
}
|
|
|
|
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 EventTarget, XMLHttpRequestEventTarget {
|
|
msCaching: string;
|
|
onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
|
|
readonly readyState: number;
|
|
readonly response: any;
|
|
readonly responseText: string;
|
|
responseType: XMLHttpRequestResponseType;
|
|
readonly responseURL: string;
|
|
readonly responseXML: object | null;
|
|
readonly status: number;
|
|
readonly statusText: string;
|
|
timeout: number;
|
|
readonly upload: XMLHttpRequestUpload;
|
|
withCredentials: boolean;
|
|
abort(): void;
|
|
getAllResponseHeaders(): string;
|
|
getResponseHeader(header: string): string | null;
|
|
msCachingEnabled(): boolean;
|
|
open(method: string, url: string, async?: boolean, user?: string | null, password?: string | null): void;
|
|
overrideMimeType(mime: string): void;
|
|
send(data?: any): void;
|
|
setRequestHeader(header: 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": Event;
|
|
"error": ErrorEvent;
|
|
"load": Event;
|
|
"loadend": ProgressEvent;
|
|
"loadstart": Event;
|
|
"progress": ProgressEvent;
|
|
"timeout": ProgressEvent;
|
|
}
|
|
|
|
interface XMLHttpRequestEventTarget {
|
|
onabort: ((this: XMLHttpRequest, ev: Event) => any) | null;
|
|
onerror: ((this: XMLHttpRequest, ev: ErrorEvent) => any) | null;
|
|
onload: ((this: XMLHttpRequest, ev: Event) => any) | null;
|
|
onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
|
onloadstart: ((this: XMLHttpRequest, ev: Event) => 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;
|
|
}
|
|
|
|
interface XMLHttpRequestUpload extends EventTarget, 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 DecodeErrorCallback {
|
|
(error: DOMException): void;
|
|
}
|
|
|
|
interface DecodeSuccessCallback {
|
|
(decodedData: AudioBuffer): void;
|
|
}
|
|
|
|
interface ErrorEventHandler {
|
|
(event: Event | string, source?: string, fileno?: number, columnNumber?: number, error?: Error): void;
|
|
}
|
|
|
|
interface ForEachCallback {
|
|
(keyId: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, status: MediaKeyStatus): void;
|
|
}
|
|
|
|
interface FunctionStringCallback {
|
|
(data: string): void;
|
|
}
|
|
|
|
interface NotificationPermissionCallback {
|
|
(permission: NotificationPermission): void;
|
|
}
|
|
|
|
interface PositionCallback {
|
|
(position: Position): void;
|
|
}
|
|
|
|
interface PositionErrorCallback {
|
|
(error: PositionError): 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 importScripts(...urls: string[]): 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 FormDataEntryValue = string | File;
|
|
type HeadersInit = Headers | string[][] | { [key: string]: string };
|
|
type AlgorithmIdentifier = string | Algorithm;
|
|
type AAGUID = string;
|
|
type BodyInit = any;
|
|
type ByteString = string;
|
|
type CryptoOperationData = ArrayBufferView;
|
|
type GLbitfield = number;
|
|
type GLboolean = boolean;
|
|
type GLbyte = number;
|
|
type GLclampf = number;
|
|
type GLenum = number;
|
|
type GLfloat = number;
|
|
type GLint = number;
|
|
type GLintptr = number;
|
|
type GLshort = number;
|
|
type GLsizei = number;
|
|
type GLsizeiptr = number;
|
|
type GLubyte = number;
|
|
type GLuint = number;
|
|
type GLushort = number;
|
|
type IDBKeyPath = string;
|
|
type RequestInfo = Request | string;
|
|
type USVString = string;
|
|
type payloadtype = number;
|
|
type ClientTypes = "window" | "worker" | "sharedworker" | "all";
|
|
type BinaryType = "blob" | "arraybuffer";
|
|
type IDBCursorDirection = "next" | "nextunique" | "prev" | "prevunique";
|
|
type IDBRequestReadyState = "pending" | "done";
|
|
type IDBTransactionMode = "readonly" | "readwrite" | "versionchange";
|
|
type KeyFormat = "raw" | "spki" | "pkcs8" | "jwk";
|
|
type KeyType = "public" | "private" | "secret";
|
|
type KeyUsage = "encrypt" | "decrypt" | "sign" | "verify" | "deriveKey" | "deriveBits" | "wrapKey" | "unwrapKey";
|
|
type MediaKeyStatus = "usable" | "expired" | "output-downscaled" | "output-not-allowed" | "status-pending" | "internal-error";
|
|
type NotificationDirection = "auto" | "ltr" | "rtl";
|
|
type NotificationPermission = "default" | "denied" | "granted";
|
|
type PushEncryptionKeyName = "p256dh" | "auth";
|
|
type PushPermissionState = "granted" | "denied" | "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";
|
|
type RequestCredentials = "omit" | "same-origin" | "include";
|
|
type RequestDestination = "" | "document" | "sharedworker" | "subresource" | "unknown" | "worker";
|
|
type RequestMode = "navigate" | "same-origin" | "no-cors" | "cors";
|
|
type RequestRedirect = "follow" | "error" | "manual";
|
|
type RequestType = "" | "audio" | "font" | "image" | "script" | "style" | "track" | "video";
|
|
type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
|
|
type ServiceWorkerState = "installing" | "installed" | "activating" | "activated" | "redundant";
|
|
type VisibilityState = "hidden" | "visible" | "prerender" | "unloaded";
|
|
type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text"; |