=== tests/cases/conformance/decorators/1.0lib-noErrors.ts ===

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

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;

>NaN : number

declare var Infinity: number;

>Infinity : number

/**

* Evaluates JavaScript code and executes it.

* @param x A String value that contains valid JavaScript code.

*/

declare function eval(x: string): any;

>eval : (x: string) => any

>x : string

/**

* Converts A string to an integer.

* @param s A string to convert into a number.

* @param radix A value between 2 and 36 that specifies the base of the number in numString.

* If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal.

* All other strings are considered decimal.

*/

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

>parseInt : (s: string, radix?: number) => number

>s : string

>radix : number

/**

* Converts a string to a floating-point number.

* @param string A string that contains a floating-point number.

*/

declare function parseFloat(string: string): number;

>parseFloat : (string: string) => number

>string : string

/**

* Returns a Boolean value that indicates whether a value is the reserved value NaN (not a number).

* @param number A numeric value.

*/

declare function isNaN(number: number): boolean;

>isNaN : (number: number) => boolean

>number : number

/**

* Determines whether a supplied number is finite.

* @param number Any numeric value.

*/

declare function isFinite(number: number): boolean;

>isFinite : (number: number) => boolean

>number : number

/**

* Gets the unencoded version of an encoded Uniform Resource Identifier (URI).

* @param encodedURI A value representing an encoded URI.

*/

declare function decodeURI(encodedURI: string): string;

>decodeURI : (encodedURI: string) => string

>encodedURI : string

/**

* Gets the unencoded version of an encoded component of a Uniform Resource Identifier (URI).

* @param encodedURIComponent A value representing an encoded URI component.

*/

declare function decodeURIComponent(encodedURIComponent: string): string;

>decodeURIComponent : (encodedURIComponent: string) => string

>encodedURIComponent : string

/**

* Encodes a text string as a valid Uniform Resource Identifier (URI)

* @param uri A value representing an encoded URI.

*/

declare function encodeURI(uri: string): string;

>encodeURI : (uri: string) => string

>uri : string

/**

* Encodes a text string as a valid component of a Uniform Resource Identifier (URI).

* @param uriComponent A value representing an encoded URI component.

*/

declare function encodeURIComponent(uriComponent: string | number | boolean): string;

>encodeURIComponent : (uriComponent: string | number | boolean) => string

>uriComponent : string | number | boolean

interface PropertyDescriptor {

configurable?: boolean;

>configurable : boolean

enumerable?: boolean;

>enumerable : boolean

value?: any;

>value : any

writable?: boolean;

>writable : boolean

get?(): any;

>get : () => any

set?(v: any): void;

>set : (v: any) => void

>v : any

}

interface PropertyDescriptorMap {

[s: string]: PropertyDescriptor;

>s : string

}

interface Object {

/** The initial value of Object.prototype.constructor is the standard built-in Object constructor. */

constructor: Function;

>constructor : Function

/** Returns a string representation of an object. */

toString(): string;

>toString : () => string

/** Returns a date converted to a string using the current locale. */

toLocaleString(): string;

>toLocaleString : () => string

/** Returns the primitive value of the specified object. */

valueOf(): Object;

>valueOf : () => Object

/**

* Determines whether an object has a property with the specified name.

* @param v A property name.

*/

hasOwnProperty(v: string): boolean;

>hasOwnProperty : (v: string) => boolean

>v : string

/**

* Determines whether an object exists in another object's prototype chain.

* @param v Another object whose prototype chain is to be checked.

*/

isPrototypeOf(v: Object): boolean;

>isPrototypeOf : (v: Object) => boolean

>v : Object

/**

* Determines whether a specified property is enumerable.

* @param v A property name.

*/

propertyIsEnumerable(v: string): boolean;

>propertyIsEnumerable : (v: string) => boolean

>v : string

}

/**

* Provides functionality common to all JavaScript objects.

*/

