/src/main/resources/front/js/typedefs/underscore-typed-1.4.d.ts

//     underscore-1.4.2.d.ts

//     (c) 2012 Josh Baldwin

//     underscore.d.ts may be freely distributed under the MIT license.

//     For all details and documentation:

//     https://github.com/jbaldwin/underscore.d.ts



interface Underscore {



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

	* Collections *

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



	/**

	* Iterates over a list of elements, yielding each in turn to an iterator function. The iterator is

	* bound to the context object, if one is passed. Each invocation of iterator is called with three

	* arguments: (element, index, list). If list is a JavaScript object, iterator's arguments will be

	* (value, key, list). Delegates to the native forEach function if it exists.

	**/	

	each(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => any,

		context?: any): void;

	each(

		list: number[],

		iterator: (element: number, index?: number, list?: number[]) => any,

		context?: any): void;

	each(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => any,

		context?: any): void;

	each(

		obj: Object,

		iterator: (value: any, key?: string, object?: Object) => any,

		context?: any): void;



	/**

	* Alias for 'each'.

	**/

	forEach(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => any,

		context?: any): void;

	forEach(

		list: number[],

		iterator: (element: number, index?: number, list?: number[]) => any,

		context?: any): void;

	forEach(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => any,

		context?: any): void;

	forEach(

		obj: Object,

		iterator: (value: any, key?: string, object?: Object) => any,

		context?: any): void;



	/**

	* Produces a new array of values by mapping each value in list through a transformation function

	* (iterator). If the native map method exists, it will be used instead. If list is a JavaScript

	* object, iterator's arguments will be (value, key, list).

	**/

	map(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => string,

		context?: any): string[];

	map(

		list: number[],

		iterator: (element: number, index?: number, list?: number[]) => number,

		context?: any): number[];

	map(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => any,

		context?: any): any[];

	map(

		obj: Object,

		iterator: (value: any, key?: string, object?: Object) => any,

		context?: any): void;



	/**

	* Alias for 'map'.

	**/

	collect(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => string,

		context?: any): string[];

	collect(

		list: number[],

		iterator: (element: number, index?: number, list?: number[]) => number,

		context?: any): number[];

	collect(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => any,

		context?: any): any[];

	collect(

		obj: Object,

		iterator: (value: any, key?: string, object?: Object) => any,

		context?: any): void;



	/**

	* Also known as inject and foldl, reduce boils down a list of values into a single value.

	* Memo is the initial state of the reduction, and each successive step of it should be

	* returned by iterator. The iterator is passed four arguments: the memo, then the value

	* and index (or key) of the iteration, and finally a reference to the entire list.

	**/

	reduce(

		list: string[],

		iterator: (memo: string, element: string, index?: number, list?: string[]) => string,

		memo: string,

		context?: any): string;

	reduce(

		list: number[],

		iterator: (memo: number, element: number, index?: number, list?: number[]) => number,

		memo: number,

		context?: any): number;

	reduce(

		list: any[],

		iterator: (memo: any, element: any, index?: number, list?: any[]) => any,

		memo: any,

		context?: any): any;



	/**

	* Alias for 'reduce'.

	**/

	inject(

		list: string[],

		iterator: (memo: string, element: string, index?: number, list?: string[]) => string,

		memo: string,

		context?: any): string;

	inject(

		list: number[],

		iterator: (memo: number, element: number, index?: number, list?: number[]) => number,

		memo: number,

		context?: any): number;

	inject(

		list: any[],

		iterator: (memo: any, element: any, index?: number, list?: any[]) => any,

		memo: any,

		context?: any): any;



	/**

	* Alias for 'reduce'.

	**/

	foldl(

		list: string[],

		iterator: (memo: string, element: string, index?: number, list?: string[]) => string,

		memo: string,

		context?: any): string;

	foldl(

		list: number[],

		iterator: (memo: number, element: number, index?: number, list?: number[]) => number,

		memo: number,

		context?: any): number;

	foldl(

		list: any[],

		iterator: (memo: any, element: any, index?: number, list?: any[]) => any,

		memo: any,

		context?: any): any;



	/**

	* The right-associative version of reduce. Delegates to the JavaScript 1.8 version of

	* reduceRight, if it exists. Foldr is not as useful in JavaScript as it would be in a

	* language with lazy evaluation.

	**/

	reduceRight(

		list: string[],

		iterator: (memo: string, element: string, index?: number, list?: string[]) => string,

		memo: string,

		context?: any): string;

	reduceRight(

		list: number[],

		iterator: (memo: number, element: number, index?: number, list?: number[]) => number,

		memo: number,

		context?: any): number;

	reduceRight(

		list: any[],

		iterator: (memo: any, element: any, index?: number, list?: any[]) => any,

		memo: any,

		context?: any): any;



	/**

	* Alias for 'reduceRight'.

	**/

	foldr(

		list: string[],

		iterator: (memo: string, element: string, index?: number, list?: string[]) => string,

		memo: string,

		context?: any): string;

	foldr(

		list: number[],

		iterator: (memo: number, element: number, index?: number, list?: number[]) => number,

		memo: number,

		context?: any): number;

	foldr(

		list: any[],

		iterator: (memo: any, element: any, index?: number, list?: any[]) => any,

		memo: any,

		context?: any): any;



	/**

	* Looks through each value in the list, returning the first one that passes a truth

	* test (iterator). The function returns as soon as it finds an acceptable element,

	* and doesn't traverse the entire list.

	**/

	find(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): string;

	find(

		list: number[],

		iterator: (element: number, index?: number, list?: number[]) => bool,

		context?: any): number;

	find(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): any;



	/**

	* Alias for 'find'.

	**/

	detect(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): string;

	detect(

		list: number[],

		iterator: (element: number, index?: number, list?: number[]) => bool,

		context?: any): number;

	detect(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): any;





	/**

	* Looks through each value in the list, returning an array of all the values that pass a truth

	* test (iterator). Delegates to the native filter method, if it exists.

	**/

	filter(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): string[];

	filter(

		list: number[],

		iterator: (element: number, index?: number, list?: number[]) => bool,

		context?: any): number[];

	filter(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): any[];



	/**

	* Alias for 'filter'.

	**/

	select(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): string[];

	select(

		list: number[],

		iterator: (element: number, index?: number, list?: number[]) => bool,

		context?: any): number[];

	select(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): any[];



	/**

	* Looks through each value in the list, returning an array of all the values that contain all

	* of the key-value pairs listed in properties.

	**/

	where(list: any[], properties: any): any[];



	/**

	* Returns the values in list without the elements that the truth test (iterator) passes.

	* The opposite of filter.

	**/

	reject(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): string[];

	reject(

		list: number[],

		iterator: (element: number, index?: number, list?: number[]) => bool,

		context?: any): number[];

	reject(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): any[];



	/**

	* Returns true if all of the values in the list pass the iterator truth test. Delegates to the

	* native method every, if present.

	**/

	all(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): bool;

	all(

		list: number[],

		iterator: (element: number, index?: number, list?: string[]) => bool,

		context?: any): bool;

	all(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): bool;



	/**

	* Alias for 'all'.

	**/

	every(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): bool;

	every(

		list: number[],

		iterator: (element: number, index?: number, list?: string[]) => bool,

		context?: any): bool;

	every(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): bool;



	/**

	* Returns true if any of the values in the list pass the iterator truth test. Short-circuits and

	* stops traversing the list if a true element is found. Delegates to the native method some, if present.

	**/

	any(

		list: string[],

		iterator?: (element: string, index?: number, list?: string[]) => bool,

		context?: any): bool;

	any(

		list: number[],

		iterator?: (element: number, index?: number, list?: string[]) => bool,

		context?: any): bool;

	any(

		list: any[],

		iterator?: (element: any, index?: number, list?: any[]) => bool,

		context?: any): bool;



	/**

	* Alias for 'any'.

	**/

	some(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): bool;

	some(

		list: number[],

		iterator: (element: number, index?: number, list?: string[]) => bool,

		context?: any): bool;

	some(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): bool;



	/**

	* Returns true if the value is present in the list. Uses indexOf internally,

	* if list is an Array.

	**/

	contains(list: string[], value: string): bool;

	contains(list: number[], value: number): bool;

	contains(list: any[], value: any): bool;



	/**

	* Alias for 'contains'.

	**/

	include(list: string[], value: string): bool;

	include(list: number[], value: number): bool;

	include(list: any[], value: any): bool;



	/**

	* Calls the method named by methodName on each value in the list. Any extra arguments passed to

	* invoke will be forwarded on to the method invocation.

	**/

	invoke(list: string[], methodName: string, ...arguments: any[]): void;

	invoke(list: number[], methodName: string, ...arguments: any[]): void;

	invoke(list: any[], methodName: string, ...arguments: any[]): void;



	/**

	* A convenient version of what is perhaps the most common use-case for map: extracting a list of

	* property values.

	**/

	pluck(list: any[], propertyName: string): any[];



	/**

	* Returns the maximum value in list. If iterator is passed, it will be used on each value to generate

	* the criterion by which the value is ranked.

	**/

	max(list: number[]): number;

	max(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => number,

		context?: any): any;



	/**

	* Returns the minimum value in list. If iterator is passed, it will be used on each value to generate

	* the criterion by which the value is ranked.

	**/

	min(list: number[]): number;

	min(

		list: any[],

		iterator: (obj: any, index?: number, list?: any[]) => number,

		context?: any): any;



	/**

	* Returns a sorted copy of list, ranked in ascending order by the results of running each value

	* through iterator. Iterator may also be the string name of the property to sort by (eg. length).

	**/

	sortBy(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => number,

		context?: any): string[];

	sortBy(

		list: number[],

		iterator: (element: number, index?: number, list?: number[]) => number,

		context?: any): number[];

	sortBy(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => number,

		context?: any): any[];

	sortBy(

		list: string[],

		iterator: string,

		context?: any): string[];

