/*! ***************************************************************************** Copyright © 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 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”/>
///////////////////////////// /// IE Worker APIs /////////////////////////////
interface Algorithm {
name: string;
}
interface EventInit {
scoped?: boolean; bubbles?: boolean; cancelable?: boolean;
}
interface IDBIndexParameters {
multiEntry?: boolean; unique?: boolean;
}
interface IDBObjectStoreParameters {
autoIncrement?: boolean; keyPath?: IDBKeyPath;
}
interface KeyAlgorithm {
name?: string;
}
interface EventListener {
(evt: Event): 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 CloseEvent extends Event {
readonly code: number; readonly reason: string; readonly wasClean: boolean; initCloseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, wasCleanArg: boolean, codeArg: number, reasonArg: string): void;
}
declare var CloseEvent: {
prototype: CloseEvent; new(): CloseEvent;
}
interface Console {
assert(test?: boolean, message?: string, ...optionalParams: any[]): void; clear(): void; count(countTitle?: string): void; debug(message?: string, ...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): void; groupCollapsed(groupTitle?: string): void; groupEnd(): void; info(message?: any, ...optionalParams: any[]): void; log(message?: any, ...optionalParams: any[]): void; msIsIndependentlyComposed(element: any): boolean; profile(reportName?: string): void; profileEnd(): void; select(element: any): void; table(...data: any[]): void; time(timerName?: string): void; timeEnd(timerName?: 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(): 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 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(): ErrorEvent;
}
interface Event {
readonly bubbles: boolean; cancelBubble: boolean; readonly cancelable: boolean; readonly currentTarget: EventTarget; readonly defaultPrevented: boolean; readonly eventPhase: number; readonly isTrusted: boolean; returnValue: boolean; readonly srcElement: any; readonly target: EventTarget; readonly timeStamp: number; readonly type: string; readonly scoped: boolean; initEvent(eventTypeArg: string, canBubbleArg: boolean, cancelableArg: boolean): void; preventDefault(): void; stopImmediatePropagation(): void; stopPropagation(): void; deepPath(): EventTarget[]; readonly AT_TARGET: number; readonly BUBBLING_PHASE: number; readonly CAPTURING_PHASE: number;
}
declare var Event: {
prototype: Event; new(type: string, eventInitDict?: EventInit): Event; readonly AT_TARGET: number; readonly BUBBLING_PHASE: number; readonly CAPTURING_PHASE: number;
}
interface EventTarget {
addEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void; dispatchEvent(evt: Event): boolean; removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
declare var EventTarget: {
prototype: EventTarget; new(): EventTarget;
}
interface File extends Blob {
readonly lastModifiedDate: any; 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; [index: number]: File;
}
declare var FileList: {
prototype: FileList; new(): FileList;
}
interface FileReader extends EventTarget, MSBaseReader {
readonly error: DOMError; readAsArrayBuffer(blob: Blob): void; readAsBinaryString(blob: Blob): void; readAsDataURL(blob: Blob): void; readAsText(blob: Blob, encoding?: string): void; addEventListener<K extends keyof MSBaseReaderEventMap>(type: K, listener: (this: MSBaseReader, ev: MSBaseReaderEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
declare var FileReader: {
prototype: FileReader; new(): FileReader;
}
interface IDBCursor {
readonly direction: string; key: IDBKeyRange | IDBValidKey; readonly primaryKey: any; source: IDBObjectStore | IDBIndex; advance(count: number): void; continue(key?: IDBKeyRange | IDBValidKey): 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": ErrorEvent;
}
interface IDBDatabase extends EventTarget {
readonly name: string; readonly objectStoreNames: DOMStringList; onabort: (this: IDBDatabase, ev: Event) => any; onerror: (this: IDBDatabase, ev: ErrorEvent) => any; version: number; onversionchange: (ev: IDBVersionChangeEvent) => any; close(): void; createObjectStore(name: string, optionalParameters?: IDBObjectStoreParameters): IDBObjectStore; deleteObjectStore(name: string): void; transaction(storeNames: string | string[], mode?: string): IDBTransaction; addEventListener(type: "versionchange", listener: (ev: IDBVersionChangeEvent) => any, useCapture?: boolean): void; addEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IDBDatabase, ev: IDBDatabaseEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): 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 {
keyPath: string | string[]; readonly name: string; readonly objectStore: IDBObjectStore; readonly unique: boolean; multiEntry: boolean; count(key?: IDBKeyRange | IDBValidKey): IDBRequest; get(key: IDBKeyRange | IDBValidKey): IDBRequest; getKey(key: IDBKeyRange | IDBValidKey): IDBRequest; openCursor(range?: IDBKeyRange | IDBValidKey, direction?: string): IDBRequest; openKeyCursor(range?: IDBKeyRange | IDBValidKey, direction?: string): 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 {
readonly indexNames: DOMStringList; keyPath: string | string[]; readonly name: string; readonly transaction: IDBTransaction; autoIncrement: boolean; add(value: any, key?: IDBKeyRange | IDBValidKey): IDBRequest; clear(): IDBRequest; count(key?: IDBKeyRange | IDBValidKey): IDBRequest; createIndex(name: string, keyPath: string | string[], optionalParameters?: IDBIndexParameters): IDBIndex; delete(key: IDBKeyRange | IDBValidKey): IDBRequest; deleteIndex(indexName: string): void; get(key: any): IDBRequest; index(name: string): IDBIndex; openCursor(range?: IDBKeyRange | IDBValidKey, direction?: string): IDBRequest; put(value: any, key?: IDBKeyRange | IDBValidKey): 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; onupgradeneeded: (this: IDBOpenDBRequest, ev: IDBVersionChangeEvent) => any; addEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IDBOpenDBRequest, ev: IDBOpenDBRequestEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
declare var IDBOpenDBRequest: {
prototype: IDBOpenDBRequest; new(): IDBOpenDBRequest;
}
interface IDBRequestEventMap {
"error": ErrorEvent; "success": Event;
}
interface IDBRequest extends EventTarget {
readonly error: DOMError; onerror: (this: IDBRequest, ev: ErrorEvent) => any; onsuccess: (this: IDBRequest, ev: Event) => any; readonly readyState: string; readonly result: any; source: IDBObjectStore | IDBIndex | IDBCursor; readonly transaction: IDBTransaction; addEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IDBRequest, ev: IDBRequestEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
declare var IDBRequest: {
prototype: IDBRequest; new(): IDBRequest;
}
interface IDBTransactionEventMap {
"abort": Event; "complete": Event; "error": ErrorEvent;
}
interface IDBTransaction extends EventTarget {
readonly db: IDBDatabase; readonly error: DOMError; readonly mode: string; onabort: (this: IDBTransaction, ev: Event) => any; oncomplete: (this: IDBTransaction, ev: Event) => any; onerror: (this: IDBTransaction, ev: ErrorEvent) => any; 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, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): 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 ImageData {
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 MSApp {
clearTemporaryWebDataAsync(): MSAppAsyncOperation; createBlobFromRandomAccessStream(type: string, seeker: any): Blob; createDataPackage(object: any): any; createDataPackageFromSelection(): any; createFileFromStorageFile(storageFile: any): File; createStreamFromInputStream(type: string, inputStream: any): MSStream; execAsyncAtPriority(asynchronousCallback: MSExecAtPriorityFunctionCallback, priority: string, ...args: any[]): void; execAtPriority(synchronousCallback: MSExecAtPriorityFunctionCallback, priority: string, ...args: any[]): any; getCurrentPriority(): string; getHtmlPrintDocumentSourceAsync(htmlDoc: any): PromiseLike<any>; getViewId(view: any): any; isTaskScheduledAtPriorityOrHigher(priority: string): boolean; pageHandlesAllApplicationActivations(enabled: boolean): void; suppressSubdownloadCredentialPrompts(suppress: boolean): void; terminateApp(exceptionObject: any): void; readonly CURRENT: string; readonly HIGH: string; readonly IDLE: string; readonly NORMAL: string;
} declare var MSApp: MSApp;
interface MSAppAsyncOperationEventMap {
"complete": Event; "error": ErrorEvent;
}
interface MSAppAsyncOperation extends EventTarget {
readonly error: DOMError; oncomplete: (this: MSAppAsyncOperation, ev: Event) => any; onerror: (this: MSAppAsyncOperation, ev: ErrorEvent) => any; readonly readyState: number; readonly result: any; start(): void; readonly COMPLETED: number; readonly ERROR: number; readonly STARTED: number; addEventListener<K extends keyof MSAppAsyncOperationEventMap>(type: K, listener: (this: MSAppAsyncOperation, ev: MSAppAsyncOperationEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
declare var MSAppAsyncOperation: {
prototype: MSAppAsyncOperation; new(): MSAppAsyncOperation; readonly COMPLETED: number; readonly ERROR: number; readonly STARTED: number;
}
interface MSBlobBuilder {
append(data: any, endings?: string): void; getBlob(contentType?: string): Blob;
}
declare var MSBlobBuilder: {
prototype: MSBlobBuilder; new(): MSBlobBuilder;
}
interface MSStream {
readonly type: string; msClose(): void; msDetachStream(): any;
}
declare var MSStream: {
prototype: MSStream; new(): MSStream;
}
interface MSStreamReader extends EventTarget, MSBaseReader {
readonly error: DOMError; readAsArrayBuffer(stream: MSStream, size?: number): void; readAsBinaryString(stream: MSStream, size?: number): void; readAsBlob(stream: MSStream, size?: number): void; readAsDataURL(stream: MSStream, size?: number): void; readAsText(stream: MSStream, encoding?: string, size?: number): void; addEventListener<K extends keyof MSBaseReaderEventMap>(type: K, listener: (this: MSBaseReader, ev: MSBaseReaderEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
declare var MSStreamReader: {
prototype: MSStreamReader; new(): MSStreamReader;
}
interface MediaQueryList {
readonly matches: boolean; readonly media: string; addListener(listener: MediaQueryListListener): void; removeListener(listener: MediaQueryListListener): void;
}
declare var MediaQueryList: {
prototype: MediaQueryList; new(): MediaQueryList;
}
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: any; readonly source: any; initMessageEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, dataArg: any, originArg: string, lastEventIdArg: string, sourceArg: any): 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; close(): void; postMessage(message?: any, ports?: any): void; start(): void; addEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
declare var MessagePort: {
prototype: MessagePort; new(): MessagePort;
}
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(type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
}
interface WebSocketEventMap {
"close": CloseEvent; "error": ErrorEvent; "message": MessageEvent; "open": Event;
}
interface WebSocket extends EventTarget {
binaryType: string; readonly bufferedAmount: number; readonly extensions: string; onclose: (this: WebSocket, ev: CloseEvent) => any; onerror: (this: WebSocket, ev: ErrorEvent) => any; onmessage: (this: WebSocket, ev: MessageEvent) => any; onopen: (this: WebSocket, ev: Event) => any; readonly protocol: string; readonly readyState: number; readonly url: string; close(code?: number, reason?: string): void; send(data: any): 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, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): 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 WorkerEventMap extends AbstractWorkerEventMap {
"message": MessageEvent;
}
interface Worker extends EventTarget, AbstractWorker {
onmessage: (this: Worker, ev: MessageEvent) => any; postMessage(message: any, ports?: any): void; terminate(): void; addEventListener<K extends keyof WorkerEventMap>(type: K, listener: (this: Worker, ev: WorkerEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
declare var Worker: {
prototype: Worker; new(stringUrl: string): Worker;
}
interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
"readystatechange": Event;
}
interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget {
onreadystatechange: (this: XMLHttpRequest, ev: Event) => any; readonly readyState: number; readonly response: any; readonly responseText: string; responseType: string; readonly responseXML: any; readonly status: number; readonly statusText: string; timeout: number; readonly upload: XMLHttpRequestUpload; withCredentials: boolean; msCaching?: string; readonly responseURL: string; abort(): void; getAllResponseHeaders(): string; getResponseHeader(header: string): string | null; msCachingEnabled(): boolean; open(method: string, url: string, async?: boolean, user?: string, password?: string): void; overrideMimeType(mime: string): void; send(data?: 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, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
declare var XMLHttpRequest: {
prototype: XMLHttpRequest; new(): XMLHttpRequest; readonly DONE: number; readonly HEADERS_RECEIVED: number; readonly LOADING: number; readonly OPENED: number; readonly UNSENT: number; create(): XMLHttpRequest;
}
interface XMLHttpRequestUpload extends EventTarget, XMLHttpRequestEventTarget {
addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
declare var XMLHttpRequestUpload: {
prototype: XMLHttpRequestUpload; new(): XMLHttpRequestUpload;
}
interface AbstractWorkerEventMap {
"error": ErrorEvent;
}
interface AbstractWorker {
onerror: (this: AbstractWorker, ev: ErrorEvent) => any; addEventListener<K extends keyof AbstractWorkerEventMap>(type: K, listener: (this: AbstractWorker, ev: AbstractWorkerEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
interface MSBaseReaderEventMap {
"abort": Event; "error": ErrorEvent; "load": Event; "loadend": ProgressEvent; "loadstart": Event; "progress": ProgressEvent;
}
interface MSBaseReader {
onabort: (this: MSBaseReader, ev: Event) => any; onerror: (this: MSBaseReader, ev: ErrorEvent) => any; onload: (this: MSBaseReader, ev: Event) => any; onloadend: (this: MSBaseReader, ev: ProgressEvent) => any; onloadstart: (this: MSBaseReader, ev: Event) => any; onprogress: (this: MSBaseReader, ev: ProgressEvent) => any; readonly readyState: number; readonly result: any; abort(): void; readonly DONE: number; readonly EMPTY: number; readonly LOADING: number; addEventListener<K extends keyof MSBaseReaderEventMap>(type: K, listener: (this: MSBaseReader, ev: MSBaseReaderEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
interface NavigatorID {
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 WindowBase64 {
atob(encodedString: string): string; btoa(rawString: string): string;
}
interface WindowConsole {
readonly console: Console;
}
interface XMLHttpRequestEventTargetEventMap {
"abort": Event; "error": ErrorEvent; "load": Event; "loadend": ProgressEvent; "loadstart": Event; "progress": ProgressEvent; "timeout": ProgressEvent;
}
interface XMLHttpRequestEventTarget {
onabort: (this: XMLHttpRequestEventTarget, ev: Event) => any; onerror: (this: XMLHttpRequestEventTarget, ev: ErrorEvent) => any; onload: (this: XMLHttpRequestEventTarget, ev: Event) => any; onloadend: (this: XMLHttpRequestEventTarget, ev: ProgressEvent) => any; onloadstart: (this: XMLHttpRequestEventTarget, ev: Event) => any; onprogress: (this: XMLHttpRequestEventTarget, ev: ProgressEvent) => any; ontimeout: (this: XMLHttpRequestEventTarget, ev: ProgressEvent) => any; addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
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 WorkerGlobalScopeEventMap extends DedicatedWorkerGlobalScopeEventMap {
"error": ErrorEvent;
}
interface WorkerGlobalScope extends EventTarget, WorkerUtils, DedicatedWorkerGlobalScope, WindowConsole {
readonly location: WorkerLocation; onerror: (this: WorkerGlobalScope, ev: ErrorEvent) => any; readonly self: WorkerGlobalScope; close(): void; msWriteProfilerMark(profilerMarkName: string): void; toString(): string; addEventListener<K extends keyof WorkerGlobalScopeEventMap>(type: K, listener: (this: WorkerGlobalScope, ev: WorkerGlobalScopeEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
declare var WorkerGlobalScope: {
prototype: WorkerGlobalScope; new(): WorkerGlobalScope;
}
interface WorkerLocation {
readonly hash: string; readonly host: string; readonly hostname: string; readonly href: 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 Object, NavigatorID, NavigatorOnLine {
readonly hardwareConcurrency: number;
}
declare var WorkerNavigator: {
prototype: WorkerNavigator; new(): WorkerNavigator;
}
interface DedicatedWorkerGlobalScopeEventMap {
"message": MessageEvent;
}
interface DedicatedWorkerGlobalScope {
onmessage: (this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any; postMessage(data: any): void; addEventListener<K extends keyof DedicatedWorkerGlobalScopeEventMap>(type: K, listener: (this: DedicatedWorkerGlobalScope, ev: DedicatedWorkerGlobalScopeEventMap[K]) => any, useCapture?: boolean): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
interface WorkerUtils extends Object, 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: (...args: any[]) => void): number; setImmediate(handler: any, ...args: any[]): number; setInterval(handler: (...args: any[]) => void, timeout: number): number; setInterval(handler: any, timeout?: any, ...args: any[]): number; setTimeout(handler: (...args: any[]) => void, timeout: number): number; setTimeout(handler: any, timeout?: any, ...args: any[]): number;
}
interface BlobPropertyBag {
type?: string; endings?: string;
}
interface FilePropertyBag {
type?: string; lastModified?: number;
}
interface EventListenerObject {
handleEvent(evt: Event): void;
}
interface MessageEventInit extends EventInit {
data?: any; origin?: string; lastEventId?: string; channel?: string; source?: any; ports?: MessagePort[];
}
interface ProgressEventInit extends EventInit {
lengthComputable?: boolean; loaded?: number; total?: number;
}
interface IDBArrayKey extends Array<IDBValidKey> { }
interface RsaKeyGenParams extends Algorithm {
modulusLength: number; publicExponent: Uint8Array;
}
interface RsaHashedKeyGenParams extends RsaKeyGenParams {
hash: AlgorithmIdentifier;
}
interface RsaKeyAlgorithm extends KeyAlgorithm {
modulusLength: number; publicExponent: Uint8Array;
}
interface RsaHashedKeyAlgorithm extends RsaKeyAlgorithm {
hash: AlgorithmIdentifier;
}
interface RsaHashedImportParams {
hash: AlgorithmIdentifier;
}
interface RsaPssParams {
saltLength: number;
}
interface RsaOaepParams extends Algorithm {
label?: BufferSource;
}
interface EcdsaParams extends Algorithm {
hash: AlgorithmIdentifier;
}
interface EcKeyGenParams extends Algorithm {
namedCurve: string;
}
interface EcKeyAlgorithm extends KeyAlgorithm {
typedCurve: string;
}
interface EcKeyImportParams {
namedCurve: string;
}
interface EcdhKeyDeriveParams extends Algorithm {
public: CryptoKey;
}
interface AesCtrParams extends Algorithm {
counter: BufferSource; length: number;
}
interface AesKeyAlgorithm extends KeyAlgorithm {
length: number;
}
interface AesKeyGenParams extends Algorithm {
length: number;
}
interface AesDerivedKeyParams extends Algorithm {
length: number;
}
interface AesCbcParams extends Algorithm {
iv: BufferSource;
}
interface AesCmacParams extends Algorithm {
length: number;
}
interface AesGcmParams extends Algorithm {
iv: BufferSource; additionalData?: BufferSource; tagLength?: number;
}
interface AesCfbParams extends Algorithm {
iv: BufferSource;
}
interface HmacImportParams extends Algorithm {
hash?: AlgorithmIdentifier; length?: number;
}
interface HmacKeyAlgorithm extends KeyAlgorithm {
hash: AlgorithmIdentifier; length: number;
}
interface HmacKeyGenParams extends Algorithm {
hash: AlgorithmIdentifier; length?: number;
}
interface DhKeyGenParams extends Algorithm {
prime: Uint8Array; generator: Uint8Array;
}
interface DhKeyAlgorithm extends KeyAlgorithm {
prime: Uint8Array; generator: Uint8Array;
}
interface DhKeyDeriveParams extends Algorithm {
public: CryptoKey;
}
interface DhImportKeyParams extends Algorithm {
prime: Uint8Array; generator: Uint8Array;
}
interface ConcatParams extends Algorithm {
hash?: AlgorithmIdentifier; algorithmId: Uint8Array; partyUInfo: Uint8Array; partyVInfo: Uint8Array; publicInfo?: Uint8Array; privateInfo?: Uint8Array;
}
interface HkdfCtrParams extends Algorithm {
hash: AlgorithmIdentifier; label: BufferSource; context: BufferSource;
}
interface Pbkdf2Params extends Algorithm {
salt: BufferSource; iterations: number; hash: AlgorithmIdentifier;
}
interface RsaOtherPrimesInfo {
r: string; d: string; t: string;
}
interface JsonWebKey {
kty: string; use?: string; key_ops?: string[]; alg?: string; kid?: string; x5u?: string; x5c?: string; x5t?: string; ext?: boolean; crv?: string; x?: string; y?: string; d?: string; n?: string; e?: string; p?: string; q?: string; dp?: string; dq?: string; qi?: string; oth?: RsaOtherPrimesInfo[]; k?: string;
}
declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
interface ErrorEventHandler {
(message: string, filename?: string, lineno?: number, colno?: number, error?:Error): void;
} interface PositionCallback {
(position: Position): void;
} interface PositionErrorCallback {
(error: PositionError): void;
} interface MediaQueryListListener {
(mql: MediaQueryList): void;
} interface MSLaunchUriCallback {
(): void;
} interface MSUnsafeFunctionCallback {
(): any;
} interface MSExecAtPriorityFunctionCallback {
(...args: any[]): any;
} interface DecodeSuccessCallback {
(decodedData: AudioBuffer): void;
} interface DecodeErrorCallback {
(error: DOMException): void;
} interface FunctionStringCallback {
(data: string): void;
} declare var location: WorkerLocation; declare var onerror: (this: WorkerGlobalScope, ev: ErrorEvent) => any; declare var self: WorkerGlobalScope; declare function close(): void; declare function msWriteProfilerMark(profilerMarkName: string): void; declare function toString(): string; declare function dispatchEvent(evt: Event): boolean; declare function removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void; 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: (…args: any[]) => void): number; declare function setImmediate(handler: any, …args: any[]): number; declare function setInterval(handler: (…args: any[]) => void, timeout: number): number; declare function setInterval(handler: any, timeout?: any, …args: any[]): number; declare function setTimeout(handler: (…args: any[]) => void, timeout: number): 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 onmessage: (this: WorkerGlobalScope, ev: MessageEvent) => any; declare function postMessage(data: any): void; declare var console: Console; declare function addEventListener<K extends keyof WorkerGlobalScopeEventMap>(type: K, listener: (this: WorkerGlobalScope, ev: WorkerGlobalScopeEventMap) => any, useCapture?: boolean): void; declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; type AlgorithmIdentifier = string | Algorithm; type IDBKeyPath = string; type IDBValidKey = number | string | Date | IDBArrayKey; type BufferSource = ArrayBuffer | ArrayBufferView;