declare var Object: {

>Object : { (): any; (value: any): any; new (value?: any): Object; 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[]; }

new (value?: any): Object;

>value : any

(): any;

(value: any): any;

>value : any

/** A reference to the prototype for a class of objects. */

prototype: Object;

>prototype : Object

/**

* Returns the prototype of an object.

* @param o The object that references the prototype.

*/

getPrototypeOf(o: any): any;

>getPrototypeOf : (o: any) => any

>o : any

/**

* Gets the own property descriptor of the specified object.

* An own property descriptor is one that is defined directly on the object and is not inherited from the object's prototype.

* @param o Object that contains the property.

* @param p Name of the property.

*/

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

>getOwnPropertyDescriptor : (o: any, p: string) => PropertyDescriptor

>o : any

>p : string

/**

* Returns the names of the own properties of an object. The own properties of an object are those that are defined directly

* on that object, and are not inherited from the object's prototype. The properties of an object include both fields (objects) and functions.

* @param o Object that contains the own properties.

*/

getOwnPropertyNames(o: any): string[];

>getOwnPropertyNames : (o: any) => string[]

>o : any

/**

* Creates an object that has the specified prototype, and that optionally contains specified properties.

* @param o Object to use as a prototype. May be null

* @param properties JavaScript object that contains one or more property descriptors.

*/

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

>create : (o: any, properties?: PropertyDescriptorMap) => any

>o : any

>properties : PropertyDescriptorMap

/**

* Adds a property to an object, or modifies attributes of an existing property.

* @param o Object on which to add or modify the property. This can be a native JavaScript object (that is, a user-defined object or a built in object) or a DOM object.

* @param p The property name.

* @param attributes Descriptor for the property. It can be for a data property or an accessor property.

*/

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

>defineProperty : (o: any, p: string, attributes: PropertyDescriptor) => any

>o : any

>p : string

>attributes : PropertyDescriptor

/**

* Adds one or more properties to an object, and/or modifies attributes of existing properties.

* @param o Object on which to add or modify the properties. This can be a native JavaScript object or a DOM object.

* @param properties JavaScript object that contains one or more descriptor objects. Each descriptor object describes a data property or an accessor property.

*/

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

>defineProperties : (o: any, properties: PropertyDescriptorMap) => any

>o : any

>properties : PropertyDescriptorMap

/**

* Prevents the modification of attributes of existing properties, and prevents the addition of new properties.

* @param o Object on which to lock the attributes.

*/

seal(o: any): any;

>seal : (o: any) => any

>o : any

/**

* Prevents the modification of existing property attributes and values, and prevents the addition of new properties.

* @param o Object on which to lock the attributes.

*/

freeze(o: any): any;

>freeze : (o: any) => any

>o : any

/**

* Prevents the addition of new properties to an object.

* @param o Object to make non-extensible.

*/

preventExtensions(o: any): any;

>preventExtensions : (o: any) => any

>o : any

/**

* Returns true if existing property attributes cannot be modified in an object and new properties cannot be added to the object.

* @param o Object to test.

*/

isSealed(o: any): boolean;

>isSealed : (o: any) => boolean

>o : any

/**

* Returns true if existing property attributes and values cannot be modified in an object, and new properties cannot be added to the object.

* @param o Object to test.

*/

isFrozen(o: any): boolean;

>isFrozen : (o: any) => boolean

>o : any

/**

* Returns a value that indicates whether new properties can be added to an object.

* @param o Object to test.

*/

isExtensible(o: any): boolean;

>isExtensible : (o: any) => boolean

>o : any

/**

* Returns the names of the enumerable properties and methods of an object.

* @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.

*/

keys(o: any): string[];

>keys : (o: any) => string[]

>o : any

}

/**

* Creates a new function.

*/

interface Function {

/**

* Calls the function, substituting the specified object for the this value of the function, and the specified array for the arguments of the function.

* @param thisArg The object to be used as the this object.

* @param argArray A set of arguments to be passed to the function.

*/

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

>apply : (thisArg: any, argArray?: any) => any

>thisArg : any

>argArray : any

/**

* Calls a method of an object, substituting another object for the current object.

* @param thisArg The object to be used as the current object.

* @param argArray A list of arguments to be passed to the method.

*/

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

>call : (thisArg: any, ...argArray: any[]) => any

>thisArg : any

>argArray : any[]

/**

* For a given function, creates a bound function that has the same body as the original function.

* The this object of the bound function is associated with the specified object, and has the specified initial parameters.

* @param thisArg An object to which the this keyword can refer inside the new function.

* @param argArray A list of arguments to be passed to the new function.

*/

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

>bind : (thisArg: any, ...argArray: any[]) => any

>thisArg : any

>argArray : any[]

prototype: any;

>prototype : any

length: number;

>length : number

// Non-standard extensions

arguments: any;

>arguments : any

caller: Function;

>caller : Function

}