	sortBy(

		list: number[],

		iterator: string,

		context?: any): number[];

	sortBy(

		list: any[],

		iterator: string,

		context?: any): any[];



	/**

	* Splits a collection into sets, grouped by the result of running each value through iterator.

	* If iterator is a string instead of a function, groups by the property named by iterator on

	* each of the values.

	**/

	groupBy(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => string,

		context?: any): { [key: string]: string[]; };

	groupBy(

		list: number[],

		iterator: (element: number, index?: number, list?: number[]) => string,

		context?: any): { [key: string]: number[]; };

	groupBy(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => string,

		context?: any): { [key: string]: any[]; };

	groupBy(

		list: string[],

		iterator: string,

		context?: any): { [key: string]: string[]; };

	groupBy(

		list: number[],

		iterator: string,

		context?: any): { [key: string]: number[]; };

	groupBy(

		list: any[],

		iterator: string,

		context?: any): { [key: string]: any[]; };



	/**

	* Sorts a list into groups and returns a count for the number of objects in each group. Similar

	* to groupBy, but instead of returning a list of values, returns a count for the number of values

	* in that group.

	**/

	countBy(

		list: string[],

		iterator: (element: string, index?: number, list?: string[]) => string,

		context?: any): { [key: string]: number; };

	countBy(

		list: number[],

		iterator: (element: number, index?: number, list?: number[]) => string,

		context?: any): { [key: string]: number; };

	countBy(

		list: any[],

		iterator: (element: any, index?: number, list?: any[]) => string,

		context?: any): { [key: string]: number; };

	countBy(

		list: string[],

		iterator: string,

		context?: any): { [key: string]: number; };

	countBy(

		list: number[],

		iterator: string,

		context?: any): { [key: string]: number; };

	countBy(

		list: any[],

		iterator: string,

		context?: any): { [key: string]: number; };



	/**

	* Returns a shuffled copy of the list, using a version of the Fisher-Yates shuffle.

	**/

	shuffle(list: string[]): string[];

	shuffle(list: number[]): number[];

	shuffle(list: any[]): any[];



	/**

	* Converts the list (anything that can be iterated over), into a real Array. Useful for transmuting

	* the arguments object.

	**/

	toArray(list: any): any[];



	/**

	* Return the number of values in the list.

	**/

	size(list: any): number;



	/*********

	* Arrays *

	**********/



	/**

	* Returns the first element of an array. Passing n will return the first n elements of the array.

	**/

	first(array: string[]): string;

	first(array: string[], n: number): string[];

	first(array: number[]): number;

	first(array: number[], n: number): number[];

	first(array: any[]): any;

	first(array: any[], n: number): any[];



	/**

	* Alias for 'first'.

	**/

	head(array: string[]): string;

	head(array: string[], n: number): string[];

	head(array: number[]): number;

	head(array: number[], n: number): number[];

	head(array: any[]): any;

	head(array: any[], n: number): any[];



	/**

	* Alias for 'first'.

	**/

	take(array: string[]): string;

	take(array: string[], n: number): string[];

	take(array: number[]): number;

	take(array: number[], n: number): number[];

	take(array: any[]): any;

	take(array: any[], n: number): any[];



	/**

	* Returns everything but the last entry of the array. Especially useful on the arguments object.

	* Pass n to exclude the last n elements from the result.

	**/

	initial(array: string[], n?: number): string[];

	initial(array: number[], n?: number): number[];

	initial(array: any[], n?: number): any[];



	/**

	* Returns the last element of an array. Passing n will return the last n elements of the array.

	**/

	last(array: string[]): string;

	last(array: string[], n: number): string[];

	last(array: number[]): number;

	last(array: number[], n: number): number[];

	last(array: any[]): any;

	last(array: any[], n: number): any[];



	/**

	* Returns the rest of the elements in an array. Pass an index to return the values of the array

	* from that index onward.

	**/

	rest(array: string[], index?: number): string[];

	rest(array: number[], index?: number): number[];

	rest(array: any[], index?: number): any[];



	/**

	* Alias for 'rest'.

	**/

	tail(array: string[], index?: number): string[];

	tail(array: number[], index?: number): number[];

	tail(array: any[], index?: number): any[];



	/**

	* Alias for 'rest'.

	**/

	drop(array: string[], index?: number): string[];

	drop(array: number[], index?: number): number[];

	drop(array: any[], index?: number): any[];



	/**

	* Returns a copy of the array with all falsy values removed. In JavaScript, false, null, 0, "",

	* undefined and NaN are all falsy.

	**/

	compact(array: string[]): string[];

	compact(array: number[]): number[];

	compact(array: bool[]): bool[];

	compact(array: any[]): any[];



	/**

	* Flattens a nested array (the nesting can be to any depth). If you pass shallow, the array will

	* only be flattened a single level.

	**/

	flatten(array: string[], shallow?: bool): string[];

	flatten(array: string[][], shallow?: bool): string[];

	flatten(array: number[], shallow?: bool): number[];

	flatten(array: number[][], shallow?: bool): number[];

	flatten(array: any[], shallow?: bool): any[];

	flatten(array: any[][], shallow?: bool): any[];



	/**

	* Returns a copy of the array with all instances of the values removed.

	**/

	without(array: string[], ...values: string[]): string[];

	without(array: number[], ...values: number[]): number[];

	without(array: any[], ...values: any[]): any[];



	/**

	* Computes the union of the passed-in arrays: the list of unique items, in order, that are

	* present in one or more of the arrays.

	**/

	union(...arrays: string[][]): string[];

	union(...arrays: number[][]): number[];

	union(...arrays: any[][]): any[];



	/**

	* Computes the list of values that are the intersection of all the arrays. Each value in the result

	* is present in each of the arrays.

	**/

	intersection(...arrays: string[][]): string[];

	intersection(...arrays: number[][]): number[];

	intersection(...arrays: any[][]): any[];



	/**

	* Similar to without, but returns the values from array that are not present in the other arrays.

	**/

	difference(array: string[], ...others: string[]): string[];

	difference(array: number[], ...others: number[]): number[];

	difference(array: any[], ...others: any[]): any[];



	/**

	* Produces a duplicate-free version of the array, using === to test object equality. If you know in

	* advance that the array is sorted, passing true for isSorted will run a much faster algorithm. If

	* you want to compute unique items based on a transformation, pass an iterator function.

	**/

	uniq(array: string[], isSorted?: bool, iterator?: (element: string, index?: number, list?: string[]) => string): string[];

	uniq(array: number[], isSorted?: bool, iterator?: (element: number, index?: number, list?: number[]) => number): number[];

	uniq(array: any[], isSorted?: bool, iterator?: (element: any, index?: number, list?: any[]) => any): any[];



	/**

	* Alias for 'uniq'.

	**/

	unique(array: string[], isSorted?: bool, iterator?: (element: string, index?: number, list?: string[]) => string): string[];

	unique(array: number[], isSorted?: bool, iterator?: (element: number, index?: number, list?: number[]) => number): number[];

	unique(array: any[], isSorted?: bool, iterator?: (element: any, index?: number, list?: any[]) => any): any[];



	/**

	* Merges together the values of each of the arrays with the values at the corresponding position.

	* Useful when you have separate data sources that are coordinated through matching array indexes.

	* If you're working with a matrix of nested arrays, zip.apply can transpose the matrix in a similar fashion.

	**/

	zip(...arrays: string[][]): string[][];

	zip(...arrays: number[][]): number[][];

	zip(...arrays: any[][]): any[][];



	/**

	* Converts arrays into objects. Pass either a single list of [key, value] pairs, or a

	* list of keys, and a list of values.

	**/

	object(keys: string[], values: any[]): any;

	object(...keyValuePairs: any[][]): any;



	/**

	* Returns the index at which value can be found in the array, or -1 if value is not present in the array.

	* Uses the native indexOf function unless it's missing. If you're working with a large array, and you know

	* that the array is already sorted, pass true for isSorted to use a faster binary search ... or, pass a number

	* as the third argument in order to look for the first matching value in the array after the given index.

	**/

	indexOf(array: string[], value: string, isSorted?: bool): number;

	indexOf(array: number[], value: number, isSorted?: bool): number;

	indexOf(array: any[], value: any, isSorted?: bool): number;



	/**

	* Returns the index of the last occurrence of value in the array, or -1 if value is not present. Uses the

	* native lastIndexOf function if possible. Pass fromIndex to start your search at a given index.

	**/

	lastIndexOf(array: string[], value: string, from?: number): number;

	lastIndexOf(array: number[], value: number, from?: number): number;

	lastIndexOf(array: any[], value: any, from?: number): number;



	/**

	* Uses a binary search to determine the index at which the value should be inserted into the list in order

	* to maintain the list's sorted order. If an iterator is passed, it will be used to compute the sort ranking

	* of each value, including the value you pass.

	**/

	sortedIndex(list: string[], value: string, iterator?: (element: string) => number): number;

	sortedIndex(list: number[], value: number, iterator?: (element: number) => number): number;

	sortedIndex(list: any[], value: any, iterator?: (element: any) => number): number;



	/**

	* A function to create flexibly-numbered lists of integers, handy for each and map loops. start, if omitted,

	* defaults to 0; step defaults to 1. Returns a list of integers from start to stop, incremented (or decremented)

	* by step, exclusive.

	**/

	range(start: number, stop: number, step?: number): number[];

	// If start is not specified the implementation will never pull the step (step = arguments[2] || 0)

	range(stop: number): number[];



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

	* Functions *

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



	/**

	* Bind a function to an object, meaning that whenever the function is called, the value of this will

	* be the object. Optionally, bind arguments to the function to pre-fill them, also known as partial application.

	**/

	bind(fn: Function, object: any, ...arguments: any[]): Function;





	/**

	* Binds a number of methods on the object, specified by methodNames, to be run in the context of that object

	* whenever they are invoked. Very handy for binding functions that are going to be used as event handlers,

	* which would otherwise be invoked with a fairly useless this. If no methodNames are provided, all of the

	* object's function properties will be bound to it.

	**/

