/* *****************************************************************************

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"/>

/////////////////////////////

/// ECMAScript APIs

/////////////////////////////

declare var NaN: number;

declare var Infinity: number;

declare function eval(x: string): any;

declare function parseInt(s: string, radix?: number): number;

declare function parseFloat(string: string): number;

declare function isNaN(number: number): boolean;

declare function isFinite(number: number): boolean;

declare function decodeURI(encodedURI: string): string;

declare function decodeURIComponent(encodedURIComponent: string): string;

declare function encodeURI(uri: string): string;

declare function encodeURIComponent(uriComponent: string): string;

interface PropertyDescriptor {

configurable?: boolean;

enumerable?: boolean;

value?: any;

writable?: boolean;

get? (): any;

set? (v: any): void;

}

interface PropertyDescriptorMap {

[s: string]: PropertyDescriptor;

}

interface Object {

toString(): string;

toLocaleString(): string;

valueOf(): Object;

hasOwnProperty(v: string): boolean;

isPrototypeOf(v: Object): boolean;

propertyIsEnumerable(v: string): boolean;

[s: string]: any;

}

declare var Object: {

new (value?: any): Object;

(): any;

(value: any): any;

prototype: Object;

getPrototypeOf(o: any): any;

getOwnPropertyDescriptor(o: any, p: string): PropertyDescriptor;

getOwnPropertyNames(o: any): string[];

create(o: any, properties?: PropertyDescriptorMap): any;

defineProperty(o: any, p: string, attributes: PropertyDescriptor): any;

defineProperties(o: any, properties: PropertyDescriptorMap): any;

seal(o: any): any;

freeze(o: any): any;

preventExtensions(o: any): any;

isSealed(o: any): boolean;

isFrozen(o: any): boolean;

isExtensible(o: any): boolean;

keys(o: any): string[];

}

interface Function {

apply(thisArg: any, argArray?: any): any;

call(thisArg: any, ...argArray: any[]): any;

bind(thisArg: any, ...argArray: any[]): any;

prototype: any;

length: number;

// Non-standard extensions

arguments: any;

caller: Function;

}

declare var Function: {

new (...args: string[]): Function;

(...args: string[]): Function;

prototype: Function;

}

interface IArguments {

[index: number]: any;

length: number;

callee: Function;

}

interface String {

toString(): string;

charAt(pos: number): string;

charCodeAt(index: number): number;

concat(...strings: string[]): string;

indexOf(searchString: string, position?: number): number;

lastIndexOf(searchString: string, position?: number): number;

localeCompare(that: string): number;

match(regexp: string): string[];

match(regexp: RegExp): string[];

replace(searchValue: string, replaceValue: string): string;

replace(searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string;

replace(searchValue: RegExp, replaceValue: string): string;

replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string;

search(regexp: string): number;

search(regexp: RegExp): number;

slice(start: number, end?: number): string;

split(separator: string, limit?: number): string[];

split(separator: RegExp, limit?: number): string[];

substring(start: number, end?: number): string;

toLowerCase(): string;

toLocaleLowerCase(): string;

toUpperCase(): string;

toLocaleUpperCase(): string;

trim(): string;

length: number;

substr(from: number, length?: number): string;

}

declare var String: {

new (value?: any): String;

(value?: any): string;

prototype: String;

fromCharCode(...codes: number[]): string;

}

interface Boolean {

}

declare var Boolean: {

new (value?: any): Boolean;

(value?: any): boolean;

prototype: Boolean;

}

interface Number {

toString(radix?: number): string;

toFixed(fractionDigits?: number): string;

toExponential(fractionDigits?: number): string;

toPrecision(precision: number): string;

}

declare var Number: {

new (value?: any): Number;

(value?: any): number;

prototype: Number;

MAX_VALUE: number;

MIN_VALUE: number;

NaN: number;

NEGATIVE_INFINITY: number;

POSITIVE_INFINITY: number;

}

interface Math {

E: number;

LN10: number;

LN2: number;

LOG2E: number;

LOG10E: number;

PI: number;

SQRT1_2: number;

SQRT2: number;

abs(x: number): number;

acos(x: number): number;

asin(x: number): number;

atan(x: number): number;

atan2(y: number, x: number): number;

ceil(x: number): number;

cos(x: number): number;

exp(x: number): number;

floor(x: number): number;

log(x: number): number;

max(...values: number[]): number;

min(...values: number[]): number;

pow(x: number, y: number): number;

random(): number;

round(x: number): number;

sin(x: number): number;

sqrt(x: number): number;

tan(x: number): number;

}

declare var Math: Math;

interface Date {

toString(): string;

toDateString(): string;

toTimeString(): string;

toLocaleString(): string;

toLocaleDateString(): string;

toLocaleTimeString(): string;

valueOf(): number;

getTime(): number;

getFullYear(): number;

getUTCFullYear(): number;

getMonth(): number;

getUTCMonth(): number;

getDate(): number;

getUTCDate(): number;

getDay(): number;

getUTCDay(): number;

getHours(): number;

getUTCHours(): number;

getMinutes(): number;

getUTCMinutes(): number;

getSeconds(): number;

getUTCSeconds(): number;

getMilliseconds(): number;

getUTCMilliseconds(): number;

getTimezoneOffset(): number;

setTime(time: number): void;

setMilliseconds(ms: number): void;

setUTCMilliseconds(ms: number): void;

setSeconds(sec: number, ms?: number): void;

setUTCSeconds(sec: number, ms?: number): void;

setMinutes(min: number, sec?: number, ms?: number): void;

setUTCMinutes(min: number, sec?: number, ms?: number): void;

setHours(hours: number, min?: number, sec?: number, ms?: number): void;

setUTCHours(hours: number, min?: number, sec?: number, ms?: number): void;

setDate(date: number): void;

setUTCDate(date: number): void;

setMonth(month: number, date?: number): void;

setUTCMonth(month: number, date?: number): void;

setFullYear(year: number, month?: number, date?: number): void;

setUTCFullYear(year: number, month?: number, date?: number): void;

toUTCString(): string;

toISOString(): string;

toJSON(key?: any): string;

}

declare var Date: {

new (): Date;

new (value: number): Date;

new (value: string): Date;

new (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Date;

(): string;

prototype: Date;

parse(s: string): number;

UTC(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;

now(): number;

}

interface RegExpExecArray {

[index: number]: string;

length: number;

index: number;

input: string;

toString(): string;

toLocaleString(): string;

concat(...items: string[][]): string[];

join(separator?: string): string;

pop(): string;

push(...items: string[]): number;

reverse(): string[];

shift(): string;

slice(start: number, end?: number): string[];

sort(compareFn?: (a: string, b: string) => number): string[];

splice(start: number): string[];

splice(start: number, deleteCount: number, ...items: string[]): string[];

unshift(...items: string[]): number;

indexOf(searchElement: string, fromIndex?: number): number;

lastIndexOf(searchElement: string, fromIndex?: number): number;

every(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): boolean;

some(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): boolean;

forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void;

map(callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): any[];

filter(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): string[];

reduce(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: string[]) => any, initialValue?: any): any;

reduceRight(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: string[]) => any, initialValue?: any): any;

}

interface RegExp {

exec(string: string): RegExpExecArray;

test(string: string): boolean;

source: string;

global: boolean;

ignoreCase: boolean;

multiline: boolean;

lastIndex: number;

// Non-standard extensions

compile(): RegExp;

}

declare var RegExp: {

new (pattern: string, flags?: string): RegExp;

(pattern: string, flags?: string): RegExp;

// Non-standard extensions

$1: string;

$2: string;

$3: string;

$4: string;

$5: string;

$6: string;

$7: string;

$8: string;

$9: string;

lastMatch: string;

}

interface Error {

name: string;

message: string;

}

declare var Error: {

new (message?: string): Error;

(message?: string): Error;

prototype: Error;

}

interface EvalError extends Error {

}

declare var EvalError: {

new (message?: string): EvalError;

(message?: string): EvalError;

prototype: EvalError;

}

interface RangeError extends Error {

}

declare var RangeError: {

new (message?: string): RangeError;

(message?: string): RangeError;

prototype: RangeError;

}

interface ReferenceError extends Error {

}

declare var ReferenceError: {

new (message?: string): ReferenceError;

(message?: string): ReferenceError;

prototype: ReferenceError;

}

interface SyntaxError extends Error {

}

declare var SyntaxError: {

new (message?: string): SyntaxError;

(message?: string): SyntaxError;

prototype: SyntaxError;

}

interface TypeError extends Error {

}

declare var TypeError: {

new (message?: string): TypeError;

(message?: string): TypeError;

prototype: TypeError;

}

interface URIError extends Error {

}

declare var URIError: {

new (message?: string): URIError;

(message?: string): URIError;

prototype: URIError;

}

interface JSON {

parse(text: string, reviver?: (key: any, value: any) => any): any;

stringify(value: any): string;

stringify(value: any, replacer: (key: string, value: any) => any): string;

stringify(value: any, replacer: any[]): string;

stringify(value: any, replacer: (key: string, value: any) => any, space: any): string;

stringify(value: any, replacer: any[], space: any): string;

}

declare var JSON: JSON;

/////////////////////////////

/// ECMAScript Array API (specially handled by compiler)

/////////////////////////////

interface Array<T> {

toString(): string;

toLocaleString(): string;

concat<U extends T[]>(...items: U[]): T[];

concat(...items: T[]): T[];

join(separator?: string): string;

pop(): T;

push(...items: T[]): number;

reverse(): T[];

shift(): T;

slice(start: number, end?: number): T[];

sort(compareFn?: (a: T, b: T) => number): T[];

splice(start: number): T[];

splice(start: number, deleteCount: number, ...items: T[]): T[];

unshift(...items: T[]): number;

indexOf(searchElement: T, fromIndex?: number): number;

lastIndexOf(searchElement: T, fromIndex?: number): number;

every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;

some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;

forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;

map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];

filter(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];

reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;

reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;

reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;

reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;

length: number;

[n: number]: T;

}

declare var Array: {

new <T>(arrayLength: number): T[];

new <T>(...items: T[]): T[];

<T>(arrayLength: number): T[];

<T>(...items: T[]): T[];

isArray(arg: any): boolean;

prototype: Array<any>;

}

/////////////////////////////

/// IE10 ECMAScript Extensions

/////////////////////////////

interface ArrayBuffer {

byteLength: number;

}

declare var ArrayBuffer: {

prototype: ArrayBuffer;

new (byteLength: number): ArrayBuffer;

}

interface ArrayBufferView {

buffer: ArrayBuffer;

byteOffset: number;

byteLength: number;

}

interface Int8Array extends ArrayBufferView {

BYTES_PER_ELEMENT: number;

length: number;

[index: number]: number;

get(index: number): number;

set(index: number, value: number): void;

set(array: Int8Array, offset?: number): void;

set(array: number[], offset?: number): void;

subarray(begin: number, end?: number): Int8Array;

}

declare var Int8Array: {

prototype: Int8Array;

new (length: number): Int8Array;

new (array: Int8Array): Int8Array;

new (array: number[]): Int8Array;

new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int8Array;

BYTES_PER_ELEMENT: number;

}

interface Uint8Array extends ArrayBufferView {

BYTES_PER_ELEMENT: number;

length: number;

[index: number]: number;

get(index: number): number;

set(index: number, value: number): void;

set(array: Uint8Array, offset?: number): void;

set(array: number[], offset?: number): void;

subarray(begin: number, end?: number): Uint8Array;

}

declare var Uint8Array: {

prototype: Uint8Array;

new (length: number): Uint8Array;

new (array: Uint8Array): Uint8Array;

new (array: number[]): Uint8Array;

new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint8Array;

BYTES_PER_ELEMENT: number;

}

interface Int16Array extends ArrayBufferView {

BYTES_PER_ELEMENT: number;

length: number;

[index: number]: number;

get(index: number): number;

set(index: number, value: number): void;

set(array: Int16Array, offset?: number): void;

set(array: number[], offset?: number): void;

subarray(begin: number, end?: number): Int16Array;

}

declare var Int16Array: {

prototype: Int16Array;

new (length: number): Int16Array;

new (array: Int16Array): Int16Array;

new (array: number[]): Int16Array;

new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int16Array;

BYTES_PER_ELEMENT: number;

}

interface Uint16Array extends ArrayBufferView {

BYTES_PER_ELEMENT: number;

length: number;

[index: number]: number;

get(index: number): number;

set(index: number, value: number): void;

set(array: Uint16Array, offset?: number): void;

set(array: number[], offset?: number): void;

subarray(begin: number, end?: number): Uint16Array;

}

declare var Uint16Array: {

prototype: Uint16Array;

new (length: number): Uint16Array;

new (array: Uint16Array): Uint16Array;

new (array: number[]): Uint16Array;

new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint16Array;

BYTES_PER_ELEMENT: number;

}

interface Int32Array extends ArrayBufferView {

BYTES_PER_ELEMENT: number;

length: number;

[index: number]: number;

get(index: number): number;

set(index: number, value: number): void;

set(array: Int32Array, offset?: number): void;

set(array: number[], offset?: number): void;

subarray(begin: number, end?: number): Int32Array;

}

declare var Int32Array: {

prototype: Int32Array;

new (length: number): Int32Array;

new (array: Int32Array): Int32Array;

new (array: number[]): Int32Array;

new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int32Array;

BYTES_PER_ELEMENT: number;

}

interface Uint32Array extends ArrayBufferView {

BYTES_PER_ELEMENT: number;

length: number;

[index: number]: number;

get(index: number): number;

set(index: number, value: number): void;

set(array: Uint32Array, offset?: number): void;

set(array: number[], offset?: number): void;

subarray(begin: number, end?: number): Uint32Array;

}

declare var Uint32Array: {

prototype: Uint32Array;

new (length: number): Uint32Array;

new (array: Uint32Array): Uint32Array;

new (array: number[]): Uint32Array;

new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint32Array;

BYTES_PER_ELEMENT: number;

}

interface Float32Array extends ArrayBufferView {

BYTES_PER_ELEMENT: number;

length: number;

[index: number]: number;

get(index: number): number;

set(index: number, value: number): void;

set(array: Float32Array, offset?: number): void;

set(array: number[], offset?: number): void;

subarray(begin: number, end?: number): Float32Array;

}

declare var Float32Array: {

prototype: Float32Array;

new (length: number): Float32Array;

new (array: Float32Array): Float32Array;

new (array: number[]): Float32Array;

new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Float32Array;

BYTES_PER_ELEMENT: number;

}

interface Float64Array extends ArrayBufferView {

BYTES_PER_ELEMENT: number;

length: number;

[index: number]: number;

get(index: number): number;

set(index: number, value: number): void;

set(array: Float64Array, offset?: number): void;

set(array: number[], offset?: number): void;

subarray(begin: number, end?: number): Float64Array;

}

declare var Float64Array: {

prototype: Float64Array;

new (length: number): Float64Array;

new (array: Float64Array): Float64Array;

new (array: number[]): Float64Array;

new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Float64Array;

BYTES_PER_ELEMENT: number;

}

interface DataView extends ArrayBufferView {

getInt8(byteOffset: number): number;

getUint8(byteOffset: number): number;

getInt16(byteOffset: number, littleEndian?: boolean): number;

getUint16(byteOffset: number, littleEndian?: boolean): number;

getInt32(byteOffset: number, littleEndian?: boolean): number;

getUint32(byteOffset: number, littleEndian?: boolean): number;

getFloat32(byteOffset: number, littleEndian?: boolean): number;

getFloat64(byteOffset: number, littleEndian?: boolean): number;

setInt8(byteOffset: number, value: number): void;

setUint8(byteOffset: number, value: number): void;

setInt16(byteOffset: number, value: number, littleEndian?: boolean): void;

setUint16(byteOffset: number, value: number, littleEndian?: boolean): void;

setInt32(byteOffset: number, value: number, littleEndian?: boolean): void;

setUint32(byteOffset: number, value: number, littleEndian?: boolean): void;

setFloat32(byteOffset: number, value: number, littleEndian?: boolean): void;

setFloat64(byteOffset: number, value: number, littleEndian?: boolean): void;

}

declare var DataView: {

prototype: DataView;

new (buffer: ArrayBuffer, byteOffset?: number, length?: number): DataView;

}

/////////////////////////////

/// IE11 ECMAScript Extensions

/////////////////////////////

interface Map<K, V> {

clear(): void;

delete(key: K): boolean;

forEach(callbackfn: (value: V, index: K, map: Map<K, V>) => void, thisArg?: any): void;

get(key: K): V;

has(key: K): boolean;

set(key: K, value: V): Map<K, V>;

size: number;

}

declare var Map: {

new <K, V>(): Map<K, V>;

}

interface WeakMap<K, V> {

clear(): void;

delete(key: K): boolean;

get(key: K): V;

has(key: K): boolean;

set(key: K, value: V): WeakMap<K, V>;

}

declare var WeakMap: {

new <K, V>(): WeakMap<K, V>;

}

interface Set<T> {

add(value: T): Set<T>;

clear(): void;

delete(value: T): boolean;

forEach(callbackfn: (value: T, index: T, set: Set<T>) => void, thisArg?: any): void;

has(value: T): boolean;

size: number;

}

declare var Set: {

new <T>(): Set<T>;

}

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;

}

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): Collator;

new (locale?: string, options?: NumberFormatOptions): Collator;

(locales?: string[], options?: NumberFormatOptions): Collator;

(locale?: string, options?: NumberFormatOptions): Collator;

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;

}

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: number): string;

resolvedOptions(): ResolvedDateTimeFormatOptions;

}

var DateTimeFormat: {

new (locales?: string[], options?: DateTimeFormatOptions): Collator;

new (locale?: string, options?: DateTimeFormatOptions): Collator;

(locales?: string[], options?: DateTimeFormatOptions): Collator;

(locale?: string, options?: DateTimeFormatOptions): Collator;

supportedLocalesOf(locales: string[], options?: DateTimeFormatOptions): string[];

supportedLocalesOf(locale: string, options?: DateTimeFormatOptions): string[];

}

}

interface String {

localeCompare(that: string, locales: string[], options?: Intl.CollatorOptions): number;

localeCompare(that: string, locale: string, options?: Intl.CollatorOptions): number;

}

interface Numer {

toLocaleString(locales: string[], options?: Intl.NumberFormatOptions): string;

toLocaleString(locale: string, options?: Intl.NumberFormatOptions): string;

}

interface Date {

toLocaleString(locales: string[], options?: Intl.DateTimeFormatOptions): string;

toLocaleString(locale: string, options?: Intl.DateTimeFormatOptions): string;

}

/////////////////////////////

/// IE9 DOM APIs

/////////////////////////////

interface PositionOptions {

enableHighAccuracy?: boolean;

timeout?: number;

maximumAge?: number;

}

interface NavigatorID {

appVersion: string;

appName: string;

userAgent: string;

platform: string;

}

interface HTMLTableElement extends HTMLElement, MSDataBindingTableExtensions, MSDataBindingExtensions, DOML2DeprecatedBackgroundStyle, DOML2DeprecatedBackgroundColorStyle {

width: string;

borderColorLight: any;

cellSpacing: string;

tFoot: HTMLTableSectionElement;

frame: string;

borderColor: any;

rows: HTMLCollection;

rules: string;

cols: number;

summary: string;

caption: HTMLTableCaptionElement;

tBodies: HTMLCollection;

tHead: HTMLTableSectionElement;

align: string;

cells: HTMLCollection;

height: any;

cellPadding: string;

border: string;

borderColorDark: any;

deleteRow(index?: number): void;

createTBody(): HTMLElement;

deleteCaption(): void;

insertRow(index?: number): HTMLElement;

deleteTFoot(): void;

createTHead(): HTMLElement;

deleteTHead(): void;

createCaption(): HTMLElement;

moveRow(indexFrom?: number, indexTo?: number): Object;

createTFoot(): HTMLElement;

}

declare var HTMLTableElement: {

prototype: HTMLTableElement;

new (): HTMLTableElement;

}

interface TreeWalker {

whatToShow: number;

filter: NodeFilter;

root: Node;

currentNode: Node;

expandEntityReferences: boolean;

previousSibling(): Node;

lastChild(): Node;

nextSibling(): Node;

nextNode(): Node;

parentNode(): Node;

firstChild(): Node;

previousNode(): Node;

}

declare var TreeWalker: {

prototype: TreeWalker;

new (): TreeWalker;

}

interface GetSVGDocument {

getSVGDocument(): Document;

}

interface SVGPathSegCurvetoQuadraticRel extends SVGPathSeg {

y: number;

y1: number;

x: number;

x1: number;

}

declare var SVGPathSegCurvetoQuadraticRel: {

prototype: SVGPathSegCurvetoQuadraticRel;

new (): SVGPathSegCurvetoQuadraticRel;

}

interface Performance {

navigation: PerformanceNavigation;

timing: PerformanceTiming;

getEntriesByType(entryType: string): any;

toJSON(): any;

getMeasures(measureName?: string): any;

clearMarks(markName?: string): void;

getMarks(markName?: string): any;

clearResourceTimings(): void;

mark(markName: string): void;

measure(measureName: string, startMarkName?: string, endMarkName?: string): void;

getEntriesByName(name: string, entryType?: string): any;

getEntries(): any;

clearMeasures(measureName?: string): void;

setResourceTimingBufferSize(maxSize: number): void;

}

declare var Performance: {

prototype: Performance;

new (): Performance;

}

interface MSDataBindingTableExtensions {

dataPageSize: number;

nextPage(): void;

firstPage(): void;

refresh(): void;

previousPage(): void;

lastPage(): void;

}

interface CompositionEvent extends UIEvent {

data: string;

locale: string;

initCompositionEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, dataArg: string, locale: string): void;

}

declare var CompositionEvent: {

prototype: CompositionEvent;

new (): CompositionEvent;

}

interface WindowTimers {

clearTimeout(handle: number): void;

setTimeout(handler: any, timeout?: any, ...args: any[]): number;

clearInterval(handle: number): void;

setInterval(handler: any, timeout?: any, ...args: any[]): number;

}

interface SVGMarkerElement extends SVGElement, SVGStylable, SVGLangSpace, SVGFitToViewBox, SVGExternalResourcesRequired {

orientType: SVGAnimatedEnumeration;

markerUnits: SVGAnimatedEnumeration;

markerWidth: SVGAnimatedLength;

markerHeight: SVGAnimatedLength;

orientAngle: SVGAnimatedAngle;

refY: SVGAnimatedLength;

refX: SVGAnimatedLength;

setOrientToAngle(angle: SVGAngle): void;

setOrientToAuto(): void;

SVG_MARKER_ORIENT_UNKNOWN: number;

SVG_MARKER_ORIENT_ANGLE: number;

SVG_MARKERUNITS_UNKNOWN: number;

SVG_MARKERUNITS_STROKEWIDTH: number;

SVG_MARKER_ORIENT_AUTO: number;

SVG_MARKERUNITS_USERSPACEONUSE: number;

}

declare var SVGMarkerElement: {

prototype: SVGMarkerElement;

new (): SVGMarkerElement;

SVG_MARKER_ORIENT_UNKNOWN: number;

SVG_MARKER_ORIENT_ANGLE: number;

SVG_MARKERUNITS_UNKNOWN: number;

SVG_MARKERUNITS_STROKEWIDTH: number;

SVG_MARKER_ORIENT_AUTO: number;

SVG_MARKERUNITS_USERSPACEONUSE: number;

}

interface CSSStyleDeclaration {

backgroundAttachment: string;

visibility: string;

textAlignLast: string;

borderRightStyle: string;

counterIncrement: string;

orphans: string;

cssText: string;

borderStyle: string;

pointerEvents: string;

borderTopColor: string;

markerEnd: string;

textIndent: string;

listStyleImage: string;

cursor: string;

listStylePosition: string;

wordWrap: string;

borderTopStyle: string;

alignmentBaseline: string;

opacity: string;

direction: string;

strokeMiterlimit: string;

maxWidth: string;

color: string;

clip: string;

borderRightWidth: string;

verticalAlign: string;

overflow: string;

mask: string;

borderLeftStyle: string;

emptyCells: string;

stopOpacity: string;

paddingRight: string;

parentRule: CSSRule;

background: string;

boxSizing: string;

textJustify: string;

height: string;