declare var Function: {

>Function : { (...args: string[]): Function; new (...args: string[]): Function; prototype: Function; }

/**

* Creates a new function.

* @param args A list of arguments the function accepts.

*/

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

>args : string[]

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

>args : string[]

prototype: Function;

>prototype : Function

}

interface IArguments {

[index: number]: any;

>index : number

length: number;

>length : number

callee: Function;

>callee : Function

}

interface String {

/** Returns a string representation of a string. */

toString(): string;

>toString : () => string

/**

* Returns the character at the specified index.

* @param pos The zero-based index of the desired character.

*/

charAt(pos: number): string;

>charAt : (pos: number) => string

>pos : number

/**

* Returns the Unicode value of the character at the specified location.

* @param index The zero-based index of the desired character. If there is no character at the specified index, NaN is returned.

*/

charCodeAt(index: number): number;

>charCodeAt : (index: number) => number

>index : number

/**

* Returns a string that contains the concatenation of two or more strings.

* @param strings The strings to append to the end of the string.

*/

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

>concat : (...strings: string[]) => string

>strings : string[]

/**

* Returns the position of the first occurrence of a substring.

* @param searchString The substring to search for in the string

* @param position The index at which to begin searching the String object. If omitted, search starts at the beginning of the string.

*/

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

>indexOf : (searchString: string, position?: number) => number

>searchString : string

>position : number

/**

* Returns the last occurrence of a substring in the string.

* @param searchString The substring to search for.

* @param position The index at which to begin searching. If omitted, the search begins at the end of the string.

*/

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

>lastIndexOf : (searchString: string, position?: number) => number

>searchString : string

>position : number

/**

* Determines whether two strings are equivalent in the current locale.

* @param that String to compare to target string

*/

localeCompare(that: string): number;

>localeCompare : (that: string) => number

>that : string

/**

* Matches a string with a regular expression, and returns an array containing the results of that search.

* @param regexp A variable name or string literal containing the regular expression pattern and flags.

*/

match(regexp: string): string[];

>match : { (regexp: string): string[]; (regexp: RegExp): string[]; }

>regexp : string

/**

* Matches a string with a regular expression, and returns an array containing the results of that search.

* @param regexp A regular expression object that contains the regular expression pattern and applicable flags.

*/

match(regexp: RegExp): string[];

>match : { (regexp: string): string[]; (regexp: RegExp): string[]; }

>regexp : RegExp

/**

* Replaces text in a string, using a regular expression or search string.

* @param searchValue A String object or string literal that represents the regular expression

* @param replaceValue A String object or string literal containing the text to replace for every successful match of rgExp in stringObj.

*/

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

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

>searchValue : string

>replaceValue : string

/**

* Replaces text in a string, using a regular expression or search string.

* @param searchValue A String object or string literal that represents the regular expression

* @param replaceValue A function that returns the replacement text.

*/

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

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

>searchValue : string

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

>substring : string

>args : any[]

/**

* Replaces text in a string, using a regular expression or search string.

* @param searchValue A Regular Expression object containing the regular expression pattern and applicable flags

* @param replaceValue A String object or string literal containing the text to replace for every successful match of rgExp in stringObj.

*/

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

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

>searchValue : RegExp

>replaceValue : string

/**

* Replaces text in a string, using a regular expression or search string.

* @param searchValue A Regular Expression object containing the regular expression pattern and applicable flags

* @param replaceValue A function that returns the replacement text.

*/

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

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

>searchValue : RegExp

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

>substring : string

>args : any[]

/**

* Finds the first substring match in a regular expression search.

* @param regexp The regular expression pattern and applicable flags.

*/

search(regexp: string): number;

>search : { (regexp: string): number; (regexp: RegExp): number; }

>regexp : string

/**

* Finds the first substring match in a regular expression search.

* @param regexp The regular expression pattern and applicable flags.

*/

search(regexp: RegExp): number;

>search : { (regexp: string): number; (regexp: RegExp): number; }

>regexp : RegExp

/**

* Returns a section of a string.

* @param start The index to the beginning of the specified portion of stringObj.

* @param end The index to the end of the specified portion of stringObj. The substring includes the characters up to, but not including, the character indicated by end.

* If this value is not specified, the substring continues to the end of stringObj.

*/

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

>slice : (start?: number, end?: number) => string

>start : number

>end : number

/**

* Split a string into substrings using the specified separator and return them as an array.

* @param separator A string that identifies character or characters to use in separating the string. If omitted, a single-element array containing the entire string is returned.

* @param limit A value used to limit the number of elements returned in the array.

*/

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

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

>separator : string

>limit : number

/**

* Split a string into substrings using the specified separator and return them as an array.

* @param separator A Regular Express that identifies character or characters to use in separating the string. If omitted, a single-element array containing the entire string is returned.

* @param limit A value used to limit the number of elements returned in the array.

*/

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

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

>separator : RegExp

>limit : number

/**

* Returns the substring at the specified location within a String object.

* @param start The zero-based index number indicating the beginning of the substring.

* @param end Zero-based index number indicating the end of the substring. The substring includes the characters up to, but not including, the character indicated by end.

* If end is omitted, the characters from start through the end of the original string are returned.

*/

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

>substring : (start: number, end?: number) => string

>start : number

>end : number

/** Converts all the alphabetic characters in a string to lowercase. */

toLowerCase(): string;

>toLowerCase : () => string

/** Converts all alphabetic characters to lowercase, taking into account the host environment's current locale. */

toLocaleLowerCase(): string;

>toLocaleLowerCase : () => string

/** Converts all the alphabetic characters in a string to uppercase. */

toUpperCase(): string;

>toUpperCase : () => string

/** Returns a string where all alphabetic characters have been converted to uppercase, taking into account the host environment's current locale. */

toLocaleUpperCase(): string;

>toLocaleUpperCase : () => string

/** Removes the leading and trailing white space and line terminator characters from a string. */

trim(): string;

>trim : () => string

/** Returns the length of a String object. */

length: number;

>length : number

// IE extensions

/**

* Gets a substring beginning at the specified location and having the specified length.

* @param from The starting position of the desired substring. The index of the first character in the string is zero.

* @param length The number of characters to include in the returned substring.

*/

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

>substr : (from: number, length?: number) => string

>from : number

>length : number

[index: number]: string;

>index : number

}