	bindAll(object: any, ...methodNames: string[]): void;



	/**

	* Memoizes a given function by caching the computed result. Useful for speeding up slow-running computations.

	* If passed an optional hashFunction, it will be used to compute the hash key for storing the result, based

	* on the arguments to the original function. The default hashFunction just uses the first argument to the

	* memoized function as the key.

	**/

	memoize(fn: Function, hashFn?: (n: any) => string): Function;



	/**

	* Much like setTimeout, invokes function after wait milliseconds. If you pass the optional arguments,

	* they will be forwarded on to the function when it is invoked.

	**/

	delay(fn: Function, waitMS: number, ...arguments: any[]): void;



	/**

	* Defers invoking the function until the current call stack has cleared, similar to using setTimeout

	* with a delay of 0. Useful for performing expensive computations or HTML rendering in chunks without

	* blocking the UI thread from updating. If you pass the optional arguments, they will be forwarded on

	* to the function when it is invoked.

	**/

	defer(fn: Function, ...arguments: any[]): void;



	/**

	* Creates and returns a new, throttled version of the passed function, that, when invoked repeatedly,

	* will only actually call the original function at most once per every wait milliseconds. Useful for

	* rate-limiting events that occur faster than you can keep up with.

	**/

	throttle(fn: Function, waitMS: number): Function;



	/**

	* Creates and returns a new debounced version of the passed function that will postpone its execution

	* until after wait milliseconds have elapsed since the last time it was invoked. Useful for implementing

	* behavior that should only happen after the input has stopped arriving. For example: rendering a preview

	* of a Markdown comment, recalculating a layout after the window has stopped being resized, and so on.

	*

	* Pass true for the immediate parameter to cause debounce to trigger the function on the leading instead

	* of the trailing edge of the wait interval. Useful in circumstances like preventing accidental double

	*-clicks on a "submit" button from firing a second time.

	**/

	debounce(fn: Function, waitMS: number, immediate?: bool): Function;



	/**

	* Creates a version of the function that can only be called one time. Repeated calls to the modified

	* function will have no effect, returning the value from the original call. Useful for initialization

	* functions, instead of having to set a boolean flag and then check it later.

	**/

	once(fn: Function): Function;



	/**

	* Creates a version of the function that will only be run after first being called count times. Useful

	* for grouping asynchronous responses, where you want to be sure that all the async calls have finished,

	* before proceeding.

	**/

	after(count: number, fn: Function): Function;



	/**

	* Wraps the first function inside of the wrapper function, passing it as the first argument. This allows

	* the wrapper to execute code before and after the function runs, adjust the arguments, and execute it

	* conditionally.

	**/

	wrap(fn: Function, wrapper: (fn: Function, ...args: any[]) => any): Function;



	/**

	* Returns the composition of a list of functions, where each function consumes the return value of the

	* function that follows. In math terms, composing the functions f(), g(), and h() produces f(g(h())).

	**/

	compose(...functions: Function[]): Function;



	/**********

	* Objects *

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



	/**

	* Retrieve all the names of the object's properties.

	**/

	keys(object: any): string[];



	/**

	* Return all of the values of the object's properties.

	**/

	values(object: any): any[];



	/**

	* Convert an object into a list of [key, value] pairs.

	**/

	pairs(object: any): any[][];



	/**

	* Returns a copy of the object where the keys have become the values and the values the keys.

	* For this to work, all of your object's values should be unique and string serializable.

	**/

	invert(object: any): any;



	/**

	* Returns a sorted list of the names of every method in an object — that is to say,

	* the name of every function property of the object.

	**/

	functions(object: any): string[];



	/**

	* Copy all of the properties in the source objects over to the destination object, and return

	* the destination object. It's in-order, so the last source will override properties of the

	* same name in previous arguments.

	**/

	extend(destination: any, ...sources: any[]): any;



	/**

	* Return a copy of the object, filtered to only have values for the whitelisted keys

	* (or array of valid keys).

	**/

	pick(object: any, ...keys: string[]): any;



	/**

	* Return a copy of the object, filtered to omit the blacklisted keys (or array of keys).

	**/

	omit(object: any, ...keys: string[]): any;



	/**

	* Fill in null and undefined properties in object with values from the defaults objects,

	* and return the object. As soon as the property is filled, further defaults will have no effect.

	**/

	defaults(object: any, ...defaults: any[]): any;



	/**

	* Create a shallow-copied clone of the object.

	* Any nested objects or arrays will be copied by reference, not duplicated.

	**/

	clone(object: any): any;

	clone(list: string[]): string[];

	clone(list: number[]): number[];

	clone(list: any[]): any[];



	/**

	* Invokes interceptor with the object, and then returns object. The primary purpose of this method

	* is to "tap into" a method chain, in order to perform operations on intermediate results within the chain.

	**/

	tap(object: any, intercepter: Function): any;



	/**

	* Does the object contain the given key? Identical to object.hasOwnProperty(key), but uses a safe

	* reference to the hasOwnProperty function, in case it's been overridden accidentally.

	**/

	has(object: any, key: string): bool;



	/**

	* Performs an optimized deep comparison between the two objects,

	* to determine if they should be considered equal.

	**/

	isEqual(object: any, other: any): bool;



	/**

	* Returns true if object contains no values.

	**/

	isEmpty(object: any): bool;

	isEmpty(list: any[]): bool;



	/**

	* Returns true if object is a DOM element.

	**/

	isElement(object: any): bool;



	/**

	* Returns true if object is an Array.

	**/

	isArray(object: any): bool;



	/**

	* Returns true if value is an any. Note that JavaScript arrays and functions are objects,

	* while (normal) strings and numbers are not.

	**/

	isObject(object: any): bool;



	/**

	* Returns true if object is an Arguments object.

	**/

	isArguments(object: any): bool;



	/**

	* Returns true if object is a Function.

	**/

	isFunction(object: any): bool;



	/**

	* Returns true if object is a String.

	**/

	isString(object: any): bool;



	/**

	* Returns true if object is a Number (including NaN).

	**/

	isNumber(object: any): bool;



	/**

	* Returns true if object is a finite Number.

	**/

	isFinite(object: any): bool;



	/**

	* Returns true if object is either true or false.

	**/

	isBoolean(object: any): bool;



	/**

	* Returns true if object is a Date.

	**/

	isDate(object: any): bool;



	/**

	* Returns true if object is a RegExp.

	**/

	isRegExp(object: any): bool;



	/**

	* Returns true if object is NaN.

	* Note: this is not the same as the native isNaN function,

	* which will also return true if the variable is undefined.

	**/

	isNaN(object: any): bool;



	/**

	* Returns true if the value of object is null.

	**/

	isNull(object: any): bool;



	/**

	* Returns true if value is undefined.

	**/

	isUndefined(object: any): bool;



	/**********

	* Utility *

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



	/**

	* Give control of the "_" variable back to its previous owner.

	* Returns a reference to the Underscore object.

	**/

	noConflict(): Underscore;



	/**

	* Returns the same value that is used as the argument. In math: f(x) = x

	* This function looks useless, but is used throughout Underscore as a default iterator.

	**/

	identity(value: string): string;

	identity(value: string[]): string[];

	identity(value: number): number;

	identity(value: number[]): number[];

	identity(value: bool): bool;

	identity(value: any): any;



	/**

	* Invokes the given iterator function n times.

	* Each invocation of iterator is called with an index argument.

	* @example

	*

	* _(3).times(function(n){ genie.grantWishNumber(n); });

	*

	**/

	times(n: number, iterator: (n: number) => void , context?: any): void;



	/**

	* Returns a random integer between min and max, inclusive. If you only pass one argument,

	* it will return a number between 0 and that number.

	**/

	random(max: number): number;

	random(min: number, max: number): number;



	/**

	* Allows you to extend Underscore with your own utility functions. Pass a hash of

	* {name: function} definitions to have your functions added to the Underscore object,

	* as well as the OOP wrapper.

	* @example

	*

	* _.mixin({

	*     capitalize : function(string) {

	*         return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();

	*     }

	* });

	* _("fabio").capitalize();

	* => "Fabio"

	*

	**/

	mixin(object: any): void;



	/**

	* Generate a globally-unique id for client-side models or DOM elements that need one.

	* If prefix is passed, the id will be appended to it. Without prefix, returns an integer.

	**/

	uniqueId(): number;

	uniqueId(prefix: string): string;



	/**

	* Escapes a string for insertion into HTML, replacing &, <, >, ", ', and / characters.

	**/

	escape(str: string): string;



	/**

	* If the value of the named property is a function then invoke it; otherwise, return it.

	**/

	result(object: any, property: string): any;



	/**

	* Compiles JavaScript templates into functions that can be evaluated for rendering. Useful

	* for rendering complicated bits of HTML from JSON data sources. Template functions can both

	* interpolate variables, using <%= … %>, as well as execute arbitrary JavaScript code, with

	* <% … %>. If you wish to interpolate a value, and have it be HTML-escaped, use <%- … %> When

	* you evaluate a template function, pass in a data object that has properties corresponding to

	* the template's free variables. If you're writing a one-off, you can pass the data object as

	* the second parameter to template in order to render immediately instead of returning a template

	* function. The settings argument should be a hash containing any _.templateSettings that should

	* be overridden.

	**/

	template(templateString: string, data?: any, settings?: UnderscoreTemplateSettings): any;



	// By default, Underscore uses ERB-style template delimiters, change the

	// following template settings to use alternative delimiters.

	templateSettings: UnderscoreTemplateSettings;



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

	* Chaining *

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



	/**

	* Returns a wrapped object. Calling methods on this object will continue to return wrapped objects

	* until value is used.

	**/

	chain(obj: any): any;



	/**

	* Extracts the value of a wrapped object.

	**/

	value(s: string): string;

