typescript-src 1.4.1.3 → 1.6.2.0

data/lib/typescript-src/support/typescript/lib/lib.scriptHost.d.ts

@@ -0,0 +1,294 @@
+/*! *****************************************************************************
+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 path="lib.core.d.ts" />
+
+
+/////////////////////////////
+/// Windows Script Host APIS
+/////////////////////////////
+
+
+interface ActiveXObject {
+    new (s: string): any;
+}
+declare var ActiveXObject: ActiveXObject;
+
+interface ITextWriter {
+    Write(s: string): void;
+    WriteLine(s: string): void;
+    Close(): void;
+}
+
+interface TextStreamBase {
+    /**
+     * The column number of the current character position in an input stream.
+     */
+    Column: number;
+
+    /**
+     * The current line number in an input stream.
+     */
+    Line: number;
+
+    /**
+     * Closes a text stream.
+     * It is not necessary to close standard streams; they close automatically when the process ends. If 
+     * you close a standard stream, be aware that any other pointers to that standard stream become invalid.
+     */
+    Close(): void;
+}
+
+interface TextStreamWriter extends TextStreamBase {
+    /**
+     * Sends a string to an output stream.
+     */
+    Write(s: string): void;
+
+    /**
+     * Sends a specified number of blank lines (newline characters) to an output stream.
+     */
+    WriteBlankLines(intLines: number): void;
+
+    /**
+     * Sends a string followed by a newline character to an output stream.
+     */
+    WriteLine(s: string): void;
+}
+
+interface TextStreamReader extends TextStreamBase {
+    /**
+     * Returns a specified number of characters from an input stream, starting at the current pointer position.
+     * Does not return until the ENTER key is pressed.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    Read(characters: number): string;
+
+    /**
+     * Returns all characters from an input stream.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    ReadAll(): string;
+
+    /**
+     * Returns an entire line from an input stream.
+     * Although this method extracts the newline character, it does not add it to the returned string.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    ReadLine(): string;
+
+    /**
+     * Skips a specified number of characters when reading from an input text stream.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     * @param characters Positive number of characters to skip forward. (Backward skipping is not supported.)
+     */
+    Skip(characters: number): void;
+
+    /**
+     * Skips the next line when reading from an input text stream.
+     * Can only be used on a stream in reading mode, not writing or appending mode.
+     */
+    SkipLine(): void;
+
+    /**
+     * Indicates whether the stream pointer position is at the end of a line.
+     */
+    AtEndOfLine: boolean;
+
+    /**
+     * Indicates whether the stream pointer position is at the end of a stream.
+     */
+    AtEndOfStream: boolean;
+}
+
+declare var WScript: {
+    /**
+    * Outputs text to either a message box (under WScript.exe) or the command console window followed by
+    * a newline (under CScript.exe).
+    */
+    Echo(s: any): void;
+
+    /**
+     * Exposes the write-only error output stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdErr: TextStreamWriter;
+
+    /**
+     * Exposes the write-only output stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdOut: TextStreamWriter;
+    Arguments: { length: number; Item(n: number): string; };
+
+    /**
+     *  The full path of the currently running script.
+     */
+    ScriptFullName: string;
+
+    /**
+     * Forces the script to stop immediately, with an optional exit code.
+     */
+    Quit(exitCode?: number): number;
+
+    /**
+     * The Windows Script Host build version number.
+     */
+    BuildVersion: number;
+
+    /**
+     * Fully qualified path of the host executable.
+     */
+    FullName: string;
+
+    /**
+     * Gets/sets the script mode - interactive(true) or batch(false).
+     */
+    Interactive: boolean;
+
+    /**
+     * The name of the host executable (WScript.exe or CScript.exe).
+     */
+    Name: string;
+
+    /**
+     * Path of the directory containing the host executable.
+     */
+    Path: string;
+
+    /**
+     * The filename of the currently running script.
+     */
+    ScriptName: string;
+
+    /**
+     * Exposes the read-only input stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdIn: TextStreamReader;
+
+    /**
+     * Windows Script Host version
+     */
+    Version: string;
+
+    /**
+     * Connects a COM object's event sources to functions named with a given prefix, in the form prefix_event.
+     */
+    ConnectObject(objEventSource: any, strPrefix: string): void;
+
+    /**
+     * Creates a COM object.
+     * @param strProgiID
+     * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
+     */
+    CreateObject(strProgID: string, strPrefix?: string): any;
+
+    /**
+     * Disconnects a COM object from its event sources.
+     */
+    DisconnectObject(obj: any): void;
+
+    /**
+     * Retrieves an existing object with the specified ProgID from memory, or creates a new one from a file.
+     * @param strPathname Fully qualified path to the file containing the object persisted to disk.
+     *                       For objects in memory, pass a zero-length string.
+     * @param strProgID
+     * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
+     */
+    GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any;
+
+    /**
+     * Suspends script execution for a specified length of time, then continues execution.
+     * @param intTime Interval (in milliseconds) to suspend script execution.
+     */
+    Sleep(intTime: number): void;
+};
+
+/**
+ * Allows enumerating over a COM collection, which may not have indexed item access.
+ */
+interface Enumerator<T> {
+    /**
+     * Returns true if the current item is the last one in the collection, or the collection is empty,
+     * or the current item is undefined.
+     */
+    atEnd(): boolean;
+
+    /**
+     * Returns the current item in the collection
+     */
+    item(): T;
+
+    /**
+     * Resets the current item in the collection to the first item. If there are no items in the collection,
+     * the current item is set to undefined.
+     */
+    moveFirst(): void;
+
+    /**
+     * Moves the current item to the next item in the collection. If the enumerator is at the end of
+     * the collection or the collection is empty, the current item is set to undefined.
+     */
+    moveNext(): void;
+}
+
+interface EnumeratorConstructor {
+    new <T>(collection: any): Enumerator<T>;
+    new (collection: any): Enumerator<any>;
+}
+
+declare var Enumerator: EnumeratorConstructor;
+
+/**
+ * Enables reading from a COM safe array, which might have an alternate lower bound, or multiple dimensions.
+ */
+interface VBArray<T> {
+    /**
+     * Returns the number of dimensions (1-based).
+     */
+    dimensions(): number;
+
+    /**
+     * Takes an index for each dimension in the array, and returns the item at the corresponding location.
+     */
+    getItem(dimension1Index: number, ...dimensionNIndexes: number[]): T;
+
+    /**
+     * Returns the smallest available index for a given dimension.
+     * @param dimension 1-based dimension (defaults to 1)
+     */
+    lbound(dimension?: number): number;
+
+    /**
+     * Returns the largest available index for a given dimension.
+     * @param dimension 1-based dimension (defaults to 1)
+     */
+    ubound(dimension?: number): number;
+
+    /**
+     * Returns a Javascript array with all the elements in the VBArray. If there are multiple dimensions,
+     * each successive dimension is appended to the end of the array.
+     * Example: [[1,2,3],[4,5,6]] becomes [1,2,3,4,5,6]
+     */
+    toArray(): T[];
+}
+
+interface VBArrayConstructor {
+    new <T>(safeArray: any): VBArray<T>;
+    new (safeArray: any): VBArray<any>;
+}
+
+declare var VBArray: VBArrayConstructor;