/**

* Allows manipulation and formatting of text strings and determination and location of substrings within strings.

*/

declare var String: {

>String : { (value?: any): string; new (value?: any): String; prototype: String; fromCharCode(...codes: number[]): string; }

new (value?: any): String;

>value : any

(value?: any): string;

>value : any

prototype: String;

>prototype : String

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

>fromCharCode : (...codes: number[]) => string

>codes : number[]

}

interface Boolean {

}

declare var Boolean: {

>Boolean : { (value?: any): boolean; new (value?: any): Boolean; prototype: Boolean; }

new (value?: any): Boolean;

>value : any

(value?: any): boolean;

>value : any

prototype: Boolean;

>prototype : Boolean

}

interface Number {

/**

* Returns a string representation of an object.

* @param radix Specifies a radix for converting numeric values to strings. This value is only used for numbers.

*/

toString(radix?: number): string;

>toString : (radix?: number) => string

>radix : number

/**

* Returns a string representing a number in fixed-point notation.

* @param fractionDigits Number of digits after the decimal point. Must be in the range 0 - 20, inclusive.

*/

toFixed(fractionDigits?: number): string;

>toFixed : (fractionDigits?: number) => string

>fractionDigits : number

/**

* Returns a string containing a number represented in exponential notation.

* @param fractionDigits Number of digits after the decimal point. Must be in the range 0 - 20, inclusive.

*/

toExponential(fractionDigits?: number): string;

>toExponential : (fractionDigits?: number) => string

>fractionDigits : number

/**

* Returns a string containing a number represented either in exponential or fixed-point notation with a specified number of digits.

* @param precision Number of significant digits. Must be in the range 1 - 21, inclusive.

*/

toPrecision(precision?: number): string;

>toPrecision : (precision?: number) => string

>precision : number

}

/** An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers. */