	value(n: number): number;

	value(s: string[]): string[];

	value(n: number[]): number[];

	value(obj: any): any;

	value(obj: any[]): any[];



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

	* OOP Wrapper *

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

	(key: string): UnderscoreStringOOPWrapper;

	(list: string[]): UnderscoreStringArrayOOPWrapper;

	(n: number): UnderscoreNumberOOPWrapper;

	(list: number[]): UnderscoreNumberArrayOOPWrapper;

	(obj: any): UnderscoreObjectOOPWrapper;

	(list: any[]): UnderscoreObjectArrayOOPWrapper;

}



/**

* underscore.js template settings, set templateSettings or pass as an argument 

* to 'template()' to overide defaults.

**/

interface UnderscoreTemplateSettings {

	evaluate?: RegExp;

	interpolate?: RegExp;

	escape?: RegExp;

}



/**

* Returned interface when calling the Underscore String OOP Wrapper.  All "string" functions are

* available except the first argument is missing since that is the object being wrapped.

*

* If a function only works on lists then it is not included.

**/

interface UnderscoreStringOOPWrapper {

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

	* Collections *

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



	// There are no Collection OOP wrappers for String



	/*********

	* Arrays *

	**********/



	// There are no Array OOP wrappers for String



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

	* Functions *

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



	// There are no Function OOP wrappers for String



	/**********

	* Objects *

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



	// These don't seem entirely useful since it is known to be a string

	// but I have included them since they are all generic on "objects".



	/**

	* Returns true if object is a DOM element.

	**/

	isElement(): bool;



	/**

	* Returns true if object is an Array.

	**/

	isArray(): bool;



	/**

	* Returns true if value is an any. Note that JavaScript arrays and functions are objects,

	* while (normal) strings and numbers are not.

	**/

	isObject(): bool;



	/**

	* Returns true if object is an Arguments object.

	**/

	isArguments(): bool;



	/**

	* Returns true if object is a Function.

	**/

	isFunction(): bool;



	/**

	* Returns true if object is a String.

	**/

	isString(): bool;



	/**

	* Returns true if object is a Number (including NaN).

	**/

	isNumber(): bool;



	/**

	* Returns true if object is a finite Number.

	**/

	isFinite(): bool;



	/**

	* Returns true if object is either true or false.

	**/

	isBoolean(): bool;



	/**

	* Returns true if object is a Date.

	**/

	isDate(): bool;



	/**

	* Returns true if object is a RegExp.

	**/

	isRegExp(): bool;



	/**

	* Returns true if object is NaN.

	* Note: this is not the same as the native isNaN function,

	* which will also return true if the variable is undefined.

	**/

	isNaN(): bool;



	/**

	* Returns true if the value of object is null.

	**/

	isNull(): bool;



	/**

	* Returns true if value is undefined.

	**/

	isUndefined(): bool;



	/**********

	* Utility *

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



	/**

	* Returns the same value that is used as the argument. In math: f(x) = x

	* This function looks useless, but is used throughout Underscore as a default iterator.

	**/

	identity(): string;





	/**

	* Generate a globally-unique id for client-side models or DOM elements that need one.

	* If prefix is passed, the id will be appended to it. Without prefix, returns an integer.

	**/

	uniqueId(): string;



	/**

	* Escapes a string for insertion into HTML, replacing &, <, >, ", ', and / characters.

	**/

	escape(): string;



	/**

	* Compiles JavaScript templates into functions that can be evaluated for rendering. Useful

	* for rendering complicated bits of HTML from JSON data sources. Template functions can both

	* interpolate variables, using <%= … %>, as well as execute arbitrary JavaScript code, with

	* <% … %>. If you wish to interpolate a value, and have it be HTML-escaped, use <%- … %> When

	* you evaluate a template function, pass in a data object that has properties corresponding to

	* the template's free variables. If you're writing a one-off, you can pass the data object as

	* the second parameter to template in order to render immediately instead of returning a template

	* function. The settings argument should be a hash containing any _.templateSettings that should

	* be overridden.

	**/

	template(data?: any, settings?: UnderscoreTemplateSettings): any;



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

	* Chaining *

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



	// There are no Chaining OOP wrappers for String



	/**

	* Extracts the value of a wrapped object.

	**/

	value(): string;



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

	* OOP Wrapper *

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



	// There are no base OOP Wrappers for String

}



interface UnderscoreStringArrayOOPWrapper {

	

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

	* Collections *

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



	/**

	* Iterates over a list of elements, yielding each in turn to an iterator function. The iterator is

	* bound to the context object, if one is passed. Each invocation of iterator is called with three

	* arguments: (element, index, list). If list is a JavaScript object, iterator's arguments will be

	* (value, key, list). Delegates to the native forEach function if it exists.

	**/	

	each(

		iterator: (element: string, index?: number, list?: string[]) => any,

		context?: any): void;



	/**

	* Alias for 'each'.

	**/

	forEach(

		iterator: (element: string, index?: number, list?: string[]) => any,

		context?: any): void;



	/**

	* Produces a new array of values by mapping each value in list through a transformation function

	* (iterator). If the native map method exists, it will be used instead. If list is a JavaScript

	* object, iterator's arguments will be (value, key, list).

	**/

	map(

		iterator: (element: string, index?: number, list?: string[]) => string,

		context?: any): string[];



	/**

	* Alias for 'map'.

	**/

	collect(

		iterator: (element: string, index?: number, list?: string[]) => string,

		context?: any): string[];



	/**

	* Also known as inject and foldl, reduce boils down a list of values into a single value.

	* Memo is the initial state of the reduction, and each successive step of it should be

	* returned by iterator. The iterator is passed four arguments: the memo, then the value

	* and index (or key) of the iteration, and finally a reference to the entire list.

	**/

	reduce(

		iterator: (memo: string, element: string, index?: number, list?: string[]) => string,

		memo: string,

		context?: any): string;



	/**

	* Alias for 'reduce'.

	**/

	inject(

		iterator: (memo: string, element: string, index?: number, list?: string[]) => string,

		memo: string,

		context?: any): string;



	/**

	* Alias for 'reduce'.

	**/

	foldl(

		iterator: (memo: string, element: string, index?: number, list?: string[]) => string,

		memo: string,

		context?: any): string;



	/**

	* The right-associative version of reduce. Delegates to the JavaScript 1.8 version of

	* reduceRight, if it exists. Foldr is not as useful in JavaScript as it would be in a

	* language with lazy evaluation.

	**/

	reduceRight(

		iterator: (memo: string, element: string, index?: number, list?: string[]) => string,

		memo: string,

		context?: any): string;



	/**

	* Alias for 'reduceRight'.

	**/

	foldr(

		iterator: (memo: string, element: string, index?: number, list?: string[]) => string,

		memo: string,

		context?: any): string;



	/**

	* Looks through each value in the list, returning the first one that passes a truth

	* test (iterator). The function returns as soon as it finds an acceptable element,

	* and doesn't traverse the entire list.

	**/

	find(

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): string;



	/**

	* Alias for 'find'.

	**/

	detect(

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): string;





	/**

	* Looks through each value in the list, returning an array of all the values that pass a truth

	* test (iterator). Delegates to the native filter method, if it exists.

	**/

	filter(

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): string[];



	/**

	* Alias for 'filter'.

	**/

	select(

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): string[];





	/**

	* Returns the values in list without the elements that the truth test (iterator) passes.

	* The opposite of filter.

	**/

	reject(

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): string[];



	/**

	* Returns true if all of the values in the list pass the iterator truth test. Delegates to the

	* native method every, if present.

	**/

	all(

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): bool;



	/**

	* Alias for 'all'.

	**/

	every(

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): bool;



	/**

	* Returns true if any of the values in the list pass the iterator truth test. Short-circuits and

	* stops traversing the list if a true element is found. Delegates to the native method some, if present.

	**/

	any(

		iterator?: (element: string, index?: number, list?: string[]) => bool,

		context?: any): bool;



	/**

	* Alias for 'any'.

	**/

	some(

		iterator: (element: string, index?: number, list?: string[]) => bool,

		context?: any): bool;



	/**

	* Returns true if the value is present in the list. Uses indexOf internally,

	* if list is an Array.

	**/

	contains(value: string): bool;



	/**

	* Alias for 'contains'.

	**/

	include(value: string): bool;



	/**

	* Calls the method named by methodName on each value in the list. Any extra arguments passed to

	* invoke will be forwarded on to the method invocation.

	**/

	invoke(methodName: string, ...arguments: any[]): void;





	/**

	* Returns a sorted copy of list, ranked in ascending order by the results of running each value

	* through iterator. Iterator may also be the string name of the property to sort by (eg. length).

	**/

	sortBy(

		iterator: (element: string, index?: number, list?: string[]) => number,

		context?: any): string[];

	sortBy(iterator: string, context?: any): string[];



	/**

	* Splits a collection into sets, grouped by the result of running each value through iterator.

	* If iterator is a string instead of a function, groups by the property named by iterator on

	* each of the values.

	**/

	groupBy(

		iterator: (element: string, index?: number, list?: string[]) => string,

		context?: any): { [key: string]: string[]; };

	groupBy(iterator: string, context?: any): { [key: string]: string[]; };



	/**

	* Sorts a list into groups and returns a count for the number of objects in each group. Similar

	* to groupBy, but instead of returning a list of values, returns a count for the number of values

	* in that group.

	**/

	countBy(

		iterator: (element: string, index?: number, list?: string[]) => string,

		context?: any): { [key: string]: number; };

	countBy(iterator: string, context?: any): { [key: string]: number; };



	/**

	* Returns a shuffled copy of the list, using a version of the Fisher-Yates shuffle.

	**/

	shuffle(): string[];



	/**

	* Converts the list (anything that can be iterated over), into a real Array. Useful for transmuting

	* the arguments object.

	**/

	toArray(): string[];



	/**

	* Return the number of values in the list.

	**/