data/lib/typescript-src/support/typescript/lib/lib.webworker.d.ts

@@ -0,0 +1,1202 @@
+/*! *****************************************************************************
+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 path="lib.core.d.ts" />
+/////////////////////////////
+/// ECMAScript Internationalization API 
+/////////////////////////////
+
+declare module Intl {
+    interface CollatorOptions {
+        usage?: string;
+        localeMatcher?: string;
+        numeric?: boolean;
+        caseFirst?: string;
+        sensitivity?: string;
+        ignorePunctuation?: boolean;
+    }
+
+    interface ResolvedCollatorOptions {
+        locale: string;
+        usage: string;
+        sensitivity: string;
+        ignorePunctuation: boolean;
+        collation: string;
+        caseFirst: string;
+        numeric: boolean;
+    }
+
+    interface Collator {
+        compare(x: string, y: string): number;
+        resolvedOptions(): ResolvedCollatorOptions;
+    }
+    var Collator: {
+        new (locales?: string[], options?: CollatorOptions): Collator;
+        new (locale?: string, options?: CollatorOptions): Collator;
+        (locales?: string[], options?: CollatorOptions): Collator;
+        (locale?: string, options?: CollatorOptions): Collator;
+        supportedLocalesOf(locales: string[], options?: CollatorOptions): string[];
+        supportedLocalesOf(locale: string, options?: CollatorOptions): string[];
+    }
+
+    interface NumberFormatOptions {
+        localeMatcher?: string;
+        style?: string;
+        currency?: string;
+        currencyDisplay?: string;
+        useGrouping?: boolean;
+        minimumintegerDigits?: number;
+        minimumFractionDigits?: number;
+        maximumFractionDigits?: number;
+        minimumSignificantDigits?: number;
+        maximumSignificantDigits?: number;
+    }
+
+    interface ResolvedNumberFormatOptions {
+        locale: string;
+        numberingSystem: string;
+        style: string;
+        currency?: string;
+        currencyDisplay?: string;
+        minimumintegerDigits: number;
+        minimumFractionDigits: number;
+        maximumFractionDigits: number;
+        minimumSignificantDigits?: number;
+        maximumSignificantDigits?: number;
+        useGrouping: boolean;
+    }
+
+    interface NumberFormat {
+        format(value: number): string;
+        resolvedOptions(): ResolvedNumberFormatOptions;
+    }
+    var NumberFormat: {
+        new (locales?: string[], options?: NumberFormatOptions): NumberFormat;
+        new (locale?: string, options?: NumberFormatOptions): NumberFormat;
+        (locales?: string[], options?: NumberFormatOptions): NumberFormat;
+        (locale?: string, options?: NumberFormatOptions): NumberFormat;
+        supportedLocalesOf(locales: string[], options?: NumberFormatOptions): string[];
+        supportedLocalesOf(locale: string, options?: NumberFormatOptions): string[];
+    }
+
+    interface DateTimeFormatOptions {
+        localeMatcher?: string;
+        weekday?: string;
+        era?: string;
+        year?: string;
+        month?: string;
+        day?: string;
+        hour?: string;
+        minute?: string;
+        second?: string;
+        timeZoneName?: string;
+        formatMatcher?: string;
+        hour12?: boolean;
+        timeZone?: string;
+    }
+
+    interface ResolvedDateTimeFormatOptions {
+        locale: string;
+        calendar: string;
+        numberingSystem: string;
+        timeZone: string;
+        hour12?: boolean;
+        weekday?: string;
+        era?: string;
+        year?: string;
+        month?: string;
+        day?: string;
+        hour?: string;
+        minute?: string;
+        second?: string;
+        timeZoneName?: string;
+    }
+
+    interface DateTimeFormat {
+        format(date?: Date | number): string;
+        resolvedOptions(): ResolvedDateTimeFormatOptions;
+    }
+    var DateTimeFormat: {
+        new (locales?: string[], options?: DateTimeFormatOptions): DateTimeFormat;
+        new (locale?: string, options?: DateTimeFormatOptions): DateTimeFormat;
+        (locales?: string[], options?: DateTimeFormatOptions): DateTimeFormat;
+        (locale?: string, options?: DateTimeFormatOptions): DateTimeFormat;
+        supportedLocalesOf(locales: string[], options?: DateTimeFormatOptions): string[];
+        supportedLocalesOf(locale: string, options?: DateTimeFormatOptions): string[];
+    }
+}
+
+interface String {
+    /**
+      * Determines whether two strings are equivalent in the current locale.
+      * @param that String to compare to target string
+      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used. This parameter must conform to BCP 47 standards; see the Intl.Collator object for details.
+      * @param options An object that contains one or more properties that specify comparison options. see the Intl.Collator object for details.
+      */
+    localeCompare(that: string, locales: string[], options?: Intl.CollatorOptions): number;
+
+    /**
+      * Determines whether two strings are equivalent in the current locale.
+      * @param that String to compare to target string
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used. This parameter must conform to BCP 47 standards; see the Intl.Collator object for details.
+      * @param options An object that contains one or more properties that specify comparison options. see the Intl.Collator object for details.
+      */
+    localeCompare(that: string, locale: string, options?: Intl.CollatorOptions): number;
+}
+
+interface Number {
+    /**
+      * Converts a number to a string by using the current or specified locale. 
+      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleString(locales?: string[], options?: Intl.NumberFormatOptions): string;
+
+    /**
+      * Converts a number to a string by using the current or specified locale. 
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleString(locale?: string, options?: Intl.NumberFormatOptions): string;
+}
+
+interface Date {
+    /**
+      * Converts a date and time to a string by using the current or specified locale.  
+      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
+    /**
+      * Converts a date to a string by using the current or specified locale.  
+      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleDateString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
+
+    /**
+      * Converts a time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleTimeString(locale?: string[], options?: Intl.DateTimeFormatOptions): string;
+    
+    /**
+      * Converts a date and time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    
+    /**
+      * Converts a date to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleDateString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+
+    /**
+      * Converts a time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleTimeString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+}
+
+
+/////////////////////////////
+/// IE Worker APIs
+/////////////////////////////
+
+interface EventInit {
+    bubbles?: boolean;
+    cancelable?: boolean;
+}
+
+interface EventListener {
+    (evt: Event): void;
+}
+
+interface AudioBuffer {
+    duration: number;
+    length: number;
+    numberOfChannels: number;
+    sampleRate: number;
+    getChannelData(channel: number): any;
+}
+
+declare var AudioBuffer: {
+    prototype: AudioBuffer;
+    new(): AudioBuffer;
+}
+
+interface Blob {
+    size: number;
+    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 {
+    code: number;
+    reason: string;
+    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;
+    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;
+    time(timerName?: string): void;
+    timeEnd(timerName?: string): void;
+    trace(): void;
+    warn(message?: any, ...optionalParams: any[]): void;
+}
+
+declare var Console: {
+    prototype: Console;
+    new(): Console;
+}
+
+interface Coordinates {
+    accuracy: number;
+    altitude: number;
+    altitudeAccuracy: number;
+    heading: number;
+    latitude: number;
+    longitude: number;
+    speed: number;
+}
+
+declare var Coordinates: {
+    prototype: Coordinates;
+    new(): Coordinates;
+}
+
+interface DOMError {
+    name: string;
+    toString(): string;
+}
+
+declare var DOMError: {
+    prototype: DOMError;
+    new(): DOMError;
+}
+
+interface DOMException {
+    code: number;
+    message: string;
+    name: string;
+    toString(): string;
+    ABORT_ERR: number;
+    DATA_CLONE_ERR: number;
+    DOMSTRING_SIZE_ERR: number;
+    HIERARCHY_REQUEST_ERR: number;
+    INDEX_SIZE_ERR: number;
+    INUSE_ATTRIBUTE_ERR: number;
+    INVALID_ACCESS_ERR: number;
+    INVALID_CHARACTER_ERR: number;
+    INVALID_MODIFICATION_ERR: number;
+    INVALID_NODE_TYPE_ERR: number;
+    INVALID_STATE_ERR: number;
+    NAMESPACE_ERR: number;
+    NETWORK_ERR: number;
+    NOT_FOUND_ERR: number;
+    NOT_SUPPORTED_ERR: number;
+    NO_DATA_ALLOWED_ERR: number;
+    NO_MODIFICATION_ALLOWED_ERR: number;
+    PARSE_ERR: number;
+    QUOTA_EXCEEDED_ERR: number;
+    SECURITY_ERR: number;
+    SERIALIZE_ERR: number;
+    SYNTAX_ERR: number;
+    TIMEOUT_ERR: number;
+    TYPE_MISMATCH_ERR: number;
+    URL_MISMATCH_ERR: number;
+    VALIDATION_ERR: number;
+    WRONG_DOCUMENT_ERR: number;
+}
+
+declare var DOMException: {
+    prototype: DOMException;
+    new(): DOMException;
+    ABORT_ERR: number;
+    DATA_CLONE_ERR: number;
+    DOMSTRING_SIZE_ERR: number;
+    HIERARCHY_REQUEST_ERR: number;
+    INDEX_SIZE_ERR: number;
+    INUSE_ATTRIBUTE_ERR: number;
+    INVALID_ACCESS_ERR: number;
+    INVALID_CHARACTER_ERR: number;
+    INVALID_MODIFICATION_ERR: number;
+    INVALID_NODE_TYPE_ERR: number;
+    INVALID_STATE_ERR: number;
+    NAMESPACE_ERR: number;
+    NETWORK_ERR: number;
+    NOT_FOUND_ERR: number;
+    NOT_SUPPORTED_ERR: number;
+    NO_DATA_ALLOWED_ERR: number;
+    NO_MODIFICATION_ALLOWED_ERR: number;
+    PARSE_ERR: number;
+    QUOTA_EXCEEDED_ERR: number;
+    SECURITY_ERR: number;
+    SERIALIZE_ERR: number;
+    SYNTAX_ERR: number;
+    TIMEOUT_ERR: number;
+    TYPE_MISMATCH_ERR: number;
+    URL_MISMATCH_ERR: number;
+    VALIDATION_ERR: number;
+    WRONG_DOCUMENT_ERR: number;
+}
+
+interface DOMStringList {
+    length: number;
+    contains(str: string): boolean;
+    item(index: number): string;
+    [index: number]: string;
+}
+
+declare var DOMStringList: {
+    prototype: DOMStringList;
+    new(): DOMStringList;
+}
+
+interface ErrorEvent extends Event {
+    colno: number;
+    error: any;
+    filename: string;
+    lineno: number;
+    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 {
+    bubbles: boolean;
+    cancelBubble: boolean;
+    cancelable: boolean;
+    currentTarget: EventTarget;
+    defaultPrevented: boolean;
+    eventPhase: number;
+    isTrusted: boolean;
+    returnValue: boolean;
+    srcElement: any;
+    target: EventTarget;
+    timeStamp: number;
+    type: string;
+    initEvent(eventTypeArg: string, canBubbleArg: boolean, cancelableArg: boolean): void;
+    preventDefault(): void;
+    stopImmediatePropagation(): void;
+    stopPropagation(): void;
+    AT_TARGET: number;
+    BUBBLING_PHASE: number;
+    CAPTURING_PHASE: number;
+}
+
+declare var Event: {
+    prototype: Event;
+    new(type: string, eventInitDict?: EventInit): Event;
+    AT_TARGET: number;
+    BUBBLING_PHASE: number;
+    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 {
+    lastModifiedDate: any;
+    name: string;
+}
+
+declare var File: {
+    prototype: File;
+    new (parts: (ArrayBuffer | ArrayBufferView | Blob | string)[], filename: string, properties?: FilePropertyBag): File;
+}
+
+interface FileList {
+    length: number;
+    item(index: number): File;
+    [index: number]: File;
+}
+
+declare var FileList: {
+    prototype: FileList;
+    new(): FileList;
+}
+
+interface FileReader extends EventTarget, MSBaseReader {
+    error: DOMError;
+    readAsArrayBuffer(blob: Blob): void;
+    readAsBinaryString(blob: Blob): void;
+    readAsDataURL(blob: Blob): void;
+    readAsText(blob: Blob, encoding?: string): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var FileReader: {
+    prototype: FileReader;
+    new(): FileReader;
+}
+
+interface IDBCursor {
+    direction: string;
+    key: any;
+    primaryKey: any;
+    source: any;
+    advance(count: number): void;
+    continue(key?: any): void;
+    delete(): IDBRequest;
+    update(value: any): IDBRequest;
+    NEXT: string;
+    NEXT_NO_DUPLICATE: string;
+    PREV: string;
+    PREV_NO_DUPLICATE: string;
+}
+
+declare var IDBCursor: {
+    prototype: IDBCursor;
+    new(): IDBCursor;
+    NEXT: string;
+    NEXT_NO_DUPLICATE: string;
+    PREV: string;
+    PREV_NO_DUPLICATE: string;
+}
+
+interface IDBCursorWithValue extends IDBCursor {
+    value: any;
+}
+
+declare var IDBCursorWithValue: {
+    prototype: IDBCursorWithValue;
+    new(): IDBCursorWithValue;
+}
+
+interface IDBDatabase extends EventTarget {
+    name: string;
+    objectStoreNames: DOMStringList;
+    onabort: (ev: Event) => any;
+    onerror: (ev: Event) => any;
+    version: string;
+    close(): void;
+    createObjectStore(name: string, optionalParameters?: any): IDBObjectStore;
+    deleteObjectStore(name: string): void;
+    transaction(storeNames: any, mode?: string): IDBTransaction;
+    addEventListener(type: "abort", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => 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;
+    name: string;
+    objectStore: IDBObjectStore;
+    unique: boolean;
+    count(key?: any): IDBRequest;
+    get(key: any): IDBRequest;
+    getKey(key: any): IDBRequest;
+    openCursor(range?: IDBKeyRange, direction?: string): IDBRequest;
+    openKeyCursor(range?: IDBKeyRange, direction?: string): IDBRequest;
+}
+
+declare var IDBIndex: {
+    prototype: IDBIndex;
+    new(): IDBIndex;
+}
+
+interface IDBKeyRange {
+    lower: any;
+    lowerOpen: boolean;
+    upper: any;
+    upperOpen: boolean;
+}
+
+declare var IDBKeyRange: {
+    prototype: IDBKeyRange;
+    new(): IDBKeyRange;
+    bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
+    lowerBound(bound: any, open?: boolean): IDBKeyRange;
+    only(value: any): IDBKeyRange;
+    upperBound(bound: any, open?: boolean): IDBKeyRange;
+}
+
+interface IDBObjectStore {
+    indexNames: DOMStringList;
+    keyPath: string;
+    name: string;
+    transaction: IDBTransaction;
+    add(value: any, key?: any): IDBRequest;
+    clear(): IDBRequest;
+    count(key?: any): IDBRequest;
+    createIndex(name: string, keyPath: string, optionalParameters?: any): IDBIndex;
+    delete(key: any): IDBRequest;
+    deleteIndex(indexName: string): void;
+    get(key: any): IDBRequest;
+    index(name: string): IDBIndex;
+    openCursor(range?: any, direction?: string): IDBRequest;
+    put(value: any, key?: any): IDBRequest;
+}
+
+declare var IDBObjectStore: {
+    prototype: IDBObjectStore;
+    new(): IDBObjectStore;
+}
+
+interface IDBOpenDBRequest extends IDBRequest {
+    onblocked: (ev: Event) => any;
+    onupgradeneeded: (ev: IDBVersionChangeEvent) => any;
+    addEventListener(type: "blocked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "success", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "upgradeneeded", listener: (ev: IDBVersionChangeEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var IDBOpenDBRequest: {
+    prototype: IDBOpenDBRequest;
+    new(): IDBOpenDBRequest;
+}
+
+interface IDBRequest extends EventTarget {
+    error: DOMError;
+    onerror: (ev: Event) => any;
+    onsuccess: (ev: Event) => any;
+    readyState: string;
+    result: any;
+    source: any;
+    transaction: IDBTransaction;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "success", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var IDBRequest: {
+    prototype: IDBRequest;
+    new(): IDBRequest;
+}
+
+interface IDBTransaction extends EventTarget {
+    db: IDBDatabase;
+    error: DOMError;
+    mode: string;
+    onabort: (ev: Event) => any;
+    oncomplete: (ev: Event) => any;
+    onerror: (ev: Event) => any;
+    abort(): void;
+    objectStore(name: string): IDBObjectStore;
+    READ_ONLY: string;
+    READ_WRITE: string;
+    VERSION_CHANGE: string;
+    addEventListener(type: "abort", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "complete", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var IDBTransaction: {
+    prototype: IDBTransaction;
+    new(): IDBTransaction;
+    READ_ONLY: string;
+    READ_WRITE: string;
+    VERSION_CHANGE: string;
+}
+
+interface IDBVersionChangeEvent extends Event {
+    newVersion: number;
+    oldVersion: number;
+}
+
+declare var IDBVersionChangeEvent: {
+    prototype: IDBVersionChangeEvent;
+    new(): IDBVersionChangeEvent;
+}
+
+interface ImageData {
+    data: number[];
+    height: number;
+    width: number;
+}
+
+interface ImageDataConstructor {
+    prototype: ImageData;
+    new(width: number, height: number): ImageData;
+    new(array: Uint8ClampedArray, width: number, height: number): ImageData;
+}
+
+declare var ImageData: ImageDataConstructor; 
+
+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): any;
+    getViewId(view: any): any;
+    isTaskScheduledAtPriorityOrHigher(priority: string): boolean;
+    pageHandlesAllApplicationActivations(enabled: boolean): void;
+    suppressSubdownloadCredentialPrompts(suppress: boolean): void;
+    terminateApp(exceptionObject: any): void;
+    CURRENT: string;
+    HIGH: string;
+    IDLE: string;
+    NORMAL: string;
+}
+declare var MSApp: MSApp;
+
+interface MSAppAsyncOperation extends EventTarget {
+    error: DOMError;
+    oncomplete: (ev: Event) => any;
+    onerror: (ev: Event) => any;
+    readyState: number;
+    result: any;
+    start(): void;
+    COMPLETED: number;
+    ERROR: number;
+    STARTED: number;
+    addEventListener(type: "complete", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var MSAppAsyncOperation: {
+    prototype: MSAppAsyncOperation;
+    new(): MSAppAsyncOperation;
+    COMPLETED: number;
+    ERROR: number;
+    STARTED: number;
+}
+
+interface MSBlobBuilder {
+    append(data: any, endings?: string): void;
+    getBlob(contentType?: string): Blob;
+}
+
+declare var MSBlobBuilder: {
+    prototype: MSBlobBuilder;
+    new(): MSBlobBuilder;
+}
+
+interface MSStream {
+    type: string;
+    msClose(): void;
+    msDetachStream(): any;
+}
+
+declare var MSStream: {
+    prototype: MSStream;
+    new(): MSStream;
+}
+
+interface MSStreamReader extends EventTarget, MSBaseReader {
+    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(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var MSStreamReader: {
+    prototype: MSStreamReader;
+    new(): MSStreamReader;
+}
+
+interface MediaQueryList {
+    matches: boolean;
+    media: string;
+    addListener(listener: MediaQueryListListener): void;
+    removeListener(listener: MediaQueryListListener): void;
+}
+
+declare var MediaQueryList: {
+    prototype: MediaQueryList;
+    new(): MediaQueryList;
+}
+
+interface MessageChannel {
+    port1: MessagePort;
+    port2: MessagePort;
+}
+
+declare var MessageChannel: {
+    prototype: MessageChannel;
+    new(): MessageChannel;
+}
+
+interface MessageEvent extends Event {
+    data: any;
+    origin: string;
+    ports: any;
+    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 MessagePort extends EventTarget {
+    onmessage: (ev: MessageEvent) => any;
+    close(): void;
+    postMessage(message?: any, ports?: any): void;
+    start(): void;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var MessagePort: {
+    prototype: MessagePort;
+    new(): MessagePort;
+}
+
+interface Position {
+    coords: Coordinates;
+    timestamp: number;
+}
+
+declare var Position: {
+    prototype: Position;
+    new(): Position;
+}
+
+interface PositionError {
+    code: number;
+    message: string;
+    toString(): string;
+    PERMISSION_DENIED: number;
+    POSITION_UNAVAILABLE: number;
+    TIMEOUT: number;
+}
+
+declare var PositionError: {
+    prototype: PositionError;
+    new(): PositionError;
+    PERMISSION_DENIED: number;
+    POSITION_UNAVAILABLE: number;
+    TIMEOUT: number;
+}
+
+interface ProgressEvent extends Event {
+    lengthComputable: boolean;
+    loaded: number;
+    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 WebSocket extends EventTarget {
+    binaryType: string;
+    bufferedAmount: number;
+    extensions: string;
+    onclose: (ev: CloseEvent) => any;
+    onerror: (ev: Event) => any;
+    onmessage: (ev: MessageEvent) => any;
+    onopen: (ev: Event) => any;
+    protocol: string;
+    readyState: number;
+    url: string;
+    close(code?: number, reason?: string): void;
+    send(data: any): void;
+    CLOSED: number;
+    CLOSING: number;
+    CONNECTING: number;
+    OPEN: number;
+    addEventListener(type: "close", listener: (ev: CloseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "open", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var WebSocket: {
+    prototype: WebSocket;
+    new(url: string, protocols?: string | string[]): WebSocket;
+    CLOSED: number;
+    CLOSING: number;
+    CONNECTING: number;
+    OPEN: number;
+}
+
+interface Worker extends EventTarget, AbstractWorker {
+    onmessage: (ev: MessageEvent) => any;
+    postMessage(message: any, ports?: any): void;
+    terminate(): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var Worker: {
+    prototype: Worker;
+    new(stringUrl: string): Worker;
+}
+
+interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget {
+    msCaching: string;
+    onreadystatechange: (ev: ProgressEvent) => any;
+    readyState: number;
+    response: any;
+    responseBody: any;
+    responseText: string;
+    responseType: string;
+    responseXML: any;
+    status: number;
+    statusText: string;
+    timeout: number;
+    upload: XMLHttpRequestUpload;
+    withCredentials: boolean;
+    abort(): void;
+    getAllResponseHeaders(): string;
+    getResponseHeader(header: string): string;
+    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;
+    DONE: number;
+    HEADERS_RECEIVED: number;
+    LOADING: number;
+    OPENED: number;
+    UNSENT: number;
+    addEventListener(type: "abort", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadend", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeout", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var XMLHttpRequest: {
+    prototype: XMLHttpRequest;
+    new(): XMLHttpRequest;
+    DONE: number;
+    HEADERS_RECEIVED: number;
+    LOADING: number;
+    OPENED: number;
+    UNSENT: number;
+    create(): XMLHttpRequest;
+}
+
+interface XMLHttpRequestUpload extends EventTarget, XMLHttpRequestEventTarget {
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var XMLHttpRequestUpload: {
+    prototype: XMLHttpRequestUpload;
+    new(): XMLHttpRequestUpload;
+}
+
+interface AbstractWorker {
+    onerror: (ev: Event) => any;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+interface MSBaseReader {
+    onabort: (ev: Event) => any;
+    onerror: (ev: Event) => any;
+    onload: (ev: Event) => any;
+    onloadend: (ev: ProgressEvent) => any;
+    onloadstart: (ev: Event) => any;
+    onprogress: (ev: ProgressEvent) => any;
+    readyState: number;
+    result: any;
+    abort(): void;
+    DONE: number;
+    EMPTY: number;
+    LOADING: number;
+    addEventListener(type: "abort", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadend", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+interface NavigatorID {
+    appName: string;
+    appVersion: string;
+    platform: string;
+    product: string;
+    productSub: string;
+    userAgent: string;
+    vendor: string;
+    vendorSub: string;
+}
+
+interface NavigatorOnLine {
+    onLine: boolean;
+}
+
+interface WindowBase64 {
+    atob(encodedString: string): string;
+    btoa(rawString: string): string;
+}
+
+interface WindowConsole {
+    console: Console;
+}
+
+interface XMLHttpRequestEventTarget {
+    onabort: (ev: Event) => any;
+    onerror: (ev: Event) => any;
+    onload: (ev: Event) => any;
+    onloadend: (ev: ProgressEvent) => any;
+    onloadstart: (ev: Event) => any;
+    onprogress: (ev: ProgressEvent) => any;
+    ontimeout: (ev: ProgressEvent) => any;
+    addEventListener(type: "abort", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadend", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "timeout", listener: (ev: ProgressEvent) => 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 WorkerGlobalScope extends EventTarget, WorkerUtils, DedicatedWorkerGlobalScope, WindowConsole {
+    location: WorkerLocation;
+    onerror: (ev: Event) => any;
+    self: WorkerGlobalScope;
+    close(): void;
+    msWriteProfilerMark(profilerMarkName: string): void;
+    toString(): string;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var WorkerGlobalScope: {
+    prototype: WorkerGlobalScope;
+    new(): WorkerGlobalScope;
+}
+
+interface WorkerLocation {
+    hash: string;
+    host: string;
+    hostname: string;
+    href: string;
+    pathname: string;
+    port: string;
+    protocol: string;
+    search: string;
+    toString(): string;
+}
+
+declare var WorkerLocation: {
+    prototype: WorkerLocation;
+    new(): WorkerLocation;
+}
+
+interface WorkerNavigator extends Object, NavigatorID, NavigatorOnLine {
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+declare var WorkerNavigator: {
+    prototype: WorkerNavigator;
+    new(): WorkerNavigator;
+}
+
+interface DedicatedWorkerGlobalScope {
+    onmessage: (ev: MessageEvent) => any;
+    postMessage(data: any): void;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+}
+
+interface WorkerUtils extends Object, WindowBase64 {
+    indexedDB: IDBFactory;
+    msIndexedDB: IDBFactory;
+    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 BlobPropertyBag {
+    type?: string;
+    endings?: string;
+}
+
+interface FilePropertyBag {
+    type?: string;
+    lastModified?: number;
+}
+
+interface EventListenerObject {
+    handleEvent(evt: Event): void;
+}
+
+declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
+
+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 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 {
+    (): void;
+}
+interface FunctionStringCallback {
+    (data: string): void;
+}
+declare var location: WorkerLocation;
+declare var onerror: (ev: Event) => any;
+declare var self: WorkerGlobalScope;
+declare function close(): void;
+declare function msWriteProfilerMark(profilerMarkName: string): void;
+declare function toString(): string;
+declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
+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: 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 onmessage: (ev: MessageEvent) => any;
+declare function postMessage(data: any): void;
+declare var console: Console;
+declare function addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
+declare function addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;