declare var Number: {

>Number : { (value?: any): number; new (value?: any): Number; prototype: Number; MAX_VALUE: number; MIN_VALUE: number; NaN: number; NEGATIVE_INFINITY: number; POSITIVE_INFINITY: number; }

new (value?: any): Number;

>value : any

(value?: any): number;

>value : any

prototype: Number;

>prototype : Number

/** The largest number that can be represented in JavaScript. Equal to approximately 1.79E+308. */

MAX_VALUE: number;

>MAX_VALUE : number

/** The closest number to zero that can be represented in JavaScript. Equal to approximately 5.00E-324. */

MIN_VALUE: number;

>MIN_VALUE : number

/**

* A value that is not a number.

* In equality comparisons, NaN does not equal any value, including itself. To test whether a value is equivalent to NaN, use the isNaN function.

*/

NaN: number;

>NaN : number

/**

* A value that is less than the largest negative number that can be represented in JavaScript.

* JavaScript displays NEGATIVE_INFINITY values as -infinity.

*/

NEGATIVE_INFINITY: number;

>NEGATIVE_INFINITY : number

/**

* A value greater than the largest number that can be represented in JavaScript.

* JavaScript displays POSITIVE_INFINITY values as infinity.

*/

POSITIVE_INFINITY: number;

>POSITIVE_INFINITY : number

}

interface Math {

/** The mathematical constant e. This is Euler's number, the base of natural logarithms. */

E: number;

>E : number

/** The natural logarithm of 10. */

LN10: number;

>LN10 : number

/** The natural logarithm of 2. */

LN2: number;

>LN2 : number

/** The base-2 logarithm of e. */

LOG2E: number;

>LOG2E : number

/** The base-10 logarithm of e. */

LOG10E: number;

>LOG10E : number

/** Pi. This is the ratio of the circumference of a circle to its diameter. */

PI: number;

>PI : number

/** The square root of 0.5, or, equivalently, one divided by the square root of 2. */

SQRT1_2: number;

>SQRT1_2 : number

/** The square root of 2. */

SQRT2: number;

>SQRT2 : number

/**

* Returns the absolute value of a number (the value without regard to whether it is positive or negative).

* For example, the absolute value of -5 is the same as the absolute value of 5.

* @param x A numeric expression for which the absolute value is needed.

*/

abs(x: number): number;

>abs : (x: number) => number

>x : number

/**

* Returns the arc cosine (or inverse cosine) of a number.

* @param x A numeric expression.

*/

acos(x: number): number;

>acos : (x: number) => number

>x : number

/**

* Returns the arcsine of a number.

* @param x A numeric expression.

*/

asin(x: number): number;

>asin : (x: number) => number

>x : number

/**

* Returns the arctangent of a number.

* @param x A numeric expression for which the arctangent is needed.

*/

atan(x: number): number;

>atan : (x: number) => number

>x : number

/**

* Returns the angle (in radians) from the X axis to a point (y,x).

* @param y A numeric expression representing the cartesian y-coordinate.

* @param x A numeric expression representing the cartesian x-coordinate.

*/

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

>atan2 : (y: number, x: number) => number

>y : number

>x : number

/**

* Returns the smallest number greater than or equal to its numeric argument.

* @param x A numeric expression.

*/

ceil(x: number): number;

>ceil : (x: number) => number

>x : number

/**

* Returns the cosine of a number.

* @param x A numeric expression that contains an angle measured in radians.

*/

cos(x: number): number;

>cos : (x: number) => number

>x : number

/**

* Returns e (the base of natural logarithms) raised to a power.

* @param x A numeric expression representing the power of e.

*/

exp(x: number): number;

>exp : (x: number) => number

>x : number

/**

* Returns the greatest number less than or equal to its numeric argument.

* @param x A numeric expression.

*/

floor(x: number): number;

>floor : (x: number) => number

>x : number

/**

* Returns the natural logarithm (base e) of a number.

* @param x A numeric expression.

*/

log(x: number): number;

>log : (x: number) => number

>x : number

/**

* Returns the larger of a set of supplied numeric expressions.

* @param values Numeric expressions to be evaluated.

*/

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

>max : (...values: number[]) => number

>values : number[]

/**

* Returns the smaller of a set of supplied numeric expressions.

* @param values Numeric expressions to be evaluated.

*/

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

>min : (...values: number[]) => number

>values : number[]

/**

* Returns the value of a base expression taken to a specified power.

* @param x The base value of the expression.

* @param y The exponent value of the expression.

*/

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

>pow : (x: number, y: number) => number

>x : number

>y : number

/** Returns a pseudorandom number between 0 and 1. */

random(): number;

>random : () => number

/**

* Returns a supplied numeric expression rounded to the nearest number.

* @param x The value to be rounded to the nearest number.

*/

round(x: number): number;

>round : (x: number) => number

>x : number

/**

* Returns the sine of a number.

* @param x A numeric expression that contains an angle measured in radians.

*/

sin(x: number): number;

>sin : (x: number) => number

>x : number

/**

* Returns the square root of a number.

* @param x A numeric expression.

*/

sqrt(x: number): number;

>sqrt : (x: number) => number

>x : number

/**

* Returns the tangent of a number.

* @param x A numeric expression that contains an angle measured in radians.

*/

tan(x: number): number;

>tan : (x: number) => number

>x : number

}