	size(): number;



	/*********

	* Arrays *

	**********/



	/**

	* Returns the first element of an array. Passing n will return the first n elements of the array.

	**/

	first(): string;

	first(n: number): string[];



	/**

	* Alias for 'first'.

	**/

	head(): string;

	head(n: number): string[];



	/**

	* Alias for 'first'.

	**/

	take(): string;

	take(n: number): string[];



	/**

	* Returns everything but the last entry of the array. Especially useful on the arguments object.

	* Pass n to exclude the last n elements from the result.

	**/

	initial(n?: number): string[];



	/**

	* Returns the last element of an array. Passing n will return the last n elements of the array.

	**/

	last(): string;

	last(n: number): string[];



	/**

	* Returns the rest of the elements in an array. Pass an index to return the values of the array

	* from that index onward.

	**/

	rest(index?: number): string[];



	/**

	* Alias for 'rest'.

	**/

	tail(index?: number): string[];



	/**

	* Alias for 'rest'.

	**/

	drop(index?: number): string[];



	/**

	* Returns a copy of the array with all falsy values removed. In JavaScript, false, null, 0, "",

	* undefined and NaN are all falsy.

	**/

	compact(): string[];



	/**

	* Flattens a nested array (the nesting can be to any depth). If you pass shallow, the array will

	* only be flattened a single level.

	**/

	flatten(shallow?: bool): string[];



	/**

	* Returns a copy of the array with all instances of the values removed.

	**/

	without(...values: string[]): string[];



	/**

	* Computes the union of the passed-in arrays: the list of unique items, in order, that are

	* present in one or more of the arrays.

	**/

	union(...arrays: string[][]): string[];



	/**

	* Computes the list of values that are the intersection of all the arrays. Each value in the result

	* is present in each of the arrays.

	**/

	intersection(...arrays: string[][]): string[];



	/**

	* Similar to without, but returns the values from array that are not present in the other arrays.

	**/

	difference(...others: string[]): string[];



	/**

	* Produces a duplicate-free version of the array, using === to test object equality. If you know in

	* advance that the array is sorted, passing true for isSorted will run a much faster algorithm. If

	* you want to compute unique items based on a transformation, pass an iterator function.

	**/

	uniq(isSorted?: bool, iterator?: (element: string, index?: number, list?: string[]) => string): string[];



	/**

	* Alias for 'uniq'.

	**/

	unique(isSorted?: bool, iterator?: (element: string, index?: number, list?: string[]) => string): string[];



	/**

	* Merges together the values of each of the arrays with the values at the corresponding position.

	* Useful when you have separate data sources that are coordinated through matching array indexes.

	* If you're working with a matrix of nested arrays, zip.apply can transpose the matrix in a similar fashion.

	**/

	zip(...arrays: string[][]): string[][];



	/**

	* Converts arrays into objects. Pass either a single list of [key, value] pairs, or a

	* list of keys, and a list of values.

	**/

	object(values: any[]): any;



	/**

	* Returns the index at which value can be found in the array, or -1 if value is not present in the array.

	* Uses the native indexOf function unless it's missing. If you're working with a large array, and you know

	* that the array is already sorted, pass true for isSorted to use a faster binary search ... or, pass a number

	* as the third argument in order to look for the first matching value in the array after the given index.

	**/

	indexOf(value: string, isSorted?: bool): number;



	/**

	* Returns the index of the last occurrence of value in the array, or -1 if value is not present. Uses the

	* native lastIndexOf function if possible. Pass fromIndex to start your search at a given index.

	**/

	lastIndexOf(value: string, from?: number): number;



	/**

	* Uses a binary search to determine the index at which the value should be inserted into the list in order

	* to maintain the list's sorted order. If an iterator is passed, it will be used to compute the sort ranking

	* of each value, including the value you pass.

	**/

	sortedIndex(value: string, iterator?: (element: string) => number): number;



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

	* Functions *

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



	// There are no Function OOP Wrappers for String[]



	/**********

	* Objects *

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

	

	/**

	* Create a shallow-copied clone of the object.

	* Any nested objects or arrays will be copied by reference, not duplicated.

	**/

	clone(): string[];



	/**

	* Returns true if object contains no values.

	**/

	isEmpty(): bool;



	/**

	* Returns true if object is a DOM element.

	**/

	isElement(): bool;



	/**

	* Returns true if object is an Array.

	**/

	isArray(): bool;



	/**

	* Returns true if value is an any. Note that JavaScript arrays and functions are objects,

	* while (normal) strings and numbers are not.

	**/

	isObject(): bool;



	/**

	* Returns true if object is an Arguments object.

	**/

	isArguments(): bool;



	/**

	* Returns true if object is a Function.

	**/

	isFunction(): bool;



	/**

	* Returns true if object is a String.

	**/

	isString(): bool;



	/**

	* Returns true if object is a Number (including NaN).

	**/

	isNumber(): bool;



	/**

	* Returns true if object is a finite Number.

	**/

	isFinite(): bool;



	/**

	* Returns true if object is either true or false.

	**/

	isBoolean(): bool;



	/**

	* Returns true if object is a Date.

	**/

	isDate(): bool;



	/**

	* Returns true if object is a RegExp.

	**/

	isRegExp(): bool;



	/**

	* Returns true if object is NaN.

	* Note: this is not the same as the native isNaN function,

	* which will also return true if the variable is undefined.

	**/

	isNaN(): bool;



	/**

	* Returns true if the value of object is null.

	**/

	isNull(): bool;



	/**

	* Returns true if value is undefined.

	**/

	isUndefined(): bool;



	/**********

	* Utility *

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



	/**

	* Returns the same value that is used as the argument. In math: f(x) = x

	* This function looks useless, but is used throughout Underscore as a default iterator.

	**/

	identity(value: string[]): string[];



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

	* Chaining *

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



	/**

	* Extracts the value of a wrapped object.

	**/

	value(): string[];



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

	* OOP Wrapper *

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



	// There are no base OOP Wrappers for String[]

}



interface UnderscoreNumberOOPWrapper {

	

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

	* Collections *

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



	// There are no Collection OOP Wrappers for Number



	/*********

	* Arrays *

	**********/



	/**

	* A function to create flexibly-numbered lists of integers, handy for each and map loops. start, if omitted,

	* defaults to 0; step defaults to 1. Returns a list of integers from start to stop, incremented (or decremented)

	* by step, exclusive.

	**/

	// start is the OOP wrapped object

	range(stop: number, step?: number): number[];

	// stop is the OOP wrapped object, cannot have step provided in this case.

	range(): number[];



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

	* Functions *

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



	/**

	* Creates a version of the function that will only be run after first being called count times. Useful

	* for grouping asynchronous responses, where you want to be sure that all the async calls have finished,

	* before proceeding.

	**/

	after(fn: Function): Function;



	/**********

	* Objects *

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



	/**

	* Returns true if object is a DOM element.

	**/

	isElement(): bool;



	/**

	* Returns true if object is an Array.

	**/

	isArray(): bool;



	/**

	* Returns true if value is an any. Note that JavaScript arrays and functions are objects,

	* while (normal) strings and numbers are not.

	**/

	isObject(): bool;



	/**

	* Returns true if object is an Arguments object.

	**/

	isArguments(): bool;



	/**

	* Returns true if object is a Function.

	**/

	isFunction(): bool;



	/**

	* Returns true if object is a String.

	**/

	isString(): bool;



	/**

	* Returns true if object is a Number (including NaN).

	**/

	isNumber(): bool;



	/**

	* Returns true if object is a finite Number.

	**/

	isFinite(): bool;



	/**

	* Returns true if object is either true or false.

	**/

	isBoolean(): bool;



	/**

	* Returns true if object is a Date.

	**/

	isDate(): bool;



	/**

	* Returns true if object is a RegExp.

	**/

	isRegExp(): bool;



	/**

	* Returns true if object is NaN.

	* Note: this is not the same as the native isNaN function,

	* which will also return true if the variable is undefined.

	**/

	isNaN(): bool;



	/**

	* Returns true if the value of object is null.

	**/

	isNull(): bool;



	/**

	* Returns true if value is undefined.

	**/

	isUndefined(): bool;



	/**********

	* Utility *

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



	/**

	* Returns the same value that is used as the argument. In math: f(x) = x

	* This function looks useless, but is used throughout Underscore as a default iterator.

	**/

	identity(value: number): number;



	/**

	* Invokes the given iterator function n times.

	* Each invocation of iterator is called with an index argument.

	* @example

	*

	* _(3).times(function(n){ genie.grantWishNumber(n); });

	*

	**/

	times(iterator: (n: number) => void , context?: any): void;



	/**

	* Returns a random integer between min and max, inclusive. If you only pass one argument,

	* it will return a number between 0 and that number.

	**/

	// max is OOP wrapped

	random(): number;

	// min is OOP wrapped

	random(max: number): number;



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

	* Chaining *

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



	/**

	* Extracts the value of a wrapped object.

	**/

	value(): number;



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

	* OOP Wrapper *

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



	// There are no base OOP Wrappers for Number

}



interface UnderscoreNumberArrayOOPWrapper {

	

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

	* Collections *

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



	/**

	* Iterates over a list of elements, yielding each in turn to an iterator function. The iterator is

	* bound to the context object, if one is passed. Each invocation of iterator is called with three

	* arguments: (element, index, list). If list is a JavaScript object, iterator's arguments will be

	* (value, key, list). Delegates to the native forEach function if it exists.

	**/	

	each(

		iterator: (element: number, index?: number, list?: number[]) => any,

		context?: any): void;



	/**

	* Alias for 'each'.

	**/

	forEach(

		iterator: (element: number, index?: number, list?: number[]) => any,

		context?: any): void;



	/**

	* Produces a new array of values by mapping each value in list through a transformation function

	* (iterator). If the native map method exists, it will be used instead. If list is a JavaScript

	* object, iterator's arguments will be (value, key, list).

	**/

	map(

		iterator: (element: number, index?: number, list?: number[]) => number,

		context?: any): number[];



	/**

	* Alias for 'map'.

	**/

	collect(

		iterator: (element: number, index?: number, list?: number[]) => number,

		context?: any): number[];



	/**

	* Also known as inject and foldl, reduce boils down a list of values into a single value.

	* Memo is the initial state of the reduction, and each successive step of it should be

	* returned by iterator. The iterator is passed four arguments: the memo, then the value

	* and index (or key) of the iteration, and finally a reference to the entire list.

	**/

	reduce(

		iterator: (memo: number, element: number, index?: number, list?: number[]) => number,

		memo: number,

		context?: any): number;



	/**

	* Alias for 'reduce'.

	**/

	inject(

		iterator: (memo: number, element: number, index?: number, list?: number[]) => number,

		memo: number,

		context?: any): number;



	/**

	* Alias for 'reduce'.

	**/

	foldl(

		iterator: (memo: number, element: number, index?: number, list?: number[]) => number,

		memo: number,

		context?: any): number;



	/**

	* The right-associative version of reduce. Delegates to the JavaScript 1.8 version of

	* reduceRight, if it exists. Foldr is not as useful in JavaScript as it would be in a

	* language with lazy evaluation.

	**/

	reduceRight(

		iterator: (memo: number, element: number, index?: number, list?: number[]) => number,

		memo: number,

		context?: any): number;



	/**

	* Alias for 'reduceRight'.

	**/

	foldr(

		iterator: (memo: number, element: number, index?: number, list?: number[]) => number,

		memo: number,

		context?: any): number;



	/**

	* Looks through each value in the list, returning the first one that passes a truth

	* test (iterator). The function returns as soon as it finds an acceptable element,

	* and doesn't traverse the entire list.

	**/

	find(

		iterator: (element: number, index?: number, list?: number[]) => bool,

		context?: any): number;



	/**

	* Alias for 'find'.

	**/

	detect(

		iterator: (element: number, index?: number, list?: number[]) => bool,

		context?: any): number;





	/**

	* Looks through each value in the list, returning an array of all the values that pass a truth

	* test (iterator). Delegates to the native filter method, if it exists.

	**/

	filter(

		iterator: (element: number, index?: number, list?: number[]) => bool,

		context?: any): number[];



	/**

	* Alias for 'filter'.

	**/

	select(

		iterator: (element: number, index?: number, list?: number[]) => bool,

		context?: any): number[];



	/**

	* Returns the values in list without the elements that the truth test (iterator) passes.

	* The opposite of filter.

	**/

	reject(

		iterator: (element: number, index?: number, list?: number[]) => bool,

		context?: any): number[];



	/**

	* Returns true if all of the values in the list pass the iterator truth test. Delegates to the

	* native method every, if present.

	**/

	all(

		iterator: (element: number, index?: number, list?: string[]) => bool,

		context?: any): bool;



	/**

	* Alias for 'all'.

	**/

	every(

		iterator: (element: number, index?: number, list?: string[]) => bool,

		context?: any): bool;



	/**

	* Returns true if any of the values in the list pass the iterator truth test. Short-circuits and

	* stops traversing the list if a true element is found. Delegates to the native method some, if present.

	**/

	any(

		iterator?: (element: number, index?: number, list?: string[]) => bool,

		context?: any): bool;



	/**

	* Alias for 'any'.

	**/

	some(

		iterator: (element: number, index?: number, list?: string[]) => bool,

		context?: any): bool;



	/**

	* Returns true if the value is present in the list. Uses indexOf internally,

	* if list is an Array.

	**/

	contains(value: number): bool;



	/**

	* Alias for 'contains'.

	**/

	include(value: number): bool;



	/**

	* Calls the method named by methodName on each value in the list. Any extra arguments passed to

	* invoke will be forwarded on to the method invocation.

	**/

	invoke(methodName: string, ...arguments: any[]): void;



	/**

	* Returns the maximum value in list. If iterator is passed, it will be used on each value to generate

	* the criterion by which the value is ranked.

	**/

	max(): number;



	/**

	* Returns the minimum value in list. If iterator is passed, it will be used on each value to generate

	* the criterion by which the value is ranked.

	**/

	min(): number;



	/**

	* Returns a sorted copy of list, ranked in ascending order by the results of running each value

	* through iterator. Iterator may also be the string name of the property to sort by (eg. length).

	**/

	sortBy(

		iterator: (element: number, index?: number, list?: number[]) => number,

		context?: any): number[];

	sortBy(iterator: string, context?: any): number[];



	/**

	* Splits a collection into sets, grouped by the result of running each value through iterator.

	* If iterator is a string instead of a function, groups by the property named by iterator on

	* each of the values.

	**/

	groupBy(

		iterator: (element: number, index?: number, list?: number[]) => string,

		context?: any): { [key: string]: number[]; };

	groupBy(iterator: string, context?: any): { [key: string]: number[]; };



	/**

	* Sorts a list into groups and returns a count for the number of objects in each group. Similar

	* to groupBy, but instead of returning a list of values, returns a count for the number of values

	* in that group.

	**/

	countBy(

		iterator: (element: number, index?: number, list?: number[]) => string,

		context?: any): { [key: string]: number; };

	countBy(iterator: string, context?: any): { [key: string]: number; };



	/**

	* Returns a shuffled copy of the list, using a version of the Fisher-Yates shuffle.

	**/

	shuffle(): number[];



	/**

	* Converts the list (anything that can be iterated over), into a real Array. Useful for transmuting

	* the arguments object.

	**/

	toArray(): number[];



	/**

	* Return the number of values in the list.

	**/

	size(): number;



	/*********

	* Arrays *

	**********/



	/**

	* Returns the first element of an array. Passing n will return the first n elements of the array.

	**/

	first(): number;

	first(n: number): number[];



	/**

	* Alias for 'first'.

	**/

	head(): number;

	head(n: number): number[];



	/**

	* Alias for 'first'.

	**/

	take(): number;

	take(n: number): number[];



	/**

	* Returns everything but the last entry of the array. Especially useful on the arguments object.

	* Pass n to exclude the last n elements from the result.

	**/

	initial(n?: number): number[];



	/**

	* Returns the last element of an array. Passing n will return the last n elements of the array.

	**/

	last(): number;

	last(n: number): number[];



	/**

	* Returns the rest of the elements in an array. Pass an index to return the values of the array

	* from that index onward.

	**/

	rest(index?: number): number[];



	/**

	* Alias for 'rest'.

	**/

	tail(index?: number): number[];



	/**

	* Alias for 'rest'.

	**/

	drop(index?: number): number[];



	/**

	* Returns a copy of the array with all falsy values removed. In JavaScript, false, null, 0, "",

	* undefined and NaN are all falsy.

	**/

	compact(): number[];



	/**

	* Flattens a nested array (the nesting can be to any depth). If you pass shallow, the array will

	* only be flattened a single level.

	**/

	flatten(shallow?: bool): number[];



	/**

	* Returns a copy of the array with all instances of the values removed.

	**/

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



	/**

	* Computes the union of the passed-in arrays: the list of unique items, in order, that are

	* present in one or more of the arrays.

	**/

	union(...arrays: number[][]): number[];



	/**

	* Computes the list of values that are the intersection of all the arrays. Each value in the result

	* is present in each of the arrays.

	**/

	intersection(...arrays: number[][]): number[];



	/**

	* Similar to without, but returns the values from array that are not present in the other arrays.

	**/

	difference(...others: number[]): number[];



	/**

	* Produces a duplicate-free version of the array, using === to test object equality. If you know in

	* advance that the array is sorted, passing true for isSorted will run a much faster algorithm. If

	* you want to compute unique items based on a transformation, pass an iterator function.

	**/

	uniq(isSorted?: bool, iterator?: (element: number, index?: number, list?: number[]) => number): number[];



	/**

	* Alias for 'uniq'.

	**/

	unique(isSorted?: bool, iterator?: (element: number, index?: number, list?: number[]) => number): number[];



	/**

	* Merges together the values of each of the arrays with the values at the corresponding position.

	* Useful when you have separate data sources that are coordinated through matching array indexes.

	* If you're working with a matrix of nested arrays, zip.apply can transpose the matrix in a similar fashion.

	**/

	zip(...arrays: number[][]): number[][];



	/**

	* Returns the index at which value can be found in the array, or -1 if value is not present in the array.

	* Uses the native indexOf function unless it's missing. If you're working with a large array, and you know

	* that the array is already sorted, pass true for isSorted to use a faster binary search ... or, pass a number

	* as the third argument in order to look for the first matching value in the array after the given index.

	**/

	indexOf(value: number, isSorted?: bool): number;



	/**

	* Returns the index of the last occurrence of value in the array, or -1 if value is not present. Uses the

	* native lastIndexOf function if possible. Pass fromIndex to start your search at a given index.

	**/

	lastIndexOf(value: number, from?: number): number;



	/**

	* Uses a binary search to determine the index at which the value should be inserted into the list in order

	* to maintain the list's sorted order. If an iterator is passed, it will be used to compute the sort ranking

	* of each value, including the value you pass.

	**/

	sortedIndex(value: number, iterator?: (element: number) => number): number;



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

	* Functions *

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



	// There are no Function OOP Wrappers for Number[]



	/**********

	* Objects *

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

	

	/**

	* Create a shallow-copied clone of the object.

	* Any nested objects or arrays will be copied by reference, not duplicated.

	**/

	clone(): number[];



	/**

	* Returns true if object contains no values.

	**/

	isEmpty(): bool;



	/**

	* Returns true if object is a DOM element.

	**/

	isElement(): bool;



	/**

	* Returns true if object is an Array.

	**/

	isArray(): bool;



	/**

	* Returns true if value is an any. Note that JavaScript arrays and functions are objects,

	* while (normal) strings and numbers are not.

	**/

	isObject(): bool;