/** An intrinsic object that provides basic mathematics functionality and constants. */

declare var Math: Math;

>Math : Math

/** Enables basic storage and retrieval of dates and times. */

interface Date {

/** Returns a string representation of a date. The format of the string depends on the locale. */

toString(): string;

>toString : () => string

/** Returns a date as a string value. */

toDateString(): string;

>toDateString : () => string

/** Returns a time as a string value. */

toTimeString(): string;

>toTimeString : () => string

/** Returns a value as a string value appropriate to the host environment's current locale. */

toLocaleString(): string;

>toLocaleString : () => string

/** Returns a date as a string value appropriate to the host environment's current locale. */

toLocaleDateString(): string;

>toLocaleDateString : () => string

/** Returns a time as a string value appropriate to the host environment's current locale. */

toLocaleTimeString(): string;

>toLocaleTimeString : () => string

/** Returns the stored time value in milliseconds since midnight, January 1, 1970 UTC. */

valueOf(): number;

>valueOf : () => number

/** Gets the time value in milliseconds. */

getTime(): number;

>getTime : () => number

/** Gets the year, using local time. */

getFullYear(): number;

>getFullYear : () => number

/** Gets the year using Universal Coordinated Time (UTC). */

getUTCFullYear(): number;

>getUTCFullYear : () => number

/** Gets the month, using local time. */

getMonth(): number;

>getMonth : () => number

/** Gets the month of a Date object using Universal Coordinated Time (UTC). */

getUTCMonth(): number;

>getUTCMonth : () => number

/** Gets the day-of-the-month, using local time. */

getDate(): number;

>getDate : () => number

/** Gets the day-of-the-month, using Universal Coordinated Time (UTC). */

getUTCDate(): number;

>getUTCDate : () => number

/** Gets the day of the week, using local time. */

getDay(): number;

>getDay : () => number

/** Gets the day of the week using Universal Coordinated Time (UTC). */

getUTCDay(): number;

>getUTCDay : () => number

/** Gets the hours in a date, using local time. */

getHours(): number;

>getHours : () => number

/** Gets the hours value in a Date object using Universal Coordinated Time (UTC). */

getUTCHours(): number;

>getUTCHours : () => number

/** Gets the minutes of a Date object, using local time. */

getMinutes(): number;

>getMinutes : () => number

/** Gets the minutes of a Date object using Universal Coordinated Time (UTC). */

getUTCMinutes(): number;

>getUTCMinutes : () => number

/** Gets the seconds of a Date object, using local time. */

getSeconds(): number;

>getSeconds : () => number

/** Gets the seconds of a Date object using Universal Coordinated Time (UTC). */

getUTCSeconds(): number;

>getUTCSeconds : () => number

/** Gets the milliseconds of a Date, using local time. */

getMilliseconds(): number;

>getMilliseconds : () => number

/** Gets the milliseconds of a Date object using Universal Coordinated Time (UTC). */

getUTCMilliseconds(): number;

>getUTCMilliseconds : () => number

/** Gets the difference in minutes between the time on the local computer and Universal Coordinated Time (UTC). */

getTimezoneOffset(): number;

>getTimezoneOffset : () => number

/**

* Sets the date and time value in the Date object.

* @param time A numeric value representing the number of elapsed milliseconds since midnight, January 1, 1970 GMT.

*/

setTime(time: number): number;

>setTime : (time: number) => number

>time : number