	/**

	* Returns true if object is an Arguments object.

	**/

	isArguments(): bool;



	/**

	* Returns true if object is a Function.

	**/

	isFunction(): bool;



	/**

	* Returns true if object is a String.

	**/

	isString(): bool;



	/**

	* Returns true if object is a Number (including NaN).

	**/

	isNumber(): bool;



	/**

	* Returns true if object is a finite Number.

	**/

	isFinite(): bool;



	/**

	* Returns true if object is either true or false.

	**/

	isBoolean(): bool;



	/**

	* Returns true if object is a Date.

	**/

	isDate(): bool;



	/**

	* Returns true if object is a RegExp.

	**/

	isRegExp(): bool;



	/**

	* Returns true if object is NaN.

	* Note: this is not the same as the native isNaN function,

	* which will also return true if the variable is undefined.

	**/

	isNaN(): bool;



	/**

	* Returns true if the value of object is null.

	**/

	isNull(): bool;



	/**

	* Returns true if value is undefined.

	**/

	isUndefined(): bool;



	/**********

	* Utility *

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



	/**

	* Returns the same value that is used as the argument. In math: f(x) = x

	* This function looks useless, but is used throughout Underscore as a default iterator.

	**/

	identity(): number[];



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

	* Chaining *

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



	/**

	* Extracts the value of a wrapped object.

	**/

	value(): number[];



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

	* OOP Wrapper *

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



	// There are no base OOP Wrappers for Number[]

}



interface UnderscoreObjectOOPWrapper {

	

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

	* Collections *

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



	/**

	* Iterates over a list of elements, yielding each in turn to an iterator function. The iterator is

	* bound to the context object, if one is passed. Each invocation of iterator is called with three

	* arguments: (element, index, list). If list is a JavaScript object, iterator's arguments will be

	* (value, key, list). Delegates to the native forEach function if it exists.

	**/	

	each(

		iterator: (value: any, key?: string, object?: any) => any,

		context?: any): void;



	/**

	* Alias for 'each'.

	**/

	forEach(

		iterator: (value: any, key?: string, object?: any) => any,

		context?: any): void;



	/**

	* Produces a new array of values by mapping each value in list through a transformation function

	* (iterator). If the native map method exists, it will be used instead. If list is a JavaScript

	* object, iterator's arguments will be (value, key, list).

	**/

	map(

		iterator: (value: any, key?: string, object?: any) => any,

		context?: any): any[];



	/**

	* Alias for 'map'.

	**/

	collect(

		iterator: (value: any, key?: string, object?: any) => any,

		context?: any): any[];



	/*********

	* Arrays *

	**********/



	// There are no Array OOP Wrappers for any



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

	* Functions *

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



	/**

	* Binds a number of methods on the object, specified by methodNames, to be run in the context of that object

	* whenever they are invoked. Very handy for binding functions that are going to be used as event handlers,

	* which would otherwise be invoked with a fairly useless this. If no methodNames are provided, all of the

	* object's function properties will be bound to it.

	**/

	bindAll(...methodNames: string[]): void;



	/**********

	* Objects *

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



	/**

	* Retrieve all the names of the object's properties.

	**/

	keys(): string[];



	/**

	* Return all of the values of the object's properties.

	**/

	values(): any[];



	/**

	* Convert an object into a list of [key, value] pairs.

	**/

	pairs(): any[][];



	/**

	* Returns a copy of the object where the keys have become the values and the values the keys.

	* For this to work, all of your object's values should be unique and string serializable.

	**/

	invert(): any;



	/**

	* Returns a sorted list of the names of every method in an object — that is to say,

	* the name of every function property of the object.

	**/

	functions(): string[];



	/**

	* Copy all of the properties in the source objects over to the destination object, and return

	* the destination object. It's in-order, so the last source will override properties of the

	* same name in previous arguments.

	**/

	extend(...sources: any[]): any;



	/**

	* Return a copy of the object, filtered to only have values for the whitelisted keys

	* (or array of valid keys).

	**/

	pick(...keys: string[]): any;



	/**

	* Return a copy of the object, filtered to omit the blacklisted keys (or array of keys).

	**/

	omit(...keys: string[]): any;



	/**

	* Fill in null and undefined properties in object with values from the defaults objects,

	* and return the object. As soon as the property is filled, further defaults will have no effect.

	**/

	defaults(...defaults: any[]): any;



	/**

	* Create a shallow-copied clone of the object.

	* Any nested objects or arrays will be copied by reference, not duplicated.

	**/

	clone(): any;



	/**

	* Invokes interceptor with the object, and then returns object. The primary purpose of this method

	* is to "tap into" a method chain, in order to perform operations on intermediate results within the chain.

	**/

	tap(intercepter: Function): any;



	/**

	* Does the object contain the given key? Identical to object.hasOwnProperty(key), but uses a safe

	* reference to the hasOwnProperty function, in case it's been overridden accidentally.

	**/

	has(key: string): bool;



	/**

	* Performs an optimized deep comparison between the two objects,

	* to determine if they should be considered equal.

	**/

	isEqual(other: any): bool;



	/**

	* Returns true if object contains no values.

	**/

	isEmpty(): bool;



	/**

	* Returns true if object is a DOM element.

	**/

	isElement(): bool;



	/**

	* Returns true if object is an Array.

	**/

	isArray(): bool;



	/**

	* Returns true if value is an any. Note that JavaScript arrays and functions are objects,

	* while (normal) strings and numbers are not.

	**/

	isObject(): bool;



	/**

	* Returns true if object is an Arguments object.

	**/

	isArguments(): bool;



	/**

	* Returns true if object is a Function.

	**/

	isFunction(): bool;



	/**

	* Returns true if object is a String.

	**/

	isString(): bool;



	/**

	* Returns true if object is a Number (including NaN).

	**/

	isNumber(): bool;



	/**

	* Returns true if object is a finite Number.

	**/

	isFinite(): bool;



	/**

	* Returns true if object is either true or false.

	**/

	isBoolean(): bool;



	/**

	* Returns true if object is a Date.

	**/

	isDate(): bool;



	/**

	* Returns true if object is a RegExp.

	**/

	isRegExp(): bool;



	/**

	* Returns true if object is NaN.

	* Note: this is not the same as the native isNaN function,

	* which will also return true if the variable is undefined.

	**/

	isNaN(): bool;



	/**

	* Returns true if the value of object is null.

	**/

	isNull(): bool;



	/**

	* Returns true if value is undefined.

	**/

	isUndefined(): bool;



	/**********

	* Utility *

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



	/**

	* Returns the same value that is used as the argument. In math: f(x) = x

	* This function looks useless, but is used throughout Underscore as a default iterator.

	**/

	identity(value: any): any;



	/**

	* Allows you to extend Underscore with your own utility functions. Pass a hash of

	* {name: function} definitions to have your functions added to the Underscore object,

	* as well as the OOP wrapper.

	* @example

	*

	* _.mixin({

	*     capitalize : function(string) {

	*         return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();

	*     }

	* });

	* _("fabio").capitalize();

	* => "Fabio"

	*

	**/

	mixin(): void;



	/**

	* If the value of the named property is a function then invoke it; otherwise, return it.

	**/

	result(property: string): any;



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

	* Chaining *

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



	/**

	* Returns a wrapped object. Calling methods on this object will continue to return wrapped objects

	* until value is used.

	**/

	chain(): any;



	/**

	* Extracts the value of a wrapped object.

	**/

	value(): any;



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

	* OOP Wrapper *

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



	// There are no base OOP Wrappers for any

}



interface UnderscoreObjectArrayOOPWrapper {

	

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

	* Collections *

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



	/**

	* Iterates over a list of elements, yielding each in turn to an iterator function. The iterator is

	* bound to the context object, if one is passed. Each invocation of iterator is called with three

	* arguments: (element, index, list). If list is a JavaScript object, iterator's arguments will be

	* (value, key, list). Delegates to the native forEach function if it exists.

	**/	

	each(

		iterator: (element: any, index?: number, list?: any[]) => any,

		context?: any): void;



	/**

	* Alias for 'each'.

	**/

	forEach(

		iterator: (element: any, index?: number, list?: any[]) => any,

		context?: any): void;



	/**

	* Produces a new array of values by mapping each value in list through a transformation function

	* (iterator). If the native map method exists, it will be used instead. If list is a JavaScript

	* object, iterator's arguments will be (value, key, list).

	**/

	map(

		iterator: (element: any, index?: number, list?: any[]) => any,

		context?: any): any[];



	/**

	* Alias for 'map'.

	**/

	collect(

		iterator: (element: any, index?: number, list?: any[]) => any,

		context?: any): any[];



	/**

	* Also known as inject and foldl, reduce boils down a list of values into a single value.

	* Memo is the initial state of the reduction, and each successive step of it should be

	* returned by iterator. The iterator is passed four arguments: the memo, then the value

	* and index (or key) of the iteration, and finally a reference to the entire list.

	**/

	reduce(

		iterator: (memo: any, element: any, index?: number, list?: any[]) => any,

		memo: any,

		context?: any): any;



	/**

	* Alias for 'reduce'.

	**/

	inject(

		iterator: (memo: any, element: any, index?: number, list?: any[]) => any,

		memo: any,

		context?: any): any;



	/**

	* Alias for 'reduce'.

	**/

	foldl(

		iterator: (memo: any, element: any, index?: number, list?: any[]) => any,

		memo: any,

		context?: any): any;



	/**

	* The right-associative version of reduce. Delegates to the JavaScript 1.8 version of

	* reduceRight, if it exists. Foldr is not as useful in JavaScript as it would be in a

	* language with lazy evaluation.

	**/

	reduceRight(

		iterator: (memo: any, element: any, index?: number, list?: any[]) => any,

		memo: any,

		context?: any): any;



	/**

	* Alias for 'reduceRight'.

	**/

	foldr(

		iterator: (memo: any, element: any, index?: number, list?: any[]) => any,

		memo: any,

		context?: any): any;



	/**

	* Looks through each value in the list, returning the first one that passes a truth

	* test (iterator). The function returns as soon as it finds an acceptable element,

	* and doesn't traverse the entire list.

	**/

	find(

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): any;



	/**

	* Alias for 'find'.

	**/

	detect(

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): any;





	/**

	* Looks through each value in the list, returning an array of all the values that pass a truth

	* test (iterator). Delegates to the native filter method, if it exists.

	**/

	filter(

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): any[];



	/**

	* Alias for 'filter'.

	**/

	select(

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): any[];



	/**

	* Looks through each value in the list, returning an array of all the values that contain all

	* of the key-value pairs listed in properties.

	**/

	where(properties: any): any[];



	/**

	* Returns the values in list without the elements that the truth test (iterator) passes.

	* The opposite of filter.

	**/

	reject(

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): any[];



	/**

	* Returns true if all of the values in the list pass the iterator truth test. Delegates to the

	* native method every, if present.

	**/

	all(

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): bool;



	/**

	* Alias for 'all'.

	**/

	every(

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): bool;



	/**

	* Returns true if any of the values in the list pass the iterator truth test. Short-circuits and

	* stops traversing the list if a true element is found. Delegates to the native method some, if present.

	**/

	any(

		iterator?: (element: any, index?: number, list?: any[]) => bool,

		context?: any): bool;



	/**

	* Alias for 'any'.

	**/

	some(

		iterator: (element: any, index?: number, list?: any[]) => bool,

		context?: any): bool;



	/**

	* Returns true if the value is present in the list. Uses indexOf internally,

	* if list is an Array.

	**/

	contains(value: any): bool;



	/**

	* Alias for 'contains'.

	**/

	include(value: any): bool;



	/**

	* Calls the method named by methodName on each value in the list. Any extra arguments passed to

	* invoke will be forwarded on to the method invocation.

	**/

	invoke(methodName: string, ...arguments: any[]): void;



	/**

	* A convenient version of what is perhaps the most common use-case for map: extracting a list of

	* property values.

	**/

	pluck(propertyName: string): any[];



	/**

	* Returns the maximum value in list. If iterator is passed, it will be used on each value to generate

	* the criterion by which the value is ranked.

	**/

	max(

		iterator: (element: any, index?: number, list?: any[]) => number,

		context?: any): any;



	/**

	* Returns the minimum value in list. If iterator is passed, it will be used on each value to generate

	* the criterion by which the value is ranked.

	**/

	min(

		iterator: (obj: any, index?: number, list?: any[]) => number,

		context?: any): any;



	/**

	* Returns a sorted copy of list, ranked in ascending order by the results of running each value

	* through iterator. Iterator may also be the string name of the property to sort by (eg. length).

	**/

	sortBy(

		iterator: (element: any, index?: number, list?: any[]) => number,

		context?: any): any[];

	sortBy(iterator: string, context?: any): any[];



	/**

	* Splits a collection into sets, grouped by the result of running each value through iterator.

	* If iterator is a string instead of a function, groups by the property named by iterator on

	* each of the values.

	**/

	groupBy(

		iterator: (element: any, index?: number, list?: any[]) => string,

		context?: any): { [key: string]: any[]; };

	groupBy(iterator: string, context?: any): { [key: string]: any[]; };



	/**

	* Sorts a list into groups and returns a count for the number of objects in each group. Similar

	* to groupBy, but instead of returning a list of values, returns a count for the number of values

	* in that group.

	**/

	countBy(

		iterator: (element: any, index?: number, list?: any[]) => string,

		context?: any): { [key: string]: number; };

	countBy(iterator: string, context?: any): { [key: string]: number; };



	/**

	* Returns a shuffled copy of the list, using a version of the Fisher-Yates shuffle.

	**/

	shuffle(): any[];



	/**

	* Converts the list (anything that can be iterated over), into a real Array. Useful for transmuting

	* the arguments object.

	**/

	toArray(): any[];



	/**

	* Return the number of values in the list.

	**/

	size(): number;



	/*********

	* Arrays *

	**********/



	/**

	* Returns the first element of an array. Passing n will return the first n elements of the array.

	**/

	first(): any;

	first(n: number): any[];



	/**

	* Alias for 'first'.

	**/

	head(): any;

	head(n: number): any[];



	/**

	* Alias for 'first'.

	**/

	take(): any;

	take(n: number): any[];



	/**

	* Returns everything but the last entry of the array. Especially useful on the arguments object.

	* Pass n to exclude the last n elements from the result.

	**/

	initial(n?: number): any[];



	/**

	* Returns the last element of an array. Passing n will return the last n elements of the array.

	**/

	last(): any;

	last(n: number): any[];



	/**

	* Returns the rest of the elements in an array. Pass an index to return the values of the array

	* from that index onward.

	**/

	rest(index?: number): any[];



	/**

	* Alias for 'rest'.

	**/

	tail(index?: number): any[];



	/**

	* Alias for 'rest'.

	**/

	drop(index?: number): any[];



	/**

	* Returns a copy of the array with all falsy values removed. In JavaScript, false, null, 0, "",

	* undefined and NaN are all falsy.

	**/

	compact(): any[];



	/**

	* Flattens a nested array (the nesting can be to any depth). If you pass shallow, the array will

	* only be flattened a single level.

	**/

	flatten(shallow?: bool): any[];



	/**

	* Returns a copy of the array with all instances of the values removed.

	**/

	without(...values: any[]): any[];



	/**

	* Computes the union of the passed-in arrays: the list of unique items, in order, that are

	* present in one or more of the arrays.

	**/

	union(...arrays: any[][]): any[];



	/**

	* Computes the list of values that are the intersection of all the arrays. Each value in the result

	* is present in each of the arrays.

	**/

	intersection(...arrays: any[][]): any[];



	/**

	* Similar to without, but returns the values from array that are not present in the other arrays.

	**/

	difference(...others: any[]): any[];



	/**

	* Produces a duplicate-free version of the array, using === to test object equality. If you know in

	* advance that the array is sorted, passing true for isSorted will run a much faster algorithm. If

	* you want to compute unique items based on a transformation, pass an iterator function.

	**/

	uniq(isSorted?: bool, iterator?: (element: any, index?: number, list?: any[]) => any): any[];



	/**

	* Alias for 'uniq'.

	**/

	unique(isSorted?: bool, iterator?: (element: any, index?: number, list?: any[]) => any): any[];



	/**

	* Merges together the values of each of the arrays with the values at the corresponding position.

	* Useful when you have separate data sources that are coordinated through matching array indexes.

	* If you're working with a matrix of nested arrays, zip.apply can transpose the matrix in a similar fashion.

	**/

	zip(...arrays: any[][]): any[][];



	/**

	* Returns the index at which value can be found in the array, or -1 if value is not present in the array.

	* Uses the native indexOf function unless it's missing. If you're working with a large array, and you know

	* that the array is already sorted, pass true for isSorted to use a faster binary search ... or, pass a number

	* as the third argument in order to look for the first matching value in the array after the given index.

	**/

	indexOf(value: any, isSorted?: bool): number;



	/**

	* Returns the index of the last occurrence of value in the array, or -1 if value is not present. Uses the

	* native lastIndexOf function if possible. Pass fromIndex to start your search at a given index.

	**/

	lastIndexOf(value: any, from?: number): number;



	/**

	* Uses a binary search to determine the index at which the value should be inserted into the list in order

	* to maintain the list's sorted order. If an iterator is passed, it will be used to compute the sort ranking

	* of each value, including the value you pass.

	**/

	sortedIndex(value: any, iterator?: (element: any) => number): number;



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

	* Functions *

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



	// There are no Function OOP Wrappers for any[]



	/**********

	* Objects *

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

	

	/**

	* Create a shallow-copied clone of the object.

	* Any nested objects or arrays will be copied by reference, not duplicated.

	**/

	clone(list: any[]): any[];



	/**

	* Returns true if object contains no values.

	**/

	isEmpty(): bool;



	/**

	* Returns true if object is a DOM element.

	**/

	isElement(): bool;



	/**

	* Returns true if object is an Array.

	**/

	isArray(): bool;



	/**

	* Returns true if value is an any. Note that JavaScript arrays and functions are objects,

	* while (normal) strings and numbers are not.

	**/

	isObject(): bool;



	/**

	* Returns true if object is an Arguments object.

	**/

	isArguments(): bool;



	/**

	* Returns true if object is a Function.

	**/

	isFunction(): bool;



	/**

	* Returns true if object is a String.

	**/

	isString(): bool;



	/**

	* Returns true if object is a Number (including NaN).

	**/

	isNumber(): bool;



	/**

	* Returns true if object is a finite Number.

	**/

	isFinite(): bool;



	/**

	* Returns true if object is either true or false.

	**/

	isBoolean(): bool;



	/**

	* Returns true if object is a Date.

	**/

	isDate(): bool;



	/**

	* Returns true if object is a RegExp.

	**/

	isRegExp(): bool;



	/**

	* Returns true if object is NaN.

	* Note: this is not the same as the native isNaN function,

	* which will also return true if the variable is undefined.

	**/

	isNaN(): bool;



	/**

	* Returns true if the value of object is null.

	**/

	isNull(): bool;



	/**

	* Returns true if value is undefined.

	**/

	isUndefined(): bool;



	/**********

	* Utility *

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



	/**

	* Returns the same value that is used as the argument. In math: f(x) = x

	* This function looks useless, but is used throughout Underscore as a default iterator.

	**/

	identity(): any[];



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

	* Chaining *

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



	/**

	* Returns a wrapped object. Calling methods on this object will continue to return wrapped objects

	* until value is used.

	**/

	chain(): any;



	/**

	* Extracts the value of a wrapped object.

	**/

	value(): any[];



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

	* OOP Wrapper *

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



	// There are no base OOP Wrappers for any[]

}





declare var _: Underscore;