diff --git a/README.md b/README.md
index b2e60d65a..2d552bfc1 100755
--- a/README.md
+++ b/README.md
@@ -159,6 +159,7 @@ List of Definitions
 * [Levelup](https://github.com/rvagg/node-levelup) (by [Bret Little](https://github.com/blittle))
 * [linq.js](http://linqjs.codeplex.com/) (by [Marcin Najder](https://github.com/marcinnajder))
 * [Livestamp.js](https://github.com/mattbradley/livestampjs) (by [Vincent Bortone](https://github.com/vbortone))
+* [Lodash](http://lodash.com/) (by [Brian Zengel](https://github.com/bczengel))
 * [Logg](https://github.com/dpup/node-logg) (by [Bret Little](https://github.com/blittle))
 * [Marked](https://github.com/chjj/marked) (by [William Orr](https://github.com/worr))
 * [mCustomScrollbar](https://github.com/malihu/malihu-custom-scrollbar-plugin) (by [Sarah Williams] (https://github.com/flurg))
@@ -243,7 +244,6 @@ Requested Definitions
 * [google.visualizations](https://developers.google.com/chart/)
 * [Prelude.ls](http://gkz.github.com/prelude-ls/)
 * [MooTools](http://mootools.net/)
-* [Lo-Dash](http://lodash.com/)
 * [java](https://github.com/nearinfinity/node-java)
 * [SVG.js](http://www.svgjs.com/)
 
diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
new file mode 100644
index 000000000..400d8664a
--- /dev/null
+++ b/lodash/lodash-tests.ts
@@ -0,0 +1,929 @@
+/// <reference path="lodash.d.ts" />
+
+declare var $: any, jQuery: any;
+
+interface IFoodOrganic {
+	name: string;
+	organic: boolean;
+}
+
+interface IFoodType {
+	name: string;
+	type: string;
+}
+
+interface IFoodCombined {
+	name: string;
+	organic: boolean;
+	type: string;
+}
+
+interface IStoogesQuote {
+	name: string;
+	quotes: string[];
+}
+
+interface IStoogesAge {
+	name: string;
+	age: number;
+}
+
+interface IStoogesCombined {
+	name: string;
+	age: number;
+	quotes: string[];
+}
+
+interface IKey {
+	dir: string;
+	code: number;
+}
+
+var foodsOrganic: IFoodOrganic[] = [
+	{ name: 'banana', organic: true },
+	{ name: 'beet',   organic: false },
+];
+var foodsType: IFoodType[] = [
+	{ name: 'apple',  type: 'fruit' },
+	{ name: 'banana', type: 'fruit' },
+	{ name: 'beet',   type: 'vegetable' }
+];
+var foodsCombined: IFoodCombined[] = [
+  { 'name': 'apple',  'organic': false, 'type': 'fruit' },
+  { 'name': 'carrot', 'organic': true,  'type': 'vegetable' }
+];
+
+var stoogesQuotes: IStoogesQuote[] = [
+	{ 'name': 'curly', 'quotes': ['Oh, a wise guy, eh?', 'Poifect!'] },
+	{ 'name': 'moe', 'quotes': ['Spread out!', 'You knucklehead!'] }
+];
+var stoogesAges: IStoogesAge[] = [
+	{ 'name': 'moe', 'age': 40 },
+	{ 'name': 'larry', 'age': 50 }
+];
+
+var stoogesCombined: IStoogesCombined[] = [
+  { 'name': 'curly', 'age': 30, 'quotes': ['Oh, a wise guy, eh?', 'Poifect!'] },
+  { 'name': 'moe', 'age': 40, 'quotes': ['Spread out!', 'You knucklehead!'] }
+];
+
+var keys: IKey[] = [
+  { 'dir': 'left', 'code': 97 },
+  { 'dir': 'right', 'code': 100 }
+];
+
+class Dog {
+	constructor(public name: string) {}
+
+	public bark() {
+	  console.log('Woof, woof!');
+	}
+}
+
+var result : any;
+
+/*************
+ * Chaining *
+ *************/
+result = <_.LoDashWrapper<string>>_('test');
+result = <_.LoDashWrapper<number>>_(1);
+result = <_.LoDashWrapper<boolean>>_(true);
+result = <_.LoDashArrayWrapper<string>>_(['test1', 'test2']);
+result = <_.LoDashObjectWrapper<_.Dictionary<string>>>_({'key1': 'test1', 'key2': 'test2'});
+
+result = <_.LoDashWrapper<string>>_.chain('test');
+result = <_.LoDashWrapper<string>>_('test').chain();
+result = <_.LoDashWrapper<number>>_.chain(1);
+result = <_.LoDashWrapper<number>>_(1).chain();
+result = <_.LoDashWrapper<boolean>>_.chain(true);
+result = <_.LoDashWrapper<boolean>>_(true).chain();
+result = <_.LoDashArrayWrapper<string>>_.chain(['test1', 'test2']);
+result = <_.LoDashArrayWrapper<string>>_(['test1', 'test2']).chain();
+result = <_.LoDashObjectWrapper<_.Dictionary<string>>>_.chain({'key1': 'test1', 'key2': 'test2'});
+result = <_.LoDashObjectWrapper<_.Dictionary<string>>>_({'key1': 'test1', 'key2': 'test2'}).chain();
+
+//Wrapped array shortcut methods
+result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).concat(5, 6);
+result = <_.LoDashWrapper<string>>_([1, 2, 3, 4]).join(',');
+result = <_.LoDashWrapper<number>>_([1, 2, 3, 4]).pop();
+_([1, 2, 3, 4]).push(5, 6, 7);
+result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).reverse();
+result = <_.LoDashWrapper<number>>_([1, 2, 3, 4]).shift();
+result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).slice(1, 2);
+result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).slice(2);
+result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).sort((a, b) => 1);
+result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).splice(1);
+result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).splice(1, 2, 5, 6);
+result = <_.LoDashWrapper<number>>_([1, 2, 3, 4]).unshift(5, 6);
+
+result = <number[]>_.tap([1, 2, 3, 4], function(array) { console.log(array); });
+result = <_.LoDashWrapper<string>>_('test').tap(function(value) { console.log(value); });
+result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).tap(function(array) { console.log(array); });
+result = <_.LoDashObjectWrapper<_.Dictionary<string>>>_({'key1': 'test1', 'key2': 'test2'}).tap(function(array) { console.log(array); });
+
+result = <string>_('test').toString();
+result = <string>_([1, 2, 3]).toString();
+result = <string>_({'key1': 'test1', 'key2': 'test2'}).toString();
+
+result = <string>_('test').valueOf();
+result = <number[]>_([1, 2, 3]).valueOf();
+result = <_.Dictionary<string>>_({'key1': 'test1', 'key2': 'test2'}).valueOf();
+
+result = <string>_('test').value();
+result = <number[]>_([1, 2, 3]).value();
+result = <_.Dictionary<string>>_({'key1': 'test1', 'key2': 'test2'}).value();
+
+// /*************
+//  * Arrays *
+//  *************/
+result = <any[]>_.compact([0, 1, false, 2, '', 3]);
+	result = <_.LoDashArrayWrapper<any>>_([0, 1, false, 2, '', 3]).compact();
+
+result = <number[]>_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
+	result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4, 5]).difference([5, 2, 10]);
+
+result = <number[]>_.rest([1, 2, 3]);
+result = <number[]>_.rest([1, 2, 3], 2);
+result = <number[]>_.rest([1, 2, 3], (num) => num < 3)
+result = <IFoodOrganic[]>_.rest(foodsOrganic, 'test');
+result = <IFoodType[]>_.rest(foodsType, { 'type': 'value' });
+
+result = <number[]>_.drop([1, 2, 3]);
+result = <number[]>_.drop([1, 2, 3], 2);
+result = <number[]>_.drop([1, 2, 3], (num) => num < 3)
+result = <IFoodOrganic[]>_.drop(foodsOrganic, 'test');
+result = <IFoodType[]>_.drop(foodsType, { 'type': 'value' });
+
+result = <number[]>_.tail([1, 2, 3])
+result = <number[]>_.tail([1, 2, 3], 2)
+result = <number[]>_.tail([1, 2, 3], (num) => num < 3)
+result = <IFoodOrganic[]>_.tail(foodsOrganic, 'test')
+result = <IFoodType[]> _.tail(foodsType, { 'type': 'value' })
+
+result = <number>_.findIndex(['apple', 'banana', 'beet'], function(f) {
+  return /^b/.test(f);
+});
+result = <number>_.findIndex(['apple', 'banana', 'beet'], 'apple');
+result = <number>_.findIndex([{ food: 'apple' }, { food: 'banana' }, { food: 'beet' }], { food: 'apple'});
+
+result = <number>_.findLastIndex(['apple', 'banana', 'beet'], function(f: string) {
+  return /^b/.test(f);
+});
+result = <number>_.findLastIndex(['apple', 'banana', 'beet'], 'apple');
+result = <number>_.findLastIndex([{ food: 'apple' }, { food: 'banana' }, { food: 'beet' }], { food: 'apple'});
+
+result = <number>_.first([1, 2, 3]);
+result = <number[]>_.first([1, 2, 3], 2);
+result = <number[]>_.first([1, 2, 3], function(num) {
+  return num < 3;
+});
+result = <IFoodOrganic[]>_.first(foodsOrganic, 'organic');
+result = <IFoodType[]>_.first(foodsType, { 'type': 'fruit' });
+
+	result = <number>_.head([1, 2, 3]);
+	result = <number[]>_.head([1, 2, 3], 2);
+	result = <number[]>_.head([1, 2, 3], function(num) {
+	  return num < 3;
+	});
+	result = <IFoodOrganic[]>_.head(foodsOrganic, 'organic');
+	result = <IFoodType[]>_.head(foodsType, { 'type': 'fruit' });
+
+	result = <number>_.take([1, 2, 3]);
+	result = <number[]>_.take([1, 2, 3], 2);
+    result = <number[]>_.take([1, 2, 3], (num) => num < 3);
+	result = <IFoodOrganic[]>_.take(foodsOrganic, 'organic');
+	result = <IFoodType[]>_.take(foodsType, { 'type': 'fruit' });
+
+result = <number[]>_.flatten([1, [2], [3, [[4]]]]);
+result = <any[]>_.flatten([1, [2], [3, [[4]]]], true);
+var result: any
+result = <string[]>_.flatten(stoogesQuotes, 'quotes');
+
+	result = <_.LoDashArrayWrapper<number>>_([1, [2], [3, [[4]]]]).flatten();
+	result = <_.LoDashArrayWrapper<number>>_([1, [2], [3, [[4]]]]).flatten(true);
+	result = <_.LoDashArrayWrapper<string>>_(stoogesQuotes).flatten('quotes');
+
+result = <number>_.indexOf([1, 2, 3, 1, 2, 3], 2);
+result = <number>_.indexOf([1, 2, 3, 1, 2, 3], 2, 3);
+result = <number>_.indexOf([1, 1, 2, 2, 3, 3], 2, true);
+
+result = <number[]>_.initial([1, 2, 3]);
+result = <number[]>_.initial([1, 2, 3], 2);
+result = <number[]>_.initial([1, 2, 3], function(num) {
+  return num > 1;
+});
+result = <IFoodOrganic[]>_.initial(foodsOrganic, 'organic');
+result = <IFoodType[]>_.initial(foodsType, { 'type': 'vegetable' });
+
+result = <number[]>_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+
+result = <number>_.last([1, 2, 3]);
+result = <number[]>_.last([1, 2, 3], 2);
+result = <number[]>_.last([1, 2, 3], function(num) {
+  return num > 1;
+});
+result = <IFoodOrganic[]>_.last(foodsOrganic, 'organic');
+result = <IFoodType[]>_.last(foodsType, { 'type': 'vegetable' });
+
+result = <number>_.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
+result = <number>_.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3);
+
+result = <{[key: string]: any}>_.zipObject(['moe', 'larry'], [30, 40]);
+	result = <{[key: string]: any}>_.object(['moe', 'larry'], [30, 40]);
+
+result = <any[]>_.pull([1, 2, 3, 1, 2, 3], 2, 3);
+
+result = <number[]>_.range(10);
+result = <number[]>_.range(1, 11);
+result = <number[]>_.range(0, 30, 5);
+result = <number[]>_.range(0, -10, -1);
+result = <number[]>_.range(1, 4, 0);
+result = <number[]>_.range(0);
+
+result = <number[]>_.remove([1, 2, 3, 4, 5, 6], function(num: number) { return num % 2 == 0; });
+result = <IFoodOrganic[]>_.remove(foodsOrganic, 'organic');
+result = <IFoodType[]>_.remove(foodsType, { 'type': 'vegetable'});
+
+result = <number>_.sortedIndex([20, 30, 50], 40);
+result = <number>_.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
+var sortedIndexDict = {
+  'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 }
+};
+result = <number>_.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+  return sortedIndexDict.wordToNumber[word];
+});
+result = <number>_.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+  return this.wordToNumber[word];
+}, sortedIndexDict);
+
+result = <number[]>_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+
+result = <number[]>_.uniq([1, 2, 1, 3, 1]);
+result = <number[]>_.uniq([1, 1, 2, 2, 3], true);
+result = <string[]>_.uniq(['A', 'b', 'C', 'a', 'B', 'c'], function(letter) { 
+	return letter.toLowerCase(); 
+});
+result = <number[]>_.uniq([1, 2.5, 3, 1.5, 2, 3.5], function(num) { return this.floor(num); }, Math);
+result = <{x: number;}[]>_.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+
+	result = <number[]>_.unique([1, 2, 1, 3, 1]);
+	result = <number[]>_.unique([1, 1, 2, 2, 3], true);
+	result = <string[]>_.unique(['A', 'b', 'C', 'a', 'B', 'c'], function(letter) { 
+		return letter.toLowerCase(); 
+	});
+	result = <number[]>_.unique([1, 2.5, 3, 1.5, 2, 3.5], function(num) { return this.floor(num); }, Math);
+	result = <{x: number;}[]>_.unique([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+
+result = <number[]>_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
+
+result = <any[][]>_.zip(['moe', 'larry'], [30, 40], [true, false]);
+	result = <any[][]>_.unzip(['moe', 'larry'], [30, 40], [true, false]);
+
+// /* *************
+//  * Collections *
+//  ************* */
+
+result = <string[]>_.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]);
+result = <string[]>_.at(['moe', 'larry', 'curly'], 0, 2);
+
+result = <boolean>_.contains([1, 2, 3], 1);
+result = <boolean>_.contains([1, 2, 3], 1, 2);
+result = <boolean>_.contains({ 'name': 'moe', 'age': 40 }, 'moe');
+result = <boolean>_.contains('curly', 'ur');
+
+	result = <boolean>_.include([1, 2, 3], 1);
+	result = <boolean>_.include([1, 2, 3], 1, 2);
+	result = <boolean>_.include({ 'name': 'moe', 'age': 40 }, 'moe');
+	result = <boolean>_.include('curly', 'ur');
+
+result = <_.Dictionary<number>>_.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); });
+result = <_.Dictionary<number>>_.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+result = <_.Dictionary<number>>_.countBy(['one', 'two', 'three'], 'length');
+
+	result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_([4.3, 6.1, 6.4]).countBy(function(num) { return Math.floor(num); });
+	result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_([4.3, 6.1, 6.4]).countBy(function(num) { return this.floor(num); }, Math);
+	result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_(['one', 'two', 'three']).countBy('length');
+
+result = <boolean>_.every([true, 1, null, 'yes'], Boolean);
+result = <boolean>_.every(stoogesAges, 'age');
+result = <boolean>_.every(stoogesAges, { 'age': 50 });
+
+	result = <boolean>_.all([true, 1, null, 'yes'], Boolean);
+	result = <boolean>_.all(stoogesAges, 'age');
+	result = <boolean>_.all(stoogesAges, { 'age': 50 });
+
+result = <number[]>_.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+result = <IFoodCombined[]>_.filter(foodsCombined, 'organic');
+result = <IFoodCombined[]>_.filter(foodsCombined, { 'type': 'fruit' });
+
+	result = <number[]>_([1, 2, 3, 4, 5, 6]).filter(function(num) { return num % 2 == 0; });
+	result = <IFoodCombined[]>_(foodsCombined).filter('organic');
+	result = <IFoodCombined[]>_(foodsCombined).filter({ 'type': 'fruit' });
+
+	result = <number[]>_.select([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+	result = <IFoodCombined[]>_.select(foodsCombined, 'organic');
+	result = <IFoodCombined[]>_.select(foodsCombined, { 'type': 'fruit' });
+
+		result = <number[]>_([1, 2, 3, 4, 5, 6]).select(function(num) { return num % 2 == 0; });
+		result = <IFoodCombined[]>_(foodsCombined).select('organic');
+		result = <IFoodCombined[]>_(foodsCombined).select({ 'type': 'fruit' });
+
+result = <number>_.find([1, 2, 3, 4], function(num) {
+  return num % 2 == 0;
+});
+result = <IFoodCombined>_.find(foodsCombined, { 'type': 'vegetable' });
+result = <IFoodCombined>_.find(foodsCombined, 'organic');
+
+	result = <number>_.detect([1, 2, 3, 4], function(num) {
+	  return num % 2 == 0;
+	});
+	result = <IFoodCombined>_.detect(foodsCombined, { 'type': 'vegetable' });
+	result = <IFoodCombined>_.detect(foodsCombined, 'organic');
+
+	result = <number>_.findWhere([1, 2, 3, 4], function(num) {
+	  return num % 2 == 0;
+	});
+	result = <IFoodCombined>_.findWhere(foodsCombined, { 'type': 'vegetable' });
+	result = <IFoodCombined>_.findWhere(foodsCombined, 'organic');
+
+result = <number>_.findLast([1, 2, 3, 4], function(num) {
+  return num % 2 == 0;
+});
+result = <IFoodCombined>_.findLast(foodsCombined, { 'type': 'vegetable' });
+result = <IFoodCombined>_.findLast(foodsCombined, 'organic');
+
+result = <number[]>_.forEach([1, 2, 3], function(num) { console.log(num); });
+result = <_.Dictionary<number>>_.forEach({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
+
+	result = <number[]>_.each([1, 2, 3], function(num) { console.log(num); });
+	result = <_.Dictionary<number>>_.each({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
+
+	result = <_.LoDashArrayWrapper<number>>_([1, 2, 3]).forEach(function(num) { console.log(num); });
+	result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_({ 'one': 1, 'two': 2, 'three': 3 }).forEach(function(num) { console.log(num); });	
+
+		result = <_.LoDashArrayWrapper<number>>_([1, 2, 3]).each(function(num) { console.log(num); });
+		result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_({ 'one': 1, 'two': 2, 'three': 3 }).each(function(num) { console.log(num); });	
+
+result = <number[]>_.forEachRight([1, 2, 3], function(num) { console.log(num); });
+result = <_.Dictionary<number>>_.forEachRight({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
+
+	result = <number[]>_.eachRight([1, 2, 3], function(num) { console.log(num); });
+	result = <_.Dictionary<number>>_.eachRight({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
+
+	result = <_.LoDashArrayWrapper<number>>_([1, 2, 3]).forEachRight(function(num) { console.log(num); });
+	result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_({ 'one': 1, 'two': 2, 'three': 3 }).forEachRight(function(num) { console.log(num); });
+
+		result = <_.LoDashArrayWrapper<number>>_([1, 2, 3]).eachRight(function(num) { console.log(num); });
+		result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_({ 'one': 1, 'two': 2, 'three': 3 }).eachRight(function(num) { console.log(num); });
+
+result = <_.Dictionary<number[]>>_.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); });
+result = <_.Dictionary<number[]>>_.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+result = <_.Dictionary<string[]>>_.groupBy(['one', 'two', 'three'], 'length');
+
+	result = <_.LoDashObjectWrapper<_.Dictionary<number[]>>>_([4.2, 6.1, 6.4]).groupBy(function(num) { return Math.floor(num); });
+	result = <_.LoDashObjectWrapper<_.Dictionary<number[]>>>_([4.2, 6.1, 6.4]).groupBy(function(num) { return this.floor(num); }, Math);
+	result = <_.LoDashObjectWrapper<_.Dictionary<string[]>>>_(['one', 'two', 'three']).groupBy('length');
+
+result = <_.Dictionary<IKey>>_.indexBy(keys, 'dir');
+result = <_.Dictionary<IKey>>_.indexBy(keys, function(key) { return String.fromCharCode(key.code); });
+result = <_.Dictionary<IKey>>_.indexBy(keys, function(key) { this.fromCharCode(key.code); }, String);
+
+result = <any[]>_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+result = <any[]>_.invoke([123, 456], String.prototype.split, '');
+
+result = <any[]>_.map([1, 2, 3], function(num) { return num * 3; });
+result = <any[]>_.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });
+result = <any[]>_.map(stoogesAges, 'name');
+
+	result = <any[]>_.collect([1, 2, 3], function(num) { return num * 3; });
+	result = <any[]>_.collect({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });
+	result = <any[]>_.collect(stoogesAges, 'name');
+
+result = <number>_.max([4, 2, 8, 6]);
+result = <IStoogesAge>_.max(stoogesAges, function(stooge) { return stooge.age; });
+result = <IStoogesAge>_.max(stoogesAges, 'age');
+
+result = <number>_.min([4, 2, 8, 6]);
+result = <IStoogesAge>_.min(stoogesAges, function(stooge) { return stooge.age; });
+result = <IStoogesAge>_.min(stoogesAges, 'age');
+
+result = <string[]>_.pluck(stoogesAges, 'name');
+
+result = <number>_.reduce<number, number>([1, 2, 3], function(sum: number, num: number) {
+  return sum + num;
+});
+result = <any>_.reduce<number, any>({ 'a': 1, 'b': 2, 'c': 3 }, function(r: any, num: number, key: string) {
+  r[key] = num * 3;
+  return r;
+}, {});
+
+	result = <any>_.foldl([1, 2, 3], function(sum: number, num: number) {
+	  return sum + num;
+	});
+	result = <any>_.foldl({ 'a': 1, 'b': 2, 'c': 3 }, function(r: any, num: number, key: string) {
+	  r[key] = num * 3;
+	  return r;
+	}, {});
+
+	result = <any>_.inject([1, 2, 3], function(sum: number, num: number) {
+	  return sum + num;
+	});
+	result = <any>_.inject({ 'a': 1, 'b': 2, 'c': 3 }, function(r: any, num: number, key: string) {
+	  r[key] = num * 3;
+	  return r;
+	}, {});
+
+result = <any>_.reduceRight([[0, 1], [2, 3], [4, 5]], function(a: number[], b: number[]) { return a.concat(b); }, []);
+	result = <any>_.foldr([[0, 1], [2, 3], [4, 5]], function(a: number[], b: number[]) { return a.concat(b); }, []);
+
+result = <number[]>_.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+result = <IFoodCombined[]>_.reject(foodsCombined, 'organic');
+result = <IFoodCombined[]>_.reject(foodsCombined, { 'type': 'fruit' });
+
+result = <number>_.sample([1, 2, 3, 4]);
+result = <number[]>_.sample([1, 2, 3, 4], 2);
+
+result = <number[]>_.shuffle([1, 2, 3, 4, 5, 6]);
+
+result = <number>_.size([1, 2]);
+result = <number>_.size({ 'one': 1, 'two': 2, 'three': 3 });
+result = <number>_.size('curly');
+
+result = <boolean>_.some([null, 0, 'yes', false], Boolean);
+result = <boolean>_.some(foodsCombined, 'organic');
+result = <boolean>_.some(foodsCombined, { 'type': 'meat' });
+	
+	result = <boolean>_.any([null, 0, 'yes', false], Boolean);
+	result = <boolean>_.any(foodsCombined, 'organic');
+	result = <boolean>_.any(foodsCombined, { 'type': 'meat' });
+	
+result = <number[]>_.sortBy([1, 2, 3], function(num) { return Math.sin(num); });
+result = <number[]>_.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math);
+result = <string[]>_.sortBy(['banana', 'strawberry', 'apple'], 'length');
+
+(function(a: any, b: any, c: any, d: any){ return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
+
+result = <IStoogesCombined[]>_.where(stoogesCombined, { 'age': 40 });
+result = <IStoogesCombined[]>_.where(stoogesCombined, { 'quotes': ['Poifect!'] });
+	
+/*************
+ * Functions *
+ *************/
+var saves = ['profile', 'settings'];
+var asyncSave = (obj: any) => obj.done();
+var done: Function;
+
+done = _.after(saves.length, function() {
+  console.log('Done saving!');
+});
+
+_.forEach(saves, function(type) {
+  asyncSave({ 'type': type, 'complete': done });
+});
+
+done = _(saves.length).after(function() {
+  console.log('Done saving!');
+}).value();
+
+_.forEach(saves, function(type) {
+  asyncSave({ 'type': type, 'complete': done });
+});
+
+var funcBind = function (greeting: string) { return greeting + ' ' + this.name };
+var funcBind2: () => any = _.bind(funcBind, { 'name': 'moe' }, 'hi');
+funcBind2();
+
+var funcBind3: () => any = _(funcBind).bind({ 'name': 'moe' }, 'hi').value();
+funcBind3();
+
+var view = {
+ 'label': 'docs',
+ 'onClick': function() { console.log('clicked ' + this.label); }
+};
+
+view = _.bindAll(view);
+jQuery('#docs').on('click', view.onClick);
+
+view = _(view).bindAll().value();
+jQuery('#docs').on('click', view.onClick);
+
+var objectBindKey = {
+  'name': 'moe',
+  'greet': function(greeting: string) {
+    return greeting + ' ' + this.name;
+  }
+};
+
+var funcBindKey: Function = _.bindKey(objectBindKey, 'greet', 'hi');
+funcBindKey();
+
+objectBindKey.greet = function(greeting) {
+  return greeting + ', ' + this.name + '!';
+};
+
+funcBindKey();
+
+funcBindKey = _(objectBindKey).bindKey('greet', 'hi').value();
+funcBindKey();
+
+var realNameMap = {
+  'curly': 'jerome'
+};
+
+var format = function(name: string) {
+  name = realNameMap[name.toLowerCase()] || name;
+  return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+};
+
+var greet = function(formatted: string) {
+  return 'Hiya ' + formatted + '!';
+};
+
+result = <Function>_.compose(greet, format);
+result = <_.LoDashObjectWrapper<Function>>_(greet).compose(format);
+
+var createCallbackObj = { name: 'Joe' };
+result = <() => any>_.createCallback('name');
+result = <() => boolean>_.createCallback(createCallbackObj);
+result = <_.LoDashObjectWrapper<() => any>>_('name').createCallback();
+result = <_.LoDashObjectWrapper<() => boolean>>_(createCallbackObj).createCallback();
+
+result = <Function>_.curry(function(a, b, c) {
+  	console.log(a + b + c);
+});
+
+result = <_.LoDashObjectWrapper<Function>>_(function(a, b, c) {
+  	console.log(a + b + c);
+}).curry();
+
+declare var source: any;
+result = <Function>_.debounce(function() {}, 150);
+
+jQuery('#postbox').on('click', <Function>_.debounce(function() {}, 300, {
+  'leading': true,
+  'trailing': false
+}));
+
+source.addEventListener('message', <Function>_.debounce(function() {}, 250, {
+  'maxWait': 1000
+}), false);
+
+result = <_.LoDashObjectWrapper<Function>>_(function() {}).debounce(150);
+
+jQuery('#postbox').on('click', <_.LoDashObjectWrapper<Function>>_(function() {}).debounce(300, {
+  'leading': true,
+  'trailing': false
+}));
+
+source.addEventListener('message', <_.LoDashObjectWrapper<Function>>_(function() {}).debounce(250, {
+  'maxWait': 1000
+}), false);
+
+result = <number>_.defer(function() { console.log('deferred'); });
+result = <_.LoDashWrapper<number>>_(function() { console.log('deferred'); }).defer();
+
+var log = _.bind(console.log, console);
+result = <number>_.delay(log, 1000, 'logged later');
+result = <_.LoDashWrapper<number>>_(log).delay(1000, 'logged later');
+
+var fibonacci = <Function>_.memoize(function(n) {
+  return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+});
+
+var data = {
+  'moe': { 'name': 'moe', 'age': 40 },
+  'curly': { 'name': 'curly', 'age': 60 }
+};
+
+var stooge = <Function>_.memoize(function(name: string) { return data[name]; }, _.identity);
+stooge('curly');
+
+stooge['cache']['curly'].name = 'jerome';
+stooge('curly');
+
+var initialize = <Function>_.once(function(){ });
+initialize();
+initialize();
+
+var greetPartial = function(greeting: string, name: string) { return greeting + ' ' + name; };
+var hi = <Function>_.partial(greetPartial, 'hi');
+hi('moe');
+
+var defaultsDeep = <Function>_.partialRight(_.merge, _.defaults);
+
+var optionsPartialRight = {
+  'variable': 'data',
+  'imports': { 'jq': $ }
+};
+
+defaultsDeep(optionsPartialRight, _.templateSettings);
+
+var throttled = _.throttle(function () { }, 100);
+jQuery(window).on('scroll', throttled);
+
+jQuery('.interactive').on('click', _.throttle(function() { }, 300000, {
+  'trailing': false
+}));
+
+var helloWrap = function(name: string) { return 'hello ' + name; };
+var helloWrap2 = _.wrap(helloWrap, function(func) {
+  return 'before, ' + func('moe') + ', after';
+});
+helloWrap2();
+
+/**********
+* Objects *
+***********/
+result = <any>_.assign({ 'name': 'moe' }, { 'age': 40 });
+result = <any>_.assign({ 'name': 'moe' }, { 'age': 40 }, function(a: any, b: any) {
+  return typeof a == 'undefined' ? b : a;
+});
+
+result = <_.LoDashObjectWrapper<any>>_({ 'name': 'moe' }).assign({ 'age': 40 });
+result = <_.LoDashObjectWrapper<any>>_({ 'name': 'moe' }).assign({ 'age': 40 }, function(a: any, b: any) {
+  return typeof a == 'undefined' ? b : a;
+});
+
+	result = <any>_.extend({ 'name': 'moe' }, { 'age': 40 });
+	result = <any>_.extend({ 'name': 'moe' }, { 'age': 40 }, function(a: any, b: any) {
+	  return typeof a == 'undefined' ? b : a;
+	});
+
+	result = <_.LoDashObjectWrapper<any>>_({ 'name': 'moe' }).extend({ 'age': 40 });
+	result = <_.LoDashObjectWrapper<any>>_({ 'name': 'moe' }).extend({ 'age': 40 }, function(a: any, b: any) {
+	  return typeof a == 'undefined' ? b : a;
+	});
+
+var result = <any>_.clone(stoogesAges);
+var result = <any>_.clone(stoogesAges, true);
+var result = <any>_.clone(stoogesAges, true, function(value) {
+    return _.isElement(value) ? value.cloneNode(false) : undefined;
+});
+
+var result = <any>_.cloneDeep(stoogesAges);
+var result = <any>_.cloneDeep(stoogesAges, function(value) {
+    return _.isElement(value) ? value.cloneNode(false) : undefined;
+});
+
+var foodDefaults = { 'name': 'apple' };
+result = <any>_.defaults(foodDefaults, { 'name': 'banana', 'type': 'fruit' });
+result = <any>_(foodDefaults).defaults({ 'name': 'banana', 'type': 'fruit' });
+
+result = <string>_.findKey({ 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, function(num) {
+  return num % 2 == 0;
+});
+
+result = <string>_.findLastKey({ 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, function(num) {
+  return num % 2 == 1;
+});
+
+result = <any>_.forIn(new Dog('Dagny'), function(value, key) {
+  console.log(key);
+});
+
+	result = <_.LoDashObjectWrapper<any>>_(new Dog('Dagny')).forIn(function(value, key) {
+	  console.log(key);
+	});
+
+result = <any>_.forInRight(new Dog('Dagny'), function(value, key) {
+  console.log(key);
+});
+
+	result = <_.LoDashObjectWrapper<any>>_(new Dog('Dagny')).forInRight(function(value, key) {
+	  console.log(key);
+	});
+
+result = <any>_.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+  console.log(key);
+});
+
+	result = <_.LoDashObjectWrapper<any>>_({ '0': 'zero', '1': 'one', 'length': 2 }).forOwn(function(num, key) {
+	  console.log(key);
+	});
+
+result = <any>_.forOwnRight({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+  console.log(key);
+});
+
+	result = <_.LoDashObjectWrapper<any>>_({ '0': 'zero', '1': 'one', 'length': 2 }).forOwnRight(function(num, key) {
+	  console.log(key);
+	});
+
+result = <string[]>_.functions(_);
+ 	result = <string[]>_.methods(_);
+
+ 	result = <_.LoDashArrayWrapper<string>>_(_).functions();
+ 		result = <_.LoDashArrayWrapper<string>>_(_).methods();
+
+result = <boolean>_.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');
+
+result = <any>_.invert({ 'first': 'moe', 'second': 'larry' });
+
+(function(...args: any[]) { return <boolean>_.isArguments(arguments); })(1, 2, 3);
+
+(function () { return <boolean>_.isArray(arguments); })();
+result = <boolean>_.isArray([1, 2, 3]);
+
+result = <boolean>_.isBoolean(null);
+
+result = <boolean>_.isDate(new Date());
+
+result = <boolean>_.isElement(document.body);
+
+result = <boolean>_.isEmpty([1, 2, 3]);
+result = <boolean>_.isEmpty({});
+result = <boolean>_.isEmpty('');
+
+var moe = { 'name': 'moe', 'age': 40 };
+var copy = { 'name': 'moe', 'age': 40 };
+
+result = <boolean>_.isEqual(moe, copy);
+
+var words = ['hello', 'goodbye'];
+var otherWords = ['hi', 'goodbye'];
+
+result = <boolean>_.isEqual(words, otherWords, function(a, b) {
+  var reGreet = /^(?:hello|hi)$/i,
+      aGreet = _.isString(a) && reGreet.test(a),
+      bGreet = _.isString(b) && reGreet.test(b);
+
+  return (aGreet || bGreet) ? (aGreet == bGreet) : undefined;
+});
+
+result = <boolean>_.isFinite(-101);
+result = <boolean>_.isFinite('10');
+result = <boolean>_.isFinite(true);
+result = <boolean>_.isFinite('');
+result = <boolean>_.isFinite(Infinity);
+
+result = <boolean>_.isFunction(_);
+
+result = <boolean>_.isNaN(NaN);
+result = <boolean>_.isNaN(new Number(NaN));
+result = <boolean>_.isNaN(undefined);
+
+result = <boolean>_.isNull(null);
+result = <boolean>_.isNull(undefined);
+
+result = <boolean>_.isNumber(8.4 * 5);
+
+result = <boolean>_.isObject({});
+result = <boolean>_.isObject([1, 2, 3]);
+result = <boolean>_.isObject(1);
+
+class Stooge {
+	constructor(
+		public name: string,
+		public age: number
+	) {}
+}
+
+result = <boolean>_.isPlainObject(new Stooge('moe', 40));
+result = <boolean>_.isPlainObject([1, 2, 3]);
+result = <boolean>_.isPlainObject({ 'name': 'moe', 'age': 40 });
+
+result = <boolean>_.isRegExp(/moe/);
+
+result = <boolean>_.isString('moe');
+
+result = <boolean>_.isUndefined(void 0);
+
+result = <string[]>_.keys({ 'one': 1, 'two': 2, 'three': 3 });
+
+var mergeNames = {
+  'stooges': [
+    { 'name': 'moe' },
+    { 'name': 'larry' }
+  ]
+};
+
+var mergeAges = {
+  'stooges': [
+    { 'age': 40 },
+    { 'age': 50 }
+  ]
+};
+
+result = <any>_.merge(mergeNames, mergeAges);
+
+var mergeFood = {
+  'fruits': ['apple'],
+  'vegetables': ['beet']
+};
+
+var mergeOtherFood = {
+  'fruits': ['banana'],
+  'vegetables': ['carrot']
+};
+
+result = <any>_.merge(mergeFood, mergeOtherFood, function(a: any, b: any) {
+  return _.isArray(a) ? a.concat(b) : undefined;
+});
+
+result = <any>_.omit({ 'name': 'moe', 'age': 40 }, 'age');
+result = <any>_.omit({ 'name': 'moe', 'age': 40 }, ['age']);
+result = <any>_.omit({ 'name': 'moe', 'age': 40 }, function(value) {
+  return typeof value == 'number';
+});
+
+result = <any[][]>_.pairs({ 'moe': 30, 'larry': 40 });
+
+result = <any>_.pick({ 'name': 'moe', '_userid': 'moe1' }, 'name');
+result = <any>_.pick({ 'name': 'moe', '_userid': 'moe1' }, ['name']);
+result = <any>_.pick({ 'name': 'moe', '_userid': 'moe1' }, function(value, key) {
+  return key.charAt(0) != '_';
+});
+
+result = <any>_.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(r: any, num: number) {
+  num *= num;
+  if (num % 2) {
+    return r.push(num) < 3;
+  }
+});
+// → [1, 9, 25]
+
+result = <any>_.transform({ 'a': 1, 'b': 2, 'c': 3 }, function(r: any, num: number, key: string) {
+  r[key] = num * 3;
+});
+
+result = <any[]>_.values({ 'one': 1, 'two': 2, 'three': 3 });
+
+/**********
+* Utilities *
+***********/
+
+result = <string>_.escape('Moe, Larry & Curly');
+
+result = <{ name: string }>_.identity({ 'name': 'moe' });
+
+_.mixin({
+  'capitalize': function(string) {
+    return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+  }
+});
+
+var lodash = <typeof _>_.noConflict();
+
+result = <number>_.parseInt('08');
+
+result = <number>_.random(0, 5);
+result = <number>_.random(5);
+result = <number>_.random(5, true);
+result = <number>_.random(1.2, 5.2);
+result = <number>_.random(0, 5, true);
+
+var object = {
+  'cheese': 'crumpets',
+  'stuff': function() {
+    return 'nonsense';
+  }
+};
+
+result = <any>_.result(object, 'cheese');
+result = <any>_.result(object, 'stuff');
+
+var tempObject = {};
+result = <typeof _>_.runInContext(tempObject);
+
+result = <_.TemplateExecutor>_.template('hello <%= name %>');
+result = <string>_.template('<b><%- value %></b>', { 'value': '<script>' });
+
+var listTemplate = '<% _.forEach(people, function(name) { %><li><%- name %></li><% }); %>';
+result = <string>_.template(listTemplate, { 'people': ['moe', 'larry'] });
+result = <string>_.template('hello ${ name }', { 'name': 'curly' });
+result = <string>_.template('<% print("hello " + name); %>!', { 'name': 'larry' });
+
+var listTemplate = '<% $.each(people, function(name) { %><li><%- name %></li><% }); %>';
+result = <string>_.template(listTemplate, { 'people': ['moe', 'larry'] }, { 'imports': { '$': jQuery } });
+result = <_.TemplateExecutor>_.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });
+
+result = <_.TemplateExecutor>_.template('hi <%= data.name %>!', null, { 'variable': 'data' });
+result = <string>(<_.TemplateExecutor>result).source;
+
+class Mage {
+	public castSpell(n: number) {
+		return n;
+	}
+
+	public cast(n: number) {
+		return n;
+	}
+}
+
+var mage = new Mage(); 
+result = <any[]>_.times(3, _.partial(_.random, 1, 6));
+result = <any[]>_.times(3, function(n: number) { mage.castSpell(n); });
+result = <any[]>_.times(3, function(n: number) { this.cast(n); }, mage);
+
+result = <string>_.unescape('Moe, Larry &amp; Curly');
+
+result = <string>_.uniqueId('contact_');
+result = <string>_.uniqueId();
+
+/**********
+* Utilities *
+***********/
+
+result = <string>_.VERSION;
+result = <_.Support>_.support;
+result = <_.TemplateSettings>_.templateSettings;
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
new file mode 100644
index 000000000..98c7f11cc
--- /dev/null
+++ b/lodash/lodash.d.ts
@@ -0,0 +1,4045 @@
+// Type definitions for Lo-Dash
+// Project: http://lodash.com/
+// Definitions by: Brian Zengel <https://github.com/bczengel>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare var _: _.LoDashStatic;
+
+declare module _ {
+	interface LoDashStatic {
+		/**
+		* Creates a lodash object which wraps the given value to enable intuitive method chaining.
+		*
+		* In addition to Lo-Dash methods, wrappers also have the following Array methods:
+		* concat, join, pop, push, reverse, shift, slice, sort, splice, and unshift
+		*
+		* Chaining is supported in custom builds as long as the value method is implicitly or 
+		* explicitly included in the build.
+		*
+		* The chainable wrapper functions are:
+		* after, assign, bind, bindAll, bindKey, chain, compact, compose, concat, countBy, 
+		* createCallback, curry, debounce, defaults, defer, delay, difference, filter, flatten, 
+		* forEach, forEachRight, forIn, forInRight, forOwn, forOwnRight, functions, groupBy, 
+		* indexBy, initial, intersection, invert, invoke, keys, map, max, memoize, merge, min, 
+		* object, omit, once, pairs, partial, partialRight, pick, pluck, pull, push, range, reject, 
+		* remove, rest, reverse, shuffle, slice, sort, sortBy, splice, tap, throttle, times, 
+		* toArray, transform, union, uniq, unshift, unzip, values, where, without, wrap, and zip
+		*
+		* The non-chainable wrapper functions are:
+		* clone, cloneDeep, contains, escape, every, find, findIndex, findKey, findLast, 
+		* findLastIndex, findLastKey, has, identity, indexOf, isArguments, isArray, isBoolean, 
+		* isDate, isElement, isEmpty, isEqual, isFinite, isFunction, isNaN, isNull, isNumber, 
+		* isObject, isPlainObject, isRegExp, isString, isUndefined, join, lastIndexOf, mixin, 
+		* noConflict, parseInt, pop, random, reduce, reduceRight, result, shift, size, some, 
+		* sortedIndex, runInContext, template, unescape, uniqueId, and value
+		*
+		* The wrapper functions first and last return wrapped values when n is provided, otherwise 
+		* they return unwrapped values.
+		*
+		* Explicit chaining can be enabled by using the _.chain method.
+		**/
+		(value: number): LoDashWrapper<number>;
+		(value: string): LoDashWrapper<string>;
+		(value: boolean): LoDashWrapper<boolean>;
+		<T>(value: Array<T>): LoDashArrayWrapper<T>;
+		<T extends {}>(value: T): LoDashObjectWrapper<T>;
+		(value: any): LoDashWrapper<any>;
+
+		/**
+		* The semantic version number.
+		**/
+		VERSION: string;
+
+		/**
+		* An object used to flag environments features.
+		**/
+		support: Support;
+
+		/**
+		* By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby 
+		* (ERB). Change the following template settings to use alternative delimiters.
+		**/
+		templateSettings: TemplateSettings;
+	}
+
+	/**
+	* By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby 
+	* (ERB). Change the following template settings to use alternative delimiters.
+	**/
+	interface TemplateSettings {
+		/**
+		* The "escape" delimiter.
+		**/
+		escape?: RegExp;
+
+		/**
+		* The "evaluate" delimiter.
+		**/
+		evaluate?: RegExp;
+
+		/**
+		* An object to import into the template as local variables.
+		**/
+		imports?: Dictionary<any>;
+
+		/**
+		* The "interpolate" delimiter.
+		**/
+		interpolate?: RegExp;
+
+		/**
+		* Used to reference the data object in the template text.
+		**/
+		variable?: string;
+	}
+
+	/**
+	* An object used to flag environments features.
+	**/
+	interface Support {
+		/**
+		* Detect if an arguments object’s [[Class]] is resolvable (all but Firefox < 4, IE < 9).
+		**/
+		argsClass: boolean;
+
+		/**
+		* Detect if arguments objects are Object objects (all but Narwhal and Opera < 10.5).
+		**/
+		argsObject: boolean;
+
+		/**
+		* Detect if name or message properties of Error.prototype are enumerable by default. 
+		* (IE < 9, Safari < 5.1)
+		**/
+		enumErrorProps: boolean;
+
+		/**
+		* Detect if Function#bind exists and is inferred to be fast (all but V8).
+		**/
+		fastBind: boolean;
+
+		/**
+		* Detect if functions can be decompiled by Function#toString (all but PS3 and older Opera 
+		* mobile browsers & avoided in Windows 8 apps).
+		**/
+		funcDecomp: boolean;
+
+		/**
+		* Detect if Function#name is supported (all but IE).
+		**/
+		funcNames: boolean;
+
+		/**
+		* Detect if arguments object indexes are non-enumerable (Firefox < 4, IE < 9, PhantomJS, 
+		* Safari < 5.1).
+		**/
+		nonEnumArgs: boolean;
+
+		/**
+		* Detect if properties shadowing those on Object.prototype are non-enumerable.
+		*
+		* In IE < 9 an objects own properties, shadowing non-enumerable ones, are made 
+		* non-enumerable as well (a.k.a the JScript [[DontEnum]] bug).
+		**/
+		nonEnumShadows: boolean;
+
+		/**
+		* Detect if own properties are iterated after inherited properties (all but IE < 9).
+		**/
+		ownLast: boolean;
+
+		/**
+		* Detect if Array#shift and Array#splice augment array-like objects correctly.
+		*
+		* Firefox < 10, IE compatibility mode, and IE < 9 have buggy Array shift() and splice() 
+		* functions that fail to remove the last element, value[0], of array-like objects even 
+		* though the length property is set to 0. The shift() method is buggy in IE 8 compatibility 
+		* mode, while splice() is buggy regardless of mode in IE < 9 and buggy in compatibility mode
+		* in IE 9.
+		**/
+		spliceObjects: boolean;
+
+		/**
+		* Detect lack of support for accessing string characters by index.
+		*
+		* IE < 8 can't access characters by index and IE 8 can only access characters by index on 
+		* string literals.
+		**/
+		unindexedChars: boolean;
+	}
+
+	interface LoDashWrapperBase<T, TWrapper> {
+		/**
+		* Produces the toString result of the wrapped value.
+		* @return Returns the string result.
+		**/
+		toString(): string;
+
+		/**
+		* Extracts the wrapped value.
+		* @return The wrapped value.
+		**/
+		valueOf(): T;
+
+			/**
+			* @see valueOf
+			**/
+			value(): T;
+	} 
+
+	interface LoDashWrapper<T> extends LoDashWrapperBase<T, LoDashWrapper<T>> {}
+
+	interface LoDashObjectWrapper<T> extends LoDashWrapperBase<T, LoDashObjectWrapper<T>> {}
+
+	interface LoDashArrayWrapper<T> extends LoDashWrapperBase<T[], LoDashArrayWrapper<T>> {
+		concat(...items: T[]): LoDashArrayWrapper<T>;
+		join(seperator?: string): LoDashWrapper<string>;
+		pop(): LoDashWrapper<T>;
+		push(...items: T[]): void;
+		reverse(): LoDashArrayWrapper<T>;
+		shift(): LoDashWrapper<T>;
+		slice(start: number, end?: number): LoDashArrayWrapper<T>;
+		sort(compareFn?: (a: T, b: T) => number): LoDashArrayWrapper<T>;
+		splice(start: number): LoDashArrayWrapper<T>;
+		splice(start: number, deleteCount: number, ...items: any[]): LoDashArrayWrapper<T>;
+		unshift(...items: any[]): LoDashWrapper<number>;
+	}
+
+	//_.chain
+	interface LoDashStatic {
+		/**
+		* Creates a lodash object that wraps the given value with explicit method chaining enabled.
+		* @param value The value to wrap.
+		* @return The wrapper object.
+		**/
+		chain(value: number): LoDashWrapper<number>;
+		chain(value: string): LoDashWrapper<string>;
+		chain(value: boolean): LoDashWrapper<boolean>;
+		chain<T>(value: Array<T>): LoDashArrayWrapper<T>;
+		chain<T extends {}>(value: T): LoDashObjectWrapper<T>;
+		chain(value: any): LoDashWrapper<any>;
+	}
+
+	interface LoDashWrapperBase<T, TWrapper> {
+		/**
+		* Enables explicit method chaining on the wrapper object.
+		* @see _.chain
+		* @return The wrapper object.
+		**/
+		chain(): TWrapper;
+	}
+
+	//_.tap
+	interface LoDashStatic {
+		/**
+		* Invokes interceptor with the value as the first argument and then returns value. The 
+		* purpose of this method is to "tap into" a method chain in order to perform operations on 
+		* intermediate results within the chain.
+		* @param value The value to provide to interceptor
+		* @param interceptor The function to invoke.
+		* @return value
+		**/
+		tap<T>(
+			value: T,
+			interceptor: (value: T) => void): T;
+	}
+
+	interface LoDashWrapperBase<T, TWrapper> {
+		/**
+		* @see _.tap
+		**/
+		tap(interceptor: (value: T) => void): TWrapper;
+	}
+
+	/*********
+	* Arrays *
+	**********/
+
+	//_.compact
+	interface LoDashStatic {
+		/**
+		* Returns a copy of the array with all falsy values removed. In JavaScript, false, null, 0, "",
+		* undefined and NaN are all falsy.
+		* @param array Array to compact.
+		* @return (Array) Returns a new array of filtered values.
+		**/
+		compact<T>(array: List<T>): T[];
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.compact
+		**/
+		compact<T>(): LoDashArrayWrapper<T>;
+	}	
+
+	//_.difference
+	interface LoDashStatic {
+		/**
+		* Creates an array excluding all values of the provided arrays using strict equality for comparisons
+		* , i.e. ===.
+		* @param array The array to process
+		* @param others The arrays of values to exclude.
+		* @return Returns a new array of filtered values.
+		**/
+		difference<T>(
+			array: List<T>,
+			...others: List<T>[]): T[];
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.difference
+		**/
+		difference(
+			...others: List<T>[]): LoDashArrayWrapper<T>;
+	}
+
+	//_.findIndex
+	interface LoDashStatic {
+		/**
+		* This method is like _.find except that it returns the index of the first element that passes 
+		* the callback check, instead of the element itself.
+		* @param array The array to search.
+		* @param {(Function|Object|string)} callback The function called per iteration. If a property name or object is provided it will be 
+		* used to create a ".pluck" or ".where" style callback, respectively.
+		* @param thisArg The this binding of callback.
+		* @return Returns the index of the found element, else -1.
+		**/
+		findIndex<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): number;
+
+		/**
+		* @see _.findIndex
+		**/
+		findIndex<T>(
+			array: List<T>,
+			pluckValue: string): number;
+		
+		/**
+		* @see _.findIndex
+		**/
+		findIndex<W, T extends W>(
+			array: List<T>,
+			whereDictionary: W): number;
+	}
+
+	//_.findLastIndex
+	interface LoDashStatic {
+		/**
+		* This method is like _.findIndex except that it iterates over elements of a collection from right to left.
+		* @param array The array to search.
+		* @param {(Function|Object|string)} callback The function called per iteration. If a property name or object is provided it will be 
+		* used to create a ".pluck" or ".where" style callback, respectively.
+		* @param thisArg The this binding of callback.
+		* @return Returns the index of the found element, else -1.
+		**/
+		findLastIndex<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): number;
+		
+		/**
+		* @see _.findLastIndex
+		**/
+		findLastIndex<T>(
+			array: List<T>,
+			pluckValue: string): number;
+		
+		/**
+		* @see _.findLastIndex
+		**/
+		findLastIndex<T>(
+			array: List<T>,
+			whereDictionary: Dictionary<any>): number;
+	}
+
+	//_.first
+	interface LoDashStatic {
+		/**
+		* Gets the first element or first n elements of an array. If a callback is provided 
+		* elements at the beginning of the array are returned as long as the callback returns 
+		* truey. The callback is bound to thisArg and invoked with three arguments; (value, 
+		* index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback 
+		* will return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return ]
+		* true for elements that have the properties of the given object, else false.
+		* @param array Retrieves the first element of this array.
+		* @return Returns the first element of `array`.
+		**/
+		first<T>(array: List<T>): T;
+
+		/**
+		* @see _.first
+		* @param n The number of elements to return.
+		**/
+		first<T>(
+			array: List<T>,
+			n: number): T[];
+
+		/**
+		* @see _.first
+		* @param callback The function called per element.
+		* @param [thisArg] The this binding of callback.
+		**/
+		first<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.first
+		* @param pluckValue "_.pluck" style callback value
+		**/
+		first<T>(
+			array: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.first
+		* @param whereValue "_.where" style callback value
+		**/
+		first<W, T extends W>(
+			array: List<T>,
+			whereValue: W): T[];
+
+			/**
+			* @see _.first
+			**/
+			head<T>(array: List<T>): T;
+
+			/**
+			* @see _.first
+			**/
+			head<T>(
+				array: List<T>,
+				n: number): T[];
+
+			/**
+			* @see _.first
+			**/
+			head<T>(
+				array: List<T>,
+				callback: ListIterator<T, boolean>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.first
+			**/
+			head<T>(
+				array: List<T>,
+				pluckValue: string): T[];
+
+			/**
+			* @see _.first
+			**/
+			head<W, T extends W>(
+				array: List<T>,
+				whereValue: W): T[];
+
+			/**
+			* @see _.first
+			**/
+			take<T>(array: List<T>): T;
+
+			/**
+			* @see _.first
+			**/
+			take<T>(
+				array: List<T>,
+				n: number): T[];
+
+			/**
+			* @see _.first
+			**/
+			take<T>(
+				array: List<T>,
+				callback: ListIterator<T, boolean>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.first
+			**/
+			take<T>(
+				array: List<T>,
+				pluckValue: string): T[];
+
+			/**
+			* @see _.first
+			**/
+			take<W, T extends W>(
+				array: List<T>,
+				whereValue: W): T[];
+	}
+
+	//_.flatten
+	interface LoDashStatic {
+		/**
+		* Flattens a nested array (the nesting can be to any depth). If isShallow is truey, the 
+		* array will only be flattened a single level. If a callback is provided each element of 
+		* the array is passed through the callback before flattening. The callback is bound to 
+		* thisArg and invoked with three arguments; (value, index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param array The array to flatten.
+		* @param shallow If true then only flatten one level, optional, default = false.
+		* @return `array` flattened.
+		**/
+		flatten<T>(array: List<any>, isShallow?: boolean): T[]
+
+		flatten<T>(
+			array: List<any>,
+			isShallow: boolean,
+			callback: ListIterator<any, T>,
+			thisArg?: any): T[];			
+
+		flatten<T>(
+			array: List<any>,
+			callback: ListIterator<any, T>,
+			thisArg?: any): T[];			
+
+		flatten<W, T extends W>(
+			array: List<any>,
+			isShallow: boolean,
+			whereValue: W): T[];			
+
+		flatten<W, T extends W>(
+			array: List<any>,
+			whereValue: W): T[];			
+
+		flatten<T>(
+			array: List<any>,
+			isShallow: boolean,
+			pluckValue: string): T[];			
+
+		flatten<T>(
+			array: List<any>,
+			pluckValue: string): T[];			
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.flatten
+		**/
+        flatten<Flat>(isShallow?: boolean): LoDashArrayWrapper<Flat>;
+
+        flatten<Flat>(
+			isShallow: boolean,
+			callback: ListIterator<T, Flat>,
+			thisArg?: any): LoDashArrayWrapper<Flat>;
+
+        flatten<Flat>(
+			callback: ListIterator<T, Flat>,
+			thisArg?: any): LoDashArrayWrapper<Flat>;
+
+        flatten<Flat>(
+			isShallow: boolean,
+			pluckValue: string): LoDashArrayWrapper<Flat>;
+
+        flatten<Flat>(
+			pluckValue: string): LoDashArrayWrapper<Flat>;
+
+        flatten<Flat, W extends Flat>(
+			isShallow: boolean,
+			whereValue: W): LoDashArrayWrapper<Flat>;
+
+        flatten<Flat, W extends Flat>(
+			whereValue: W): LoDashArrayWrapper<Flat>;
+	}
+
+	//_.indexOf
+	interface LoDashStatic {
+		/**
+		* Gets the index at which the first occurrence of value is found using strict equality 
+		* for comparisons, i.e. ===. If the array is already sorted providing true for fromIndex 
+		* will run a faster binary search.
+		* @param array The array to search.
+		* @param value The value to search for.
+		* @param fromIndex The index to search from.
+		* @return The index of `value` within `array`.
+		**/
+		indexOf<T>(
+			array: List<T>,
+			value: T): number;
+
+		/**
+		* @see _.indexOf
+		* @param fromIndex The index to search from
+		**/
+		indexOf<T>(
+			array: List<T>,
+			value: T,
+			fromIndex: number): number;
+
+		/**
+		* @see _.indexOf
+		* @param isSorted True to perform a binary search on a sorted array.
+		**/
+		indexOf<T>(
+			array: List<T>,
+			value: T,
+			isSorted: boolean): number;
+	}
+
+	//_.initial
+	interface LoDashStatic {
+		/**
+		* Gets all but the last element or last n elements of an array. If a callback is provided 
+		* elements at the end of the array are excluded from the result as long as the callback 
+		* returns truey. The callback is bound to thisArg and invoked with three arguments; 
+		* (value, index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param array The array to query.
+		* @param n Leaves this many elements behind, optional.
+		* @return Returns everything but the last `n` elements of `array`.
+		**/
+		initial<T>(
+			array: List<T>): T[];
+
+		/**
+		* @see _.initial
+		* @param n The number of elements to exclude.
+		**/
+		initial<T>(
+			array: List<T>,
+			n: number): T[];
+
+		/**
+		* @see _.initial
+		* @param callback The function called per element
+		**/
+		initial<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>): T[];
+
+		/**
+		* @see _.initial
+		* @param pluckValue _.pluck style callback
+		**/
+		initial<T>(
+			array: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.initial
+		* @param whereValue _.where style callback
+		**/
+		initial<W, T extends W>(
+			array: List<T>,
+			whereValue: W): T[];
+	}
+
+	//_.intersection
+	interface LoDashStatic {
+		/**
+		* Creates an array of unique values present in all provided arrays using strict 
+		* equality for comparisons, i.e. ===.
+		* @param arrays The arrays to inspect.
+		* @return Returns an array of composite values.
+		**/
+		intersection<T>(...arrays: List<T>[]): T[];
+	}
+
+	//_.last
+	interface LoDashStatic {
+		/**
+		* Gets the last element or last n elements of an array. If a callback is provided 
+		* elements at the end of the array are returned as long as the callback returns truey. 
+		* The callback is bound to thisArg and invoked with three arguments; (value, index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param array The array to query.
+		* @return Returns the last element(s) of array.
+		**/
+		last<T>(array: List<T>): T;
+
+		/**
+		* @see _.last
+		* @param n The number of elements to return
+		**/
+		last<T>(
+			array: List<T>,
+			n: number): T[];
+
+		/**
+		* @see _.last
+		* @param callback The function called per element
+		**/
+		last<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.last
+		* @param pluckValue _.pluck style callback
+		**/
+		last<T>(
+			array: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.last
+		* @param whereValue _.where style callback
+		**/
+		last<W, T extends W>(
+			array: List<T>,
+			whereValue: W): T[];
+	}
+
+	//_.lastIndexOf
+	interface LoDashStatic {
+		/**
+		* Gets the index at which the last occurrence of value is found using strict equality 
+		* for comparisons, i.e. ===. If fromIndex is negative, it is used as the offset from the 
+		* end of the collection.
+		* @param array The array to search.
+		* @param value The value to search for.
+		* @param fromIndex The index to search from.
+		* @return The index of the matched value or -1.
+		**/
+		lastIndexOf<T>(
+			array: List<T>,
+			value: T,
+			fromIndex?: number): number;
+	}
+	
+	//_.pull
+	interface LoDashStatic {
+		/**
+		* Removes all provided values from the given array using strict equality for comparisons, 
+		* i.e. ===.
+		* @param array The array to modify.
+		* @param values The values to remove.
+		* @return array.
+		**/
+		pull(
+			array: List<any>,
+			...values: any[]): any[];
+	}
+
+	//_.range
+	interface LoDashStatic {
+		/**
+		* Creates an array of numbers (positive and/or negative) progressing from start up 
+		* to but not including end. If start is less than stop a zero-length range is created 
+		* unless a negative step is specified.
+		* @param start The start of the range.
+		* @param end The end of the range.
+		* @param step The value to increment or decrement by.
+		* @return Returns a new range array.
+		**/
+
+		range(
+			start: number,
+			stop: number,
+			step?: number): number[];
+		
+		/**
+		* @see _.range
+		* @param end The end of the range.
+		* @return Returns a new range array.
+		* @note If start is not specified the implementation will never pull the step (step = arguments[2] || 0)
+		**/
+		range(stop: number): number[];
+	}
+
+	//_.remove
+	interface LoDashStatic {
+		/**
+		* Removes all elements from an array that the callback returns truey for and returns 
+		* an array of removed elements. The callback is bound to thisArg and invoked with three 
+		* arguments; (value, index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param array The array to modify.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return A new array of removed elements.
+		**/
+		remove(
+			array: List<any>,
+			callback?: ListIterator<any, boolean>,
+			thisArg?: any): any[];
+
+		/**
+		* @see _.remove
+		* @param pluckValue _.pluck style callback
+		**/
+		remove(
+			array: List<any>,
+			pluckValue?: string): any[];
+
+		/**
+		* @see _.remove
+		* @param whereValue _.where style callback
+		**/
+		remove(
+			array: List<any>,
+			wherealue?: Dictionary<any>): any[];
+	}
+
+	//_.rest
+	interface LoDashStatic {
+		/**
+		* The opposite of _.initial this method gets all but the first element or first n elements of 
+		* an array. If a callback function is provided elements at the beginning of the array are excluded 
+		* from the result as long as the callback returns truey. The callback is bound to thisArg and 
+		* invoked with three arguments; (value, index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will return 
+		* the property value of the given element.
+		* 
+		* If an object is provided for callback the created "_.where" style callback will return true 
+		* for elements that have the properties of the given object, else false.
+		* @param array The array to query.
+		* @param {(Function|Object|number|string)} [callback=1] The function called per element or the number 
+		* of elements to exclude. If a property name or object is provided it will be used to create a 
+		* ".pluck" or ".where" style callback, respectively.
+		* @param {*} [thisArg] The this binding of callback.
+		* @return Returns a slice of array.
+		**/
+		rest<T>(array: List<T>): T[];
+
+		/**
+		* @see _.rest
+		**/
+		rest<T>(
+			array: List<T>,
+            callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.rest
+		**/
+		rest<T>(
+			array: List<T>,
+			n: number): T[];
+		
+		/**
+		* @see _.rest
+		**/
+		rest<T>(
+			array: List<T>,
+			pluckValue: string): T[];
+		
+		/**
+		* @see _.rest
+		**/
+        rest<W, T extends W>(
+			array: List<T>,
+			whereValue: W): T[];
+
+            /**
+            * @see _.rest
+            **/
+            drop<T>(array: List<T>): T[];
+
+            /**
+            * @see _.rest
+            **/
+            drop<T>(
+                array: List<T>,
+                callback: ListIterator<T, boolean>,
+                thisArg?: any): T[];
+
+            /**
+            * @see _.rest
+            **/
+            drop<T>(
+                array: List<T>,
+                n: number): T[];
+            
+            /**
+            * @see _.rest
+            **/
+            drop<T>(
+                array: List<T>,
+                pluckValue: string): T[];
+            
+            /**
+            * @see _.rest
+            **/
+            drop<W, T extends W>(
+                array: List<T>,
+                whereValue: W): T[];
+
+                /**
+                * @see _.rest
+                **/
+                tail<T>(array: List<T>): T[];
+
+                /**
+                * @see _.rest
+                **/
+                tail<T>(
+                    array: List<T>,
+                    callback: ListIterator<T, boolean>,
+                    thisArg?: any): T[];
+
+                /**
+                * @see _.rest
+                **/
+                tail<T>(
+                    array: List<T>,
+                    n: number): T[];
+                
+                /**
+                * @see _.rest
+                **/
+                tail<T>(
+                    array: List<T>,
+                    pluckValue: string): T[];
+                
+                /**
+                * @see _.rest
+                **/
+                tail<W, T extends W>(
+                    array: List<T>,
+                    whereValue: W): T[];
+	}
+
+	//_.sortedIndex
+	interface LoDashStatic {
+		/**
+		* Uses a binary search to determine the smallest index at which a value should be inserted 
+		* into a given sorted array in order to maintain the sort order of the array. If a callback 
+		* is provided it will be executed for value and each element of array to compute their sort 
+		* ranking. The callback is bound to thisArg and invoked with one argument; (value).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param array The sorted list.
+		* @param value The value to determine its index within `list`.
+		* @param callback Iterator to compute the sort ranking of each value, optional.
+		* @return The index at which value should be inserted into array.
+		**/
+		sortedIndex<T, TSort>(
+			array: List<T>,
+			value: T,
+			callback?: (x: T) => TSort, 
+			thisArg?: any): number;
+
+		/**
+		* @see _.sortedIndex
+		* @param pluckValue the _.pluck style callback
+		**/
+		sortedIndex<T>(
+			array: List<T>,
+			value: T,
+			pluckValue: string): number;
+
+		/**
+		* @see _.sortedIndex
+		* @param pluckValue the _.where style callback
+		**/
+		sortedIndex<W, T extends W>(
+			array: List<T>,
+			value: T,
+			whereValue: W): number;
+	}
+
+	//_.union
+	interface LoDashStatic {
+		/**
+		* Creates an array of unique values, in order, of the provided arrays using strict 
+		* equality for comparisons, i.e. ===.
+		* @param arrays The arrays to inspect.
+		* @return Returns an array of composite values.
+		**/
+		union<T>(...arrays: List<T>[]): T[];
+	}
+
+	//_.uniq
+	interface LoDashStatic {
+		/**
+		* Creates a duplicate-value-free version of an array using strict equality for comparisons, 
+		* i.e. ===. If the array is sorted, providing true for isSorted will use a faster algorithm. 
+		* If a callback is provided each element of array is passed through the callback before 
+		* uniqueness is computed. The callback is bound to thisArg and invoked with three arguments; 
+		* (value, index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param array Array to remove duplicates from.
+		* @param isSorted True if `array` is already sorted, optiona, default = false.
+		* @param iterator Transform the elements of `array` before comparisons for uniqueness.
+		* @param context 'this' object in `iterator`, optional.
+		* @return Copy of `array` where all elements are unique.
+		**/
+		uniq<T, TSort>(array: List<T>, isSorted?: boolean): T[];
+
+		uniq<T, TSort>(
+			array: List<T>,
+			isSorted: boolean,
+			callback: ListIterator<T, TSort>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.uniq
+		**/
+		uniq<T, TSort>(
+			array: List<T>,
+			callback: ListIterator<T, TSort>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.uniq
+		* @param pluckValue _.pluck style callback
+		**/
+		uniq<T>(
+			array: List<T>,
+			isSorted: boolean,
+			pluckValue: string): T[];
+
+		uniq<T>(
+			array: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.uniq
+		* @param whereValue _.where style callback
+		**/
+		uniq<W, T extends W>(
+			array: List<T>,
+			isSorted: boolean,
+			whereValue: W): T[];
+
+		uniq<W, T extends W>(
+			array: List<T>,
+			whereValue: W): T[];
+
+			/**
+			* @see _.uniq
+			**/
+			unique<T>(array: List<T>, isSorted?: boolean): T[];
+
+			unique<T, TSort>(
+				array: List<T>,
+				callback: ListIterator<T, TSort>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.uniq
+			**/
+			unique<T, TSort>(
+				array: List<T>,
+				isSorted: boolean,
+				callback: ListIterator<T, TSort>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.uniq
+			* @param pluckValue _.pluck style callback
+			**/
+			unique<T>(
+				array: List<T>,
+				isSorted: boolean,
+				pluckValue: string): T[];
+
+			unique<T>(
+				array: List<T>,
+				pluckValue: string): T[];
+
+			/**
+			* @see _.uniq
+			* @param whereValue _.where style callback
+			**/
+			unique<W, T extends W>(
+				array: List<T>,
+				whereValue?: W): T[];
+
+			unique<W, T extends W>(
+				array: List<T>,
+				isSorted: boolean,
+				whereValue?: W): T[];
+	}
+
+	//_.without
+	interface LoDashStatic {
+		/**
+		* Creates an array excluding all provided values using strict equality for comparisons, i.e. ===.
+		* @param array The array to filter.
+		* @param values The value(s) to exclude.
+		* @return A new array of filtered values.
+		**/
+		without<T>(
+			array: List<T>,
+			...values: T[]): T[];
+	}
+
+	//_.zip
+	interface LoDashStatic {
+		/**
+		* Creates an array of grouped elements, the first of which contains the first 
+		* elements of the given arrays, the second of which contains the second elements 
+		* of the given arrays, and so on.
+		* @param arrays Arrays to process.
+		* @return A new array of grouped elements.
+		**/
+		zip(...arrays: any[][]): any[][];
+
+		/**
+		* @see _.zip
+		**/
+		zip(...arrays: any[]): any[];
+
+			/**
+			* @see _.zip
+			**/
+			unzip(...arrays: any[][]): any[][];
+
+			/**
+			* @see _.zip
+			**/
+			unzip(...arrays: any[]): any[];
+	}
+
+	//_.zipObject
+	interface LoDashStatic {
+		/**
+		* Creates an object composed from arrays of keys and values. Provide either a single 
+		* two dimensional array, i.e. [[key1, value1], [key2, value2]] or two arrays, one of 
+		* keys and one of corresponding values.
+		* @param keys The array of keys.
+		* @param values The array of values.
+		* @return An object composed of the given keys and corresponding values.
+		**/
+		zipObject<TResult extends {}>(
+			keys: List<string>,
+			values: List<any>): TResult;
+
+			/**
+			* @see _.object
+			**/
+			object<TResult extends {}>(
+				keys: List<string>,
+				values: List<any>): TResult;
+	}
+
+	/* *************
+	 * Collections *
+	 ************* */
+
+	//_.at
+	interface LoDashStatic {
+		/**
+		* Creates an array of elements from the specified indexes, or keys, of the collection. 
+		* Indexes may be specified as individual arguments or as arrays of indexes.
+		* @param collection The collection to iterate over.
+		* @param indexes The indexes of collection to retrieve, specified as individual indexes or 
+		* arrays of indexes.
+		* @return A new array of elements corresponding to the provided indexes.
+		**/
+		at<T>(
+			collection: Collection<T>,
+			indexes: number[]): T[];
+
+		/**
+		* @see _.at
+		**/
+		at<T>(
+			collection: Collection<T>,
+			...indexes: number[]): T[];
+	}
+
+	//_.contains
+	interface LoDashStatic {
+		/**
+		* Checks if a given value is present in a collection using strict equality for comparisons, 
+		* i.e. ===. If fromIndex is negative, it is used as the offset from the end of the collection.
+		* @param collection The collection to iterate over.
+		* @param target The value to check for.
+		* @param fromIndex The index to search from.
+		* @return True if the target element is found, else false.
+		**/
+		contains<T>(
+			collection: Collection<T>,
+			target: T,
+			fromIndex?: number): boolean;
+
+		/**
+		* @see _.contains
+		* @param dictionary The dictionary to iterate over.
+		* @param key The key in the dictionary to search for.
+		**/
+		contains<T>(
+			dictionary: Dictionary<T>,
+			key: string,
+			fromIndex?: number): boolean;
+
+		/**
+		* @see _.contains
+		* @param searchString the string to search
+		* @param targetString the string to search for
+		**/
+		contains(
+			searchString: string,
+			targetString: string,
+			fromIndex?: number): boolean;
+
+			/**
+			* @see _.contains
+			**/
+			include<T>(
+				collection: Collection<T>,
+				target: T,
+				fromIndex?: number): boolean;
+
+			/**
+			* @see _.contains
+			**/
+			include<T>(
+				dictionary: Dictionary<T>,
+				key: string,
+				fromIndex?: number): boolean;
+
+			/**
+			* @see _.contains
+			**/
+			include(
+				searchString: string,
+				targetString: string,
+				fromIndex?: number): boolean;
+	}
+
+	//_.countBy
+	interface LoDashStatic {
+		/**
+		* Creates an object composed of keys generated from the results of running each element 
+		* of collection through the callback. The corresponding value of each key is the number 
+		* of times the key was returned by the callback. The callback is bound to thisArg and 
+		* invoked with three arguments; (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return Returns the composed aggregate object.
+		**/
+		countBy<T>(
+			collection: Collection<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): Dictionary<number>;
+
+		/**
+		* @see _.countBy
+		* @param callback Function name
+		**/
+		countBy<T>(
+			collection: Collection<T>,
+			callback: string,
+			thisArg?: any): Dictionary<number>;			
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.countBy
+		**/
+		countBy<T>(
+			callback?: ListIterator<T, any>,
+			thisArg?: any): LoDashObjectWrapper<Dictionary<number>>;
+
+		/**
+		* @see _.countBy
+		* @param callback Function name
+		**/
+		countBy<T>(
+			callback: string,
+			thisArg?: any): LoDashObjectWrapper<Dictionary<number>>;
+	}
+
+	//_.every
+	interface LoDashStatic {
+		/**
+		* Checks if the given callback returns truey value for all elements of a collection. 
+		* The callback is bound to thisArg and invoked with three arguments; (value, index|key, 
+		* collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return True if all elements passed the callback check, else false.
+		**/
+		every<T>(
+			collection: Collection<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.every
+		* @param pluckValue _.pluck style callback
+		**/
+		every<T>(
+			collection: Collection<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.every
+		* @param whereValue _.where style callback
+		**/
+		every<W, T extends W>(
+			collection: Collection<T>,
+			whereValue: W): boolean;
+
+			/**
+			* @see _.every
+			**/
+			all<T>(
+				collection: Collection<T>,
+				callback?: ListIterator<T, boolean>,
+				thisArg?: any): boolean;
+
+			/**
+			* @see _.every
+			* @param pluckValue _.pluck style callback
+			**/
+			all<T>(
+				collection: Collection<T>,
+				pluckValue: string): boolean;
+
+			/**
+			* @see _.every
+			* @param whereValue _.where style callback
+			**/
+			all<W, T extends W>(
+				collection: Collection<T>,
+				whereValue: W): boolean;
+	}
+
+	//_.filter
+	interface LoDashStatic {
+		/**
+		* Iterates over elements of a collection, returning an array of all elements the 
+		* callback returns truey for. The callback is bound to thisArg and invoked with three 
+		* arguments; (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param context The this binding of callback.
+		* @return Returns a new array of elements that passed the callback check.
+		**/
+		filter<T>(
+			collection: Collection<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		filter<T>(
+			collection: Collection<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+        filter<W, T extends W>(
+			collection: Collection<T>,
+            whereValue: W): T[];
+
+			/**
+			* @see _.filter
+			**/
+			select<T>(
+				collection: Collection<T>,
+				callback: ListIterator<T, boolean>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.filter
+			* @param pluckValue _.pluck style callback
+			**/
+			select<T>(
+				collection: Collection<T>,
+				pluckValue: string): T[];
+
+			/**
+			* @see _.filter
+			* @param pluckValue _.pluck style callback
+			**/
+			select<W, T extends W>(
+				collection: Collection<T>,
+				whereValue: W): T[];
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.filter
+		**/
+		filter<T>(
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		filter<T>(
+			pluckValue: string): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		filter<W, T extends W>(
+			whereValue: W): T[];
+
+			/**
+			* @see _.filter
+			**/
+			select<T>(
+				callback: ListIterator<T, boolean>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.filter
+			* @param pluckValue _.pluck style callback
+			**/
+			select<T>(
+				pluckValue: string): T[];
+
+			/**
+			* @see _.filter
+			* @param pluckValue _.pluck style callback
+			**/
+			select<W, T extends W>(
+				whereValue: W): T[];
+	}
+
+	//_.find
+	interface LoDashStatic {
+		/**
+		* Iterates over elements of a collection, returning the first element that the callback 
+		* returns truey for. The callback is bound to thisArg and invoked with three arguments; 
+		* (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param collection Searches for a value in this list.
+		* @param callback The function called per iteration. 
+		* @param thisArg The this binding of callback.
+		* @return The found element, else undefined.
+		**/
+		find<T>(
+			collection: Collection<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		find<W, T extends W>(
+			collection: Collection<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		find<T>(
+			collection: Collection<T>,
+			pluckValue: string): T;
+
+			/**
+			* @see _.find
+			**/
+			detect<T>(
+				collection: Collection<T>,
+				callback: ListIterator<T, boolean>,
+				thisArg?: any): T;
+
+			/**
+			* @see _.find
+			* @param _.pluck style callback
+			**/
+			detect<W, T extends W>(
+				collection: Collection<T>,
+				whereValue: W): T;
+
+			/**
+			* @see _.find
+			* @param _.where style callback
+			**/
+			detect<T>(
+				collection: Collection<T>,
+				pluckValue: string): T;
+
+			/**
+			* @see _.find
+			**/
+			findWhere<T>(
+				collection: Collection<T>,
+				callback: ListIterator<T, boolean>,
+				thisArg?: any): T;
+
+			/**
+			* @see _.find
+			* @param _.pluck style callback
+			**/
+			findWhere<W, T extends W>(
+				collection: Collection<T>,
+				whereValue: W): T;
+
+			/**
+			* @see _.find
+			* @param _.where style callback
+			**/
+			findWhere<T>(
+				collection: Collection<T>,
+				pluckValue: string): T;
+	}
+
+	//_.findLast
+	interface LoDashStatic {
+		/**
+		* This method is like _.find except that it iterates over elements of a collection from 
+		* right to left.
+		* @param collection Searches for a value in this list.
+		* @param callback The function called per iteration. 
+		* @param thisArg The this binding of callback.
+		* @return The found element, else undefined.
+		**/
+		findLast<T>(
+			collection: Collection<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		findLast<W, T extends W>(
+			collection: Collection<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		findLast<T>(
+			collection: Collection<T>,
+			pluckValue: string): T;
+	}
+
+	//_.forEach
+	interface LoDashStatic {
+		/**
+		* Iterates over elements of a collection, executing the callback for each element. 
+		* The callback is bound to thisArg and invoked with three arguments; (value, index|key, 
+		* collection). Callbacks may exit iteration early by explicitly returning false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		**/
+		forEach<T>(
+			collection: List<T>,
+			callback: ListIterator<T, void >,
+			thisArg?: any): List<T>;
+
+		/**
+		* @see _.forEach
+		**/
+		forEach<T extends {}>(
+			object: Dictionary<T>,
+			callback: ObjectIterator<T, void >,
+			thisArg?: any): Dictionary<T>;
+
+			/**
+			* @see _.forEach
+			**/
+			each<T>(
+				collection: List<T>,
+				callback: ListIterator<T, void>,
+				thisArg?: any): List<T>;
+
+			/**
+			* @see _.forEach
+			* @param object The object to iterate over
+			* @param callback The function called per iteration.
+			* @param thisArg The this binding of callback.
+			**/
+			each<T extends {}>(
+				object: Dictionary<T>,
+				callback: ObjectIterator<T, void>,
+				thisArg?: any): Dictionary<T>;			
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.forEach
+		**/
+		forEach<T>(
+			callback: ListIterator<T, void >,
+			thisArg?: any): LoDashArrayWrapper<T>;
+
+			/**
+			* @see _.forEach
+			**/
+			each<T>(
+				callback: ListIterator<T, void >,
+				thisArg?: any): LoDashArrayWrapper<T>;
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.forEach
+		**/
+		forEach<T extends {}>(
+			callback: ObjectIterator<T, void >,
+			thisArg?: any): LoDashObjectWrapper<T>;
+
+			/**
+			* @see _.forEach
+			**/
+			each<T extends {}>(
+				callback: ObjectIterator<T, void >,	
+				thisArg?: any): LoDashObjectWrapper<T>;
+	}
+
+	//_.forEachRight
+	interface LoDashStatic {
+		/**
+		* This method is like _.forEach except that it iterates over elements of a 
+		* collection from right to left.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		**/
+		forEachRight<T>(
+			collection: List<T>,
+			callback: ListIterator<T, void >,
+			thisArg?: any): List<T>;
+
+		/**
+		* @see _.forEachRight
+		**/
+		forEachRight<T extends {}>(
+			object: Dictionary<T>,
+			callback: ObjectIterator<T, void >,
+			thisArg?: any): Dictionary<T>;
+
+			/**
+			* @see _.forEachRight
+			**/
+			eachRight<T>(
+				collection: List<T>,
+				callback: ListIterator<T, void>,
+				thisArg?: any): List<T>;
+
+			/**
+			* @see _.forEachRight
+			* @param object The object to iterate over
+			* @param callback The function called per iteration.
+			* @param thisArg The this binding of callback.
+			**/
+			eachRight<T extends {}>(
+				object: Dictionary<T>,
+				callback: ObjectIterator<T, void>,
+				thisArg?: any): Dictionary<T>;
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.forEachRight
+		**/
+		forEachRight<T>(
+			callback: ListIterator<T, void >,
+			thisArg?: any): LoDashArrayWrapper<T>;
+
+			/**
+			* @see _.forEachRight
+			**/
+			eachRight<T>(
+				callback: ListIterator<T, void >,
+				thisArg?: any): LoDashArrayWrapper<T>;
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.forEachRight
+		**/
+		forEachRight<T extends {}>(
+			callback: ObjectIterator<T, void >,
+			thisArg?: any): LoDashObjectWrapper<Dictionary<T>>;
+
+			/**
+			* @see _.forEachRight
+			* @param object The object to iterate over
+			* @param callback The function called per iteration.
+			* @param thisArg The this binding of callback.
+			**/
+			eachRight<T extends {}>(
+				callback: ObjectIterator<T, void>,
+				thisArg?: any): LoDashObjectWrapper<Dictionary<T>>;
+	}
+
+	//_.groupBy
+	interface LoDashStatic {
+		/**
+		* Creates an object composed of keys generated from the results of running each element 
+		* of a collection through the callback. The corresponding value of each key is an array 
+		* of the elements responsible for generating the key. The callback is bound to thisArg 
+		* and invoked with three arguments; (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return Returns the composed aggregate object.
+		**/
+		groupBy<T>(
+			collection: List<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): Dictionary<T[]>;
+
+		/**
+		* @see _.groupBy
+		* @param pluckValue _.pluck style callback
+		**/
+		groupBy<T>(
+			collection: List<T>,
+			pluckValue: string): Dictionary<T[]>;
+
+		/**
+		* @see _.groupBy
+		* @param whereValue _.where style callback
+		**/
+		groupBy<W, T extends W>(
+			collection: List<T>,
+			whereValue: W): Dictionary<T[]>;
+	}
+
+	interface LoDashArrayWrapper {
+		/**
+		* @see _.groupBy
+		**/
+		groupBy<T>(
+			callback: ListIterator<T, any>,
+			thisArg?: any): _.LoDashObjectWrapper<Dictionary<T[]>>;
+
+		/**
+		* @see _.groupBy
+		**/
+		groupBy<T>(
+			pluckValue: string): _.LoDashObjectWrapper<Dictionary<T[]>>;
+
+		/**
+		* @see _.groupBy
+		**/
+		groupBy<W, T extends W>(
+			whereValue: W): _.LoDashObjectWrapper<Dictionary<T[]>>;
+	}
+
+	//_.indexBy
+	interface LoDashStatic {
+		/**
+		* Creates an object composed of keys generated from the results of running each element 
+		* of the collection through the given callback. The corresponding value of each key is 
+		* the last element responsible for generating the key. The callback is bound to thisArg 
+		* and invoked with three arguments; (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return Returns the composed aggregate object.
+		**/
+		indexBy<T>(
+			list: List<T>,
+			iterator: ListIterator<T, any>,
+			context?: any): Dictionary<T>;
+
+		/**
+		* @see _.indexBy
+		* @param pluckValue _.pluck style callback
+		**/
+		indexBy<T>(
+			collection: List<T>,
+			pluckValue: string): Dictionary<T>;
+
+		/**
+		* @see _.indexBy
+		* @param whereValue _.where style callback
+		**/
+		indexBy<W, T extends W>(
+			collection: List<T>,
+			whereValue: W): Dictionary<T>;
+	}
+
+	//_.invoke
+	interface LoDashStatic {
+		/**
+		* Invokes the method named by methodName on each element in the collection returning 
+		* an array of the results of each invoked method. Additional arguments will be provided 
+		* to each invoked method. If methodName is a function it will be invoked for, and this 
+		* bound to, each element in the collection.
+		* @param collection The collection to iterate over.
+		* @param methodName The name of the method to invoke.
+		* @param args Arguments to invoke the method with.
+		**/
+		invoke<T extends {}>(
+			collection: Collection<T>,
+			methodName: string,
+			...args: any[]): any;
+
+		/**
+		* @see _.invoke
+		**/
+		invoke<T extends {}>(
+			collection: Collection<T>,
+			method: Function,
+			...args: any[]): any;
+	}
+
+	//_.map
+	interface LoDashStatic {
+		/**
+		* Creates an array of values by running each element in the collection through the callback. 
+		* The callback is bound to thisArg and invoked with three arguments; (value, index|key, 
+		* collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will return 
+		* the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return true 
+		* for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param theArg The this binding of callback.
+		* @return The mapped array result.
+		**/
+		map<T, TResult>(
+			collection: List<T>,
+			callback: ListIterator<T, TResult>,
+			thisArg?: any): TResult[];
+
+		/**
+		* @see _.map
+		* @param object The object to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg `this` object in `iterator`, optional.
+		* @return The mapped object result.
+		**/
+		map<T extends {}, TResult>(
+			object: Dictionary<T>,
+			callback: ObjectIterator<T, TResult>,
+			thisArg?: any): TResult[];
+
+		/**
+		* @see _.map
+		* @param pluckValue _.pluck style callback
+		**/
+		map<T, TResult>(
+			collection: List<T>,
+			pluckValue: string): TResult[];
+
+			/**
+			* @see _.map
+			**/
+			collect<T, TResult>(
+				collection: List<T>,
+				callback: ListIterator<T, TResult>,
+				thisArg?: any): TResult[];
+
+			/**
+			* @see _.map
+			**/
+			collect<T extends {}, TResult>(
+				object: Dictionary<T>,
+				callback: ObjectIterator<T, TResult>,
+				thisArg?: any): TResult[];
+
+			/**
+			* @see _.map
+			**/
+			collect<T, TResult>(
+				collection: List<T>,
+				pluckValue: string): TResult[];
+	}
+
+	//_.max
+	interface LoDashStatic {
+		/**
+		* Retrieves the maximum value of a collection. If the collection is empty or falsey -Infinity is 
+		* returned. If a callback is provided it will be executed for each value in the collection to 
+		* generate the criterion by which the value is ranked. The callback is bound to thisArg and invoked 
+		* with three arguments; (value, index, collection).
+		* 
+		* If a property name is provided for callback the created "_.pluck" style callback will return the 
+		* property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return true for 
+		* elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return Returns the maximum value.
+		**/
+		max<T>(
+			collection: Collection<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.max
+		* @param pluckValue _.pluck style callback
+		**/
+		max<T>(
+			collection: Collection<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.max
+		* @param whereValue _.where style callback
+		**/
+		max<W, T extends W>(
+			collection: Collection<T>,
+			whereValue: W): T;
+	}
+
+	//_.min
+	interface LoDashStatic {
+		/**
+		* Retrieves the minimum value of a collection. If the collection is empty or falsey 
+		* Infinity is returned. If a callback is provided it will be executed for each value 
+		* in the collection to generate the criterion by which the value is ranked. The callback 
+		* is bound to thisArg and invoked with three arguments; (value, index, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback 
+		* will return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will 
+		* return true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return Returns the maximum value.
+		**/
+		min<T>(
+			collection: Collection<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.min
+		* @param pluckValue _.pluck style callback
+		**/
+		min<T>(
+			collection: Collection<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.min
+		* @param whereValue _.where style callback
+		**/
+		min<W, T extends W>(
+			collection: Collection<T>,
+			whereValue: W): T;
+	}
+
+	//_.pluck
+	interface LoDashStatic {
+		/**
+		* Retrieves the value of a specified property from all elements in the collection.
+		* @param collection The collection to iterate over.
+		* @param property The property to pluck.
+		* @return A new array of property values.
+		**/
+		pluck<T extends {}>(
+			collection: Collection<T>,
+			property: string): any[];
+	}
+
+	//_.reduce
+	interface LoDashStatic {
+		/**
+		* Reduces a collection to a value which is the accumulated result of running each 
+		* element in the collection through the callback, where each successive callback execution 
+		* consumes the return value of the previous execution. If accumulator is not provided the 
+		* first element of the collection will be used as the initial accumulator value. The callback 
+		* is bound to thisArg and invoked with four arguments; (accumulator, value, index|key, collection).
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param accumulator Initial value of the accumulator.
+		* @param thisArg The this binding of callback.
+		* @return Returns the accumulated value.
+		**/
+		reduce<T, TResult>(
+			collection: Collection<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator?: TResult,
+			thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+		reduce<T, TResult>(
+			collection: Collection<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
+
+			/**
+			* @see _.reduce
+			**/
+			inject<T, TResult>(
+				collection: Collection<T>,
+				callback: MemoIterator<T, TResult>,
+				accumulator?: TResult,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.reduce
+			**/
+			inject<T, TResult>(
+				collection: Collection<T>,
+				callback: MemoIterator<T, TResult>,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.reduce
+			**/
+			foldl<T, TResult>(
+				collection: Collection<T>,
+				callback: MemoIterator<T, TResult>,
+				accumulator?: TResult,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.reduce
+			**/
+			foldl<T, TResult>(
+				collection: Collection<T>,
+				callback: MemoIterator<T, TResult>,
+				thisArg?: any): TResult;
+	}
+
+	//_.reduceRight
+	interface LoDashStatic {
+		/**
+		* This method is like _.reduce except that it iterates over elements of a collection from 
+		* right to left.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param accumulator Initial value of the accumulator.
+		* @param thisArg The this binding of callback.
+		* @return The accumulated value.
+		**/
+		reduceRight<T, TResult>(
+			collection: Collection<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator?: TResult,
+			thisArg?: any): TResult;
+
+        /**
+        * @see _.reduceRight
+        **/
+		reduceRight<T, TResult>(
+			collection: Collection<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
+
+			/**
+			* @see _.reduceRight
+			**/
+			foldr<T, TResult>(
+				collection: Collection<T>,
+				callback: MemoIterator<T, TResult>,
+				accumulator?: TResult,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.reduceRight
+			**/
+			foldr<T, TResult>(
+				collection: Collection<T>,
+				callback: MemoIterator<T, TResult>,
+				thisArg?: any): TResult;
+	}
+
+	//_.reject
+	interface LoDashStatic {
+		/**
+		* The opposite of _.filter this method returns the elements of a collection that 
+		* the callback does not return truey for.
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback 
+		* will return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will 
+		* return true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return A new array of elements that failed the callback check.
+		**/
+		reject<T>(
+			collection: Collection<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.reject
+		* @param pluckValue _.pluck style callback
+		**/
+		reject<T>(
+			collection: Collection<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.reject
+		* @param whereValue _.where style callback
+		**/
+		reject<W, T extends W>(
+			collection: Collection<T>,
+			whereValue: W): T[];
+	}
+
+	//_.sample
+	interface LoDashStatic {
+		/**
+		* Retrieves a random element or n random elements from a collection.
+		* @param collection The collection to sample.
+		* @return Returns the random sample(s) of collection.
+		**/
+		sample<T>(collection: Collection<T>): T;
+
+		/**
+		* @see _.sample
+		* @param n The number of elements to sample.
+		**/
+		sample<T>(collection: Collection<T>, n: number): T[];
+	}
+
+	//_.shuffle
+	interface LoDashStatic {
+		/**
+		* Creates an array of shuffled values, using a version of the Fisher-Yates shuffle. 
+		* See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.
+		* @param collection The collection to shuffle.
+		* @return Returns a new shuffled collection.
+		**/
+		shuffle<T>(collection: Collection<T>): T[];
+	}
+
+	//_.size
+	interface LoDashStatic {
+		/**
+		* Gets the size of the collection by returning collection.length for arrays and array-like 
+		* objects or the number of own enumerable properties for objects.
+		* @param collection The collection to inspect.
+		* @return collection.length
+		**/
+		size<T>(collection: List<T>): number;
+
+		/**
+		* @see _.size
+		* @param object The object to inspect
+		* @return The number of own enumerable properties.
+		**/
+		size<T extends {}>(object: T): number;
+
+		/**
+		* @see _.size
+		* @param aString The string to inspect
+		* @return The length of aString
+		**/
+		size(aString: string): number;
+	}
+
+	//_.some
+	interface LoDashStatic {
+		/**
+		* Checks if the callback returns a truey value for any element of a collection. The function 
+		* returns as soon as it finds a passing value and does not iterate over the entire collection. 
+		* The callback is bound to thisArg and invoked with three arguments; (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will return 
+		* the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return true for 
+		* elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return True if any element passed the callback check, else false.
+		**/
+		some<T>(
+			collection: Collection<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.some
+		* @param pluckValue _.pluck style callback
+		**/
+		some<T>(
+			collection: Collection<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.some
+		* @param whereValue _.where style callback
+		**/
+		some<W, T extends W>(
+			collection: Collection<T>,
+			whereValue: W): boolean;
+
+			/**
+			* @see _.some
+			**/
+			any<T>(
+				collection: Collection<T>,
+				callback?: ListIterator<T, boolean>,
+				thisArg?: any): boolean;
+
+			/**
+			* @see _.some
+			* @param pluckValue _.pluck style callback
+			**/
+			any<T>(
+				collection: Collection<T>,
+				pluckValue: string): boolean;
+
+			/**
+			* @see _.some
+			* @param whereValue _.where style callback
+			**/
+			any<W, T extends W>(
+				collection: Collection<T>,
+				whereValue: W): boolean;
+	}
+
+	//_.sortBy
+	interface LoDashStatic {
+		/**
+		* Creates an array of elements, sorted in ascending order by the results of running each 
+		* element in a collection through the callback. This method performs a stable sort, that 
+		* is, it will preserve the original sort order of equal elements. The callback is bound 
+		* to thisArg and invoked with three arguments; (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return A new array of sorted elements.
+		**/
+		sortBy<T, TSort>(
+			collection: List<T>,
+			callback?: ListIterator<T, TSort>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.sortBy
+		* @param pluckValue _.pluck style callback
+		**/
+		sortBy<T>(
+			collection: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.sortBy
+		* @param whereValue _.where style callback
+		**/
+		sortBy<W, T extends W>(
+			collection: List<T>,
+			whereValue: W): T[];
+	}
+
+	//_.toArray
+	interface LoDashStatic {
+		/**
+		* Converts the collection to an array.
+		* @param collection The collection to convert.
+		* @return The new converted array.
+		**/
+		toArray<T>(collection: Collection<T>): T[];
+	}
+
+	//_.where
+	interface LoDashStatic {
+		/**
+		* Performs a deep comparison of each element in a collection to the given properties 
+		* object, returning an array of all elements that have equivalent property values.
+		* @param collection The collection to iterate over.
+		* @param properties The object of property values to filter by.
+		* @return A new array of elements that have the given properties.
+		**/
+		where<T, U extends {}>(
+			list: Collection<T>,
+			properties: U): T[];
+	}
+
+	/*************
+	 * Functions *
+	 *************/
+
+	//_.after
+	interface LoDashStatic {
+		/**
+		* Creates a function that executes func, with the this binding and arguments of the 
+		* created function, only after being called n times.
+		* @param n The number of times the function must be called before func is executed.
+		* @param func The function to restrict.
+		* @return The new restricted function.
+		**/
+		after(
+			n: number,
+			func: Function): Function;			
+	}
+
+	interface LoDashWrapper<T> {
+		/**
+		* @see _.after
+		**/
+		after(func: Function): LoDashObjectWrapper<Function>;
+	}
+
+	//_.bind
+	interface LoDashStatic {
+		/**
+		* Creates a function that, when called, invokes func with the this binding of thisArg 
+		* and prepends any additional bind arguments to those provided to the bound function.
+		* @param func The function to bind.
+		* @param thisArg The this binding of func.
+		* @param args Arguments to be partially applied.
+		* @return The new bound function.
+		**/
+		bind(
+			func: Function,
+			thisArg: any,
+			...args: any[]): () => any;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.bind
+		**/
+		bind(
+			thisArg: any,
+			...args: any[]): LoDashObjectWrapper<() => any>;
+	}
+
+	//_.bindAll
+	interface LoDashStatic {
+		/**
+		* Binds methods of an object to the object itself, overwriting the existing method. Method 
+		* names may be specified as individual arguments or as arrays of method names. If no method 
+		* names are provided all the function properties of object will be bound.
+		* @param object The object to bind and assign the bound methods to.
+		* @param methodNames The object method names to bind, specified as individual method names 
+		* or arrays of method names.
+		* @return object
+		**/
+		bindAll<T>(
+			object: T,
+			...methodNames: string[]): T;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.bindAll
+		**/
+		bindAll<T>(...methodNames: string[]): LoDashWrapper<T>;
+	}
+
+	//_.bindKey
+	interface LoDashStatic {
+		/**
+		* Creates a function that, when called, invokes the method at object[key] and prepends any 
+		* additional bindKey arguments to those provided to the bound function. This method differs 
+		* from _.bind by allowing bound functions to reference methods that will be redefined or don't 
+		* yet exist. See http://michaux.ca/articles/lazy-function-definition-pattern.
+		* @param object The object the method belongs to.
+		* @param key The key of the method.
+		* @param args Arguments to be partially applied.
+		* @return The new bound function.
+		**/
+		bindKey<T>(
+			object: T,
+			key: string,
+			...args: any[]): Function;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.bindKey
+		**/
+		bindKey(
+			key: string,
+			...args: any[]): LoDashObjectWrapper<Function>;
+	}
+
+	//_.compose
+	interface LoDashStatic {
+		/**
+		* Creates a function that is the composition of the provided functions, where each function 
+		* consumes the return value of the function that follows. For example, composing the functions 
+		* f(), g(), and h() produces f(g(h())). Each function is executed with the this binding of the 
+		* composed function.
+		* @param funcs Functions to compose.
+		* @return The new composed function.
+		**/
+		compose(...funcs: Function[]): Function;	
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.compose
+		**/
+		compose(...funcs: Function[]): LoDashObjectWrapper<Function>;
+	}
+
+	//_.createCallback
+	interface LoDashStatic {
+		/**
+		* Produces a callback bound to an optional thisArg. If func is a property name the created 
+		* callback will return the property value for a given element. If func is an object the created 
+		* callback will return true for elements that contain the equivalent object properties, 
+		* otherwise it will return false.
+		* @param func The value to convert to a callback.
+		* @param thisArg The this binding of the created callback.
+		* @param argCount The number of arguments the callback accepts.
+		* @return A callback function.
+		**/
+		createCallback(
+			func: string,
+			thisArg?: any,
+			argCount?: number): () => any;
+
+		/**
+		* @see _.createCallback
+		**/
+		createCallback(
+			func: Dictionary<any>,
+			thisArg?: any,
+			argCount?: number): () => boolean;			
+	}
+
+	interface LoDashWrapper<T> {
+		/**
+		* @see _.createCallback
+		**/
+		createCallback(
+			thisArg?: any,
+			argCount?: number): LoDashObjectWrapper<() => any>;
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.createCallback
+		**/
+		createCallback(
+			thisArg?: any,
+			argCount?: number): LoDashObjectWrapper<() => any>;
+	}
+
+	//_.curry
+	interface LoDashStatic {
+		/**
+		* Creates a function which accepts one or more arguments of func that when invoked either 
+		* executes func returning its result, if all func arguments have been provided, or returns 
+		* a function that accepts one or more of the remaining func arguments, and so on. The arity 
+		* of func can be specified if func.length is not sufficient.
+		* @param func The function to curry.
+		* @param arity The arity of func.
+		* @return The new curried function.
+		**/
+		curry(
+			func: Function,
+			arity?: number): Function;	
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.curry
+		**/
+		curry(arity?: number): LoDashObjectWrapper<Function>;
+	}
+
+	//_.debounce
+	interface LoDashStatic {
+		/**
+		* Creates a function that will delay the execution of func until after wait milliseconds have 
+		* elapsed since the last time it was invoked. Provide an options object to indicate that func 
+		* should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent calls 
+		* to the debounced function will return the result of the last func call.
+		*
+		* Note: If leading and trailing options are true func will be called on the trailing edge of 
+		* the timeout only if the the debounced function is invoked more than once during the wait 
+		* timeout.
+		* @param func The function to debounce.
+		* @param wait The number of milliseconds to delay.
+		* @param options The options object.
+		* @param options.leading Specify execution on the leading edge of the timeout.
+		* @param options.maxWait The maximum time func is allowed to be delayed before it’s called.
+		* @param options.trailing Specify execution on the trailing edge of the timeout.
+		* @return The new debounced function.
+		**/
+		debounce(
+			func: Function,
+			wait: number,
+			options?: DebounceSettings): Function;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.debounce
+		**/
+		debounce(
+			wait: number,
+			options?: DebounceSettings): LoDashObjectWrapper<Function>;
+	}
+
+	interface DebounceSettings {
+		/**
+		* Specify execution on the leading edge of the timeout.
+		**/
+		leading?: boolean;
+		
+		/**
+		* The maximum time func is allowed to be delayed before it’s called.
+		**/
+		maxWait?: number;
+
+		/**
+		* Specify execution on the trailing edge of the timeout.
+		**/
+		trailing?: boolean;
+	}
+
+	//_.defer
+	interface LoDashStatic {
+		/**
+		* Defers executing the func function until the current call stack has cleared. Additional 
+		* arguments will be provided to func when it is invoked.
+		* @param func The function to defer.
+		* @param args Arguments to invoke the function with.
+		* @return The timer id.
+		**/
+		defer(
+			func: Function,
+			...args: any[]): number;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.defer
+		**/
+		defer(...args: any[]): LoDashWrapper<number>;
+	}
+
+	//_.delay
+	interface LoDashStatic {
+		/**
+		* Executes the func function after wait milliseconds. Additional arguments will be provided 
+		* to func when it is invoked.
+		* @param func The function to delay.
+		* @param wait The number of milliseconds to delay execution.
+		* @param args Arguments to invoke the function with.
+		* @return The timer id.
+		**/
+		delay(
+			func: Function,
+			wait: number,
+			...args: any[]): number;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.delay
+		**/
+		delay(
+			wait: number,
+			...args: any[]): LoDashWrapper<number>;
+	}
+
+	//_.memoize
+	interface LoDashStatic {
+		/**
+		* Creates a function that memoizes the result of func. If resolver is provided it will be 
+		* used to determine the cache key for storing the result based on the arguments provided to 
+		* the memoized function. By default, the first argument provided to the memoized function is 
+		* used as the cache key. The func is executed with the this binding of the memoized function. 
+		* The result cache is exposed as the cache property on the memoized function.
+		* @param func Computationally expensive function that will now memoized results.
+		* @param resolver Hash function for storing the result of `fn`.
+		* @return Returns the new memoizing function.
+		**/
+		memoize(
+			func: Function,
+			resolver?: (n: any) => string): Function;
+	}
+
+	//_.once
+	interface LoDashStatic {
+		/**
+		* Creates a function that is restricted to execute func once. Repeat calls to the function 
+		* will return the value of the first call. The func is executed with the this binding of the 
+		* created function.
+		* @param func Function to only execute once.
+		* @return The new restricted function.
+		**/
+		once(func: Function): Function;
+	}
+
+	//_.partial
+	interface LoDashStatic {
+		/**
+		* Creates a function that, when called, invokes func with any additional partial arguments 
+		* prepended to those provided to the new function. This method is similar to _.bind except 
+		* it does not alter the this binding.
+		* @param func The function to partially apply arguments to.
+		* @param args Arguments to be partially applied.
+		* @return The new partially applied function.
+		**/
+		partial(
+			func: Function,
+			...args: any[]): Function;
+	}
+
+	//_.partialRight
+	interface LoDashStatic {
+		/**
+		* This method is like _.partial except that partial arguments are appended to those provided 
+		* to the new function.
+		* @param func The function to partially apply arguments to.
+		* @param args Arguments to be partially applied.
+		* @return The new partially applied function.
+		**/
+		partialRight(
+			func: Function,
+			...args: any[]): Function;
+	}
+
+	//_.throttle
+	interface LoDashStatic {
+		/**
+		* Creates a function that, when executed, will only call the func function at most once per 
+		* every wait milliseconds. Provide an options object to indicate that func should be invoked 
+		* on the leading and/or trailing edge of the wait timeout. Subsequent calls to the throttled 
+		* function will return the result of the last func call.
+		*
+		* Note: If leading and trailing options are true func will be called on the trailing edge of 
+		* the timeout only if the the throttled function is invoked more than once during the wait timeout.
+		* @param func The function to throttle.
+		* @param wait The number of milliseconds to throttle executions to.
+		* @param options The options object.
+		* @param options.leading Specify execution on the leading edge of the timeout.
+		* @param options.trailing Specify execution on the trailing edge of the timeout.
+		* @return The new throttled function.
+		**/
+		throttle(
+			func: any,
+			wait: number,
+			options?: ThrottleSettings): Function;
+	}
+
+	interface ThrottleSettings {
+
+		/**
+		* If you'd like to disable the leading-edge call, pass this as false.
+		**/
+		leading?: boolean;
+
+		/**
+		* If you'd like to disable the execution on the trailing-edge, pass false.
+		**/
+		trailing?: boolean;
+	}
+
+	//_.wrap
+	interface LoDashStatic {
+		/**
+		* Creates a function that provides value to the wrapper function as its first argument. 
+		* Additional arguments provided to the function are appended to those provided to the 
+		* wrapper function. The wrapper is executed with the this binding of the created function.
+		* @param value The value to wrap.
+		* @param wrapper The wrapper function.
+		* @return The new function.
+		**/
+		wrap(
+			value: any,
+			wrapper: (func: Function, ...args: any[]) => any): Function;
+	}
+
+	/*************
+	 * Objects   *
+	 *************/
+
+	//_.assign
+	interface LoDashStatic {
+		/**
+		* Assigns own enumerable properties of source object(s) to the destination object. Subsequent 
+		* sources will overwrite property assignments of previous sources. If a callback is provided 
+		* it will be executed to produce the assigned values. The callback is bound to thisArg and 
+		* invoked with two arguments; (objectValue, sourceValue).
+		* @param object The destination object.
+		* @param s1-8 The source object(s)
+		* @param callback The function to customize merging properties.
+		* @param thisArg The this binding of callback.
+		* @return The destination object.
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/		
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			s3: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			s7: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			s7: any,
+			s8: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/				
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				s3: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				s6: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				s6: any,
+				s7: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				s6: any,
+				s7: any,
+				s8: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/		
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			s3: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			s7: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			s7: any,
+			s8: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/		
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				s3: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				s6: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				s6: any,
+				s7: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				s6: any,
+				s7: any,
+				s8: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+	}
+
+	//_.clone
+	interface LoDashStatic {
+		/**
+		* Creates a clone of value. If deep is true nested objects will also be cloned, otherwise 
+		* they will be assigned by reference. If a callback is provided it will be executed to produce 
+		* the cloned values. If the callback returns undefined cloning will be handled by the method 
+		* instead. The callback is bound to thisArg and invoked with one argument; (value).
+		* @param value The value to clone.
+		* @param deep Specify a deep clone.
+		* @param callback The function to customize cloning values.
+		* @param thisArg The this binding of callback.
+		* @return The cloned value.
+		**/
+		clone<T>(
+			value: T,
+			deep?: boolean,
+			callback?: (value: any) => any,
+			thisArg?: any): T;
+	}
+
+	//_.cloneDeep
+	interface LoDashStatic {
+		/**
+		* Creates a deep clone of value. If a callback is provided it will be executed to produce the 
+		* cloned values. If the callback returns undefined cloning will be handled by the method instead. 
+		* The callback is bound to thisArg and invoked with one argument; (value).
+		*
+		* Note: This method is loosely based on the structured clone algorithm. Functions and DOM nodes 
+		* are not cloned. The enumerable properties of arguments objects and objects created by constructors 
+		* other than Object are cloned to plain Object objects. 
+		* See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.
+		* @param value The value to clone.
+		* @param callback The function to customize cloning values.
+		* @param thisArg The this binding of callback.
+		* @return The cloned value.
+		**/
+		cloneDeep<T>(
+			value: T,
+			callback?: (value: any) => any,
+			thisArg?: any): T;
+	}
+
+	//_.defaults
+	interface LoDashStatic {
+		/**
+		* Assigns own enumerable properties of source object(s) to the destination object for all 
+		* destination properties that resolve to undefined. Once a property is set, additional defaults 
+		* of the same property will be ignored.
+		* @param object The destination object.
+		* @param sources The source objects.
+		* @return The destination object.
+		**/
+		defaults<T, TResult>(
+			object: T,
+			...sources: any[]): TResult;	
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.defaults
+		**/
+		defaults<T, TResult>(...sources: any[]): LoDashObjectWrapper<TResult>
+	}
+
+	//_.findKey
+	interface LoDashStatic {
+		/**
+		* This method is like _.findIndex except that it returns the key of the first element that 
+		* passes the callback check, instead of the element itself.
+		* @param object The object to search.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return The key of the found element, else undefined.
+		**/
+		findKey(
+			object: any,
+			callback: (value: any) => boolean,
+			thisArg?: any): string;
+
+		/**
+		* @see _.findKey
+		* @param pluckValue _.pluck style callback
+		**/
+		findKey(
+			object: any,
+			pluckValue: string): string;
+
+		/**
+		* @see _.findKey
+		* @param whereValue _.where style callback
+		**/
+        findKey<W extends Dictionary<any>, T extends W>(
+			object: T,
+			whereValue: W): string;
+	}
+
+	//_.findLastKey
+	interface LoDashStatic {
+		/**
+		* This method is like _.findKey except that it iterates over elements of a collection in the opposite order.
+		* @param object The object to search.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return The key of the found element, else undefined.
+		**/
+		findLastKey(
+			object: any,
+			callback: (value: any) => boolean,
+			thisArg?: any): string;
+
+		/**
+		* @see _.findLastKey
+		* @param pluckValue _.pluck style callback
+		**/
+		findLastKey(
+			object: any,
+			pluckValue: string): string;
+
+		/**
+		* @see _.findLastKey
+		* @param whereValue _.where style callback
+		**/
+        findLastKey<W extends Dictionary<any>, T extends W>(
+			object: T,
+			whereValue: W): string;
+	}
+
+	//_.forIn
+	interface LoDashStatic {
+		/**
+		* Iterates over own and inherited enumerable properties of an object, executing the callback for 
+		* each property. The callback is bound to thisArg and invoked with three arguments; (value, key, 
+		* object). Callbacks may exit iteration early by explicitly returning false.
+		* @param object The object to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return object
+		**/
+		forIn<T extends {}>(
+			object: Dictionary<T>,
+			callback?: ObjectIterator<T, void>,
+			thisArg?: any): Dictionary<T>;
+	}
+
+	interface LoDashObjectWrapper {
+		/**
+		* @see _.forIn
+		**/
+		forIn<T extends {}>(
+			callback: ObjectIterator<T, void>,
+			thisArg?: any): _.LoDashObjectWrapper<T>;
+	}
+
+	//_.forInRight
+	interface LoDashStatic {
+		/**
+		* This method is like _.forIn except that it iterates over elements of a collection in the 
+		* opposite order.
+		* @param object The object to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return object
+		**/
+		forInRight<T extends {}>(
+			object: Dictionary<T>,
+			callback?: ObjectIterator<T, void>,
+			thisArg?: any): Dictionary<T>;
+	}
+
+	interface LoDashObjectWrapper {
+		/**
+		* @see _.forInRight
+		**/
+		forInRight<T extends {}>(
+			callback: ObjectIterator<T, void>,
+			thisArg?: any): _.LoDashObjectWrapper<T>;
+	}
+
+	//_.forOwn
+	interface LoDashStatic {
+		/**
+		* Iterates over own enumerable properties of an object, executing the callback for each 
+		* property. The callback is bound to thisArg and invoked with three arguments; (value, key, 
+		* object). Callbacks may exit iteration early by explicitly returning false.
+		* @param object The object to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return object
+		**/
+		forOwn<T extends {}>(
+			object: Dictionary<T>,
+			callback?: ObjectIterator<T, void>,
+			thisArg?: any): Dictionary<T>;
+	}
+
+	interface LoDashObjectWrapper {
+		/**
+		* @see _.forOwn
+		**/
+		forOwn<T extends {}>(
+			callback: ObjectIterator<T, void>,
+			thisArg?: any): _.LoDashObjectWrapper<T>;
+	}
+
+	//_.forOwnRight
+	interface LoDashStatic {
+		/**
+		* This method is like _.forOwn except that it iterates over elements of a collection in the 
+		* opposite order.
+		* @param object The object to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return object
+		**/
+		forOwnRight<T extends {}>(
+			object: Dictionary<T>,
+			callback?: ObjectIterator<T, void>,
+			thisArg?: any): Dictionary<T>;
+	}
+
+	interface LoDashObjectWrapper {
+		/**
+		* @see _.forOwnRight
+		**/
+		forOwnRight<T extends {}>(
+			callback: ObjectIterator<T, void>,
+			thisArg?: any): _.LoDashObjectWrapper<T>;
+	}
+
+	//_.functions
+	interface LoDashStatic {
+		/**
+		* Creates a sorted array of property names of all enumerable properties, own and inherited, of 
+		* object that have function values.
+		* @param object The object to inspect.
+		* @return An array of property names that have function values.
+		**/
+		functions(object: any): string[];
+
+			/**
+			* @see _functions
+			**/
+			methods(object: any): string[];
+	}
+
+	interface LoDashObjectWrapper {
+		/**
+		* @see _.functions
+		**/
+		functions(): _.LoDashArrayWrapper<string>
+
+			/**
+			* @see _.functions
+			**/
+			methods(): _.LoDashArrayWrapper<string>
+	}
+
+	//_.has
+	interface LoDashStatic {
+		/**
+		* Checks if the specified object property exists and is a direct property, instead of an 
+		* inherited property.
+		* @param object The object to check.
+		* @param property The property to check for.
+		* @return True if key is a direct property, else false.
+		**/
+		has(object: any, property: string): boolean;
+	}
+
+	//_.invert
+	interface LoDashStatic {
+		/**
+		* Creates an object composed of the inverted keys and values of the given object.
+		* @param object The object to invert.
+		* @return The created inverted object.
+		**/
+		invert(object: any): any;
+	}
+
+	//_.isArguments
+	interface LoDashStatic {
+		/**
+		* Checks if value is an arguments object.
+		* @param value The value to check.
+		* @return True if the value is an arguments object, else false.
+		**/
+		isArguments(value: any): boolean;
+	}
+
+	//_.isArray
+	interface LoDashStatic {
+		/**
+		* Checks if value is an array.
+		* @param value The value to check.
+		* @return True if the value is an array, else false.
+		**/
+		isArray(value: any): boolean;
+	}
+
+	//_.isBoolean
+	interface LoDashStatic {
+		/**
+		* Checks if value is a boolean value.
+		* @param value The value to check.
+		* @return True if the value is a boolean value, else false.
+		**/
+		isBoolean(value: any): boolean;
+	}
+
+	//_.isDate
+	interface LoDashStatic {
+		/**
+		* Checks if value is a date.
+		* @param value The value to check.
+		* @return True if the value is a date, else false.
+		**/
+		isDate(value: any): boolean;
+	}
+
+	//_.isElement
+	interface LoDashStatic {
+		/**
+		* Checks if value is a DOM element.
+		* @param value The value to check.
+		* @return True if the value is a DOM element, else false.
+		**/
+		isElement(value: any): boolean;
+	}
+
+	//_.isEmpty
+	interface LoDashStatic {
+		/**
+		* Checks if value is empty. Arrays, strings, or arguments objects with a length of 0 and objects 
+		* with no own enumerable properties are considered "empty".
+		* @param value The value to inspect.
+		* @return True if the value is empty, else false.
+		**/
+		isEmpty(value: any[]): boolean;
+
+		/**
+		* @see _.isEmpty
+		**/
+		isEmpty(value: Dictionary<any>): boolean;
+
+		/**
+		* @see _.isEmpty
+		**/
+		isEmpty(value: string): boolean;
+	}
+
+	//_.isEqual
+	interface LoDashStatic {
+		/**
+		* Performs a deep comparison between two values to determine if they are equivalent to each 
+		* other. If a callback is provided it will be executed to compare values. If the callback 
+		* returns undefined comparisons will be handled by the method instead. The callback is bound to 
+		* thisArg and invoked with two arguments; (a, b).
+		* @param a The value to compare.
+		* @param b The other value to compare.
+		* @param callback The function to customize comparing values.
+		* @param thisArg The this binding of callback.
+		* @return True if the values are equivalent, else false.
+		**/
+		isEqual(
+			a: any,
+			b: any,
+			callback?: (a: any, b: any) => boolean,
+			thisArg?: any): boolean;
+	}
+
+	//_.isFinite
+	interface LoDashStatic {
+		/**
+		* Checks if value is, or can be coerced to, a finite number.
+		*
+		* Note: This is not the same as native isFinite which will return true for booleans and empty 
+		* strings. See http://es5.github.io/#x15.1.2.5.
+		* @param value The value to check.
+		* @return True if the value is finite, else false.
+		**/
+		isFinite(value: any): boolean;
+	}
+
+	//_.isFunction
+	interface LoDashStatic {
+		/**
+		* Checks if value is a function.
+		* @param value The value to check.
+		* @return True if the value is a function, else false.
+		**/
+		isFunction(value: any): boolean;
+	}
+
+	//_.isNaN
+	interface LoDashStatic {
+		/**
+		* Checks if value is NaN.
+		*
+		* Note: This is not the same as native isNaN which will return true for undefined and other 
+		* non-numeric values. See http://es5.github.io/#x15.1.2.4.
+		* @param value The value to check.
+		* @return True if the value is NaN, else false.
+		**/
+		isNaN(value: any): boolean;
+	}
+
+	//_.isNull
+	interface LoDashStatic {
+		/**
+		* Checks if value is null.
+		* @param value The value to check.
+		* @return True if the value is null, else false.
+		**/
+		isNull(value: any): boolean;
+	}
+
+	//_.isNumber
+	interface LoDashStatic {
+		/**
+		* Checks if value is a number.
+		*
+		* Note: NaN is considered a number. See http://es5.github.io/#x8.5.
+		* @param value The value to check.
+		* @return True if the value is a number, else false.
+		**/
+		isNumber(value: any): boolean;
+	}
+
+	//_.isObject
+	interface LoDashStatic {
+		/**
+		* Checks if value is the language type of Object. (e.g. arrays, functions, objects, regexes, 
+		* new Number(0), and new String(''))
+		* @param value The value to check.
+		* @return True if the value is an object, else false.
+		**/
+		isObject(value: any): boolean;
+	}
+
+	//_.isPlainObject
+	interface LoDashStatic {
+		/**
+		* Checks if value is an object created by the Object constructor.
+		* @param value The value to check.
+		* @return True if value is a plain object, else false.
+		**/
+		isPlainObject(value: any): boolean;
+	}
+
+	//_.isRegExp
+	interface LoDashStatic {
+		/**
+		* Checks if value is a regular expression.
+		* @param value The value to check.
+		* @return True if the value is a regular expression, else false.
+		**/
+		isRegExp(value: any): boolean;
+	}
+
+	//_.isString
+	interface LoDashStatic {
+		/**
+		* Checks if value is a string.
+		* @param value The value to check.
+		* @return True if the value is a string, else false.
+		**/
+		isString(value: any): boolean;
+	}
+
+	//_.isUndefined
+	interface LoDashStatic {
+		/**
+		* Checks if value is undefined.
+		* @param value The value to check.
+		* @return True if the value is undefined, else false.
+		**/
+		isUndefined(value: any): boolean;
+	}
+
+	//_.keys
+	interface LoDashStatic {
+		/**
+		* Creates an array composed of the own enumerable property names of an object.
+		* @param object The object to inspect.
+		* @return An array of property names.
+		**/
+		keys(object: any): string[];
+	}
+
+	//_.merge
+	interface LoDashStatic {
+		/**
+		* Recursively merges own enumerable properties of the source object(s), that don't resolve 
+		* to undefined into the destination object. Subsequent sources will overwrite property 
+		* assignments of previous sources. If a callback is provided it will be executed to produce 
+		* the merged values of the destination and source properties. If the callback returns undefined 
+		* merging will be handled by the method instead. The callback is bound to thisArg and invoked 
+		* with two arguments; (objectValue, sourceValue).
+		* @param object The destination object.
+		* @param s1-8 The source object(s)
+		* @param callback The function to customize merging properties.
+		* @param thisArg The this binding of callback.
+		* @return The destination object.
+		**/
+		merge(
+			object: any,
+			s1: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			s3: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			s7: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			s7: any,
+			s8: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+	}
+
+	//_.omit
+	interface LoDashStatic {
+		/**
+		* Creates a shallow clone of object excluding the specified properties. Property names may be 
+		* specified as individual arguments or as arrays of property names. If a callback is provided 
+		* it will be executed for each property of object omitting the properties the callback returns 
+		* truey for. The callback is bound to thisArg and invoked with three arguments; (value, key, 
+		* object).
+		* @param object The source object.
+		* @param keys The properties to omit.
+		* @return An object without the omitted properties.
+		**/
+        omit<Omitted, T extends Omitted>(
+			object: T,
+			...keys: string[]): Omitted;
+
+		/**
+		* @see _.omit
+		**/
+		omit<Omitted, T extends Omitted>(
+			object: T,
+			keys: string[]): Omitted;
+
+		/**
+		* @see _.omit
+		**/
+		omit<Omitted, T extends Omitted>(
+			object: T,
+			callback: ObjectIterator<any, boolean>,
+			thisArg?: any): Omitted;
+	}
+
+	//_.pairs
+	interface LoDashStatic {
+		/**
+		* Creates a two dimensional array of an object’s key-value pairs, 
+		* i.e. [[key1, value1], [key2, value2]].
+		* @param object The object to inspect.
+		* @return Aew array of key-value pairs.
+		**/
+		pairs(object: any): any[][];
+	}
+
+	//_.picks
+	interface LoDashStatic {
+		/**
+		* Creates a shallow clone of object composed of the specified properties. Property names may be 
+		* specified as individual arguments or as arrays of property names. If a callback is provided 
+		* it will be executed for each property of object picking the properties the callback returns 
+		* truey for. The callback is bound to thisArg and invoked with three arguments; (value, key, 
+		* object).
+		* @param object Object to strip unwanted key/value pairs.
+		* @param keys Property names to pick
+		* @return An object composed of the picked properties.
+		**/
+        pick<Picked, T extends Picked>(
+			object: T,
+			...keys: string[]): Picked;
+
+		/**
+		* @see _.pick
+		**/
+		pick<Picked, T extends Picked>(
+			object: T,
+			keys: string[]): Picked;
+
+		/**
+		* @see _.pick
+		**/
+		pick<Picked, T extends Picked>(
+			object: T,
+			callback: ObjectIterator<any, boolean>,
+			thisArg?: any): Picked;
+	}
+
+	//_.transform
+	interface LoDashStatic {
+		/**
+		* An alternative to _.reduce this method transforms object to a new accumulator object which is 
+		* the result of running each of its elements through a callback, with each callback execution 
+		* potentially mutating the accumulator object. The callback is bound to thisArg and invoked with 
+		* four arguments; (accumulator, value, key, object). Callbacks may exit iteration early by 
+		* explicitly returning false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param accumulator The custom accumulator value.
+		* @param thisArg The this binding of callback.
+		* @return The accumulated value.
+		**/
+		transform<T>(
+			collection: Collection<T>,
+			callback?: MemoIterator<T, any>,
+			accumulator?: any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.transform
+		**/
+		transform<T>(
+			collection: Collection<T>,
+			callback?: MemoIterator<T, any>,
+			thisArg?: any): any;
+	}
+
+	//_.values
+	interface LoDashStatic {
+		/**
+		* Creates an array composed of the own enumerable property values of object.
+		* @param object The object to inspect.
+		* @return Returns an array of property values.
+		**/
+		values(object: any): any[];
+	}
+
+	/*************
+	 * Utilities *
+	 *************/
+	//_.escape
+	interface LoDashStatic {
+		/**
+		* Converts the characters &, <, >, ", and ' in string to their corresponding HTML entities.
+		* @param string The string to escape.
+		* @return The escaped string.
+		**/
+		escape(str: string): string;
+	}
+
+	//_.identity
+	interface LoDashStatic {
+		/**
+		* This method returns the first argument provided to it.
+		* @param value Any value.
+		* @return value.
+		**/
+		identity<T>(value: T): T;
+	}
+
+	//_.mixin
+	interface LoDashStatic {
+		/**
+		* Adds function properties of a source object to the lodash function and chainable wrapper.
+		* @param object The object of function properties to add to lodash.
+		**/
+		mixin(object: Dictionary<(value: any) => any>): void;
+	}
+
+	//_.noConflict
+	interface LoDashStatic {
+		/**
+		* Reverts the '_' variable to its previous value and returns a reference to the lodash function.
+		* @return The lodash function.
+		**/
+		noConflict(): typeof _;
+	}
+
+	//_.parseInt
+	interface LoDashStatic {
+		/**
+		* Converts the given value into an integer of the specified radix. If radix is undefined or 0 a 
+		* radix of 10 is used unless the value is a hexadecimal, in which case a radix of 16 is used.
+		*
+		* Note: This method avoids differences in native ES3 and ES5 parseInt implementations. See 
+		* http://es5.github.io/#E.
+		* @param value The value to parse.
+		* @param radix The radix used to interpret the value to parse.
+		* @return The new integer value.
+		**/
+		parseInt(value: string): number;
+	}
+
+	//_.random
+	interface LoDashStatic {
+		/**
+		* Produces a random number between min and max (inclusive). If only one argument is provided a 
+		* number between 0 and the given number will be returned. If floating is truey or either min or 
+		* max are floats a floating-point number will be returned instead of an integer.
+		* @param max The maximum possible value.
+		* @param floating Specify returning a floating-point number.
+		* @return A random number.
+		**/
+		random(max: number, floating?: boolean): number;
+	
+		/**
+		* @see _.random
+		* @param min The minimum possible value.
+		* @return A random number between `min` and `max`.
+		**/
+		random(min: number, max: number, floating?: boolean): number;
+	}
+
+	//_.result
+	interface LoDashStatic {
+		/**
+		* Resolves the value of property on object. If property is a function it will be invoked with 
+		* the this binding of object and its result returned, else the property value is returned. If 
+		* object is falsey then undefined is returned.
+		* @param object The object to inspect.
+		* @param property The property to get the value of.
+		* @return The resolved value.
+		**/
+		result(object: any, property: string): any;
+	}
+
+	//_.runInContext
+	interface LoDashStatic {
+		/**
+		* Create a new lodash function using the given context object.
+		* @param context The context object
+		* @returns The lodash function.
+		**/
+		runInContext(context: any): typeof _;
+	}
+
+	//_.template
+	interface LoDashStatic {
+		/**
+		* A micro-templating method that handles arbitrary delimiters, preserves whitespace, and 
+		* correctly escapes quotes within interpolated code.
+		*
+		* Note: In the development build, _.template utilizes sourceURLs for easier debugging. See 
+		* http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+		*
+		* For more information on precompiling templates see:
+		* http://lodash.com/#custom-builds
+		*
+		* For more information on Chrome extension sandboxes see:
+		* http://developer.chrome.com/stable/extensions/sandboxingEval.html
+		* @param text The template text.
+		* @param data The data object used to populate the text.
+		* @param options The options object.
+		* @param options.escape The "escape" delimiter.
+		* @param options.evaluate The "evaluate" delimiter.
+		* @param options.import An object to import into the template as local variables.
+		* @param options.interpolate The "interpolate" delimiter.
+		* @param sourceURL The sourceURL of the template’s compiled source.
+		* @param variable The data object variable name.
+		* @return Returns the compiled Lo-Dash HTML template or a TemplateExecutor if no data is passed.
+		**/
+		template(
+			text: string): TemplateExecutor;
+		
+		/**
+		* @see _.template
+		**/
+		template(
+			text: string,
+			data: any, 
+			options?: TemplateSettings,
+			sourceURL?: string,
+			variable?: string): any /* string or TemplateExecutor*/;
+	}
+
+	interface TemplateExecutor {
+		(...data: any[]): string;
+		source: string;
+	}
+		
+	//_.times
+	interface LoDashStatic {
+		/**
+		* Executes the callback n times, returning an array of the results of each callback execution. 
+		* The callback is bound to thisArg and invoked with one argument; (index).
+		* @param n The number of times to execute the callback.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		**/
+		times<TResult>(
+			n: number, 
+			callback: Function, 
+			context?: any): TResult[];
+	}
+
+	//_.unescape
+	interface LoDashStatic {
+		/**
+		* The inverse of _.escape this method converts the HTML entities &amp;, <, &gt;, &quot;, and 
+		* &#39; in string to their corresponding characters.
+		* @param string The string to unescape.
+		* @return The unescaped string.
+		**/
+		unescape(
+			string: string): string;
+	}
+
+	//_.uniqueId
+	interface LoDashStatic {
+		/**
+		* Generates a unique ID. If prefix is provided the ID will be appended to it.
+		* @param prefix The value to prefix the ID with.
+		* @return Returns the unique ID.
+		**/
+		uniqueId(prefix?: string): string;
+	}
+
+	interface ListIterator<T, TResult> {
+		(value: T, index: number, list: T[]): TResult;
+	}
+
+	interface ObjectIterator<T, TResult> {
+		(element: T, key: string, list: any): TResult;
+	}
+
+	interface MemoIterator<T, TResult> {
+		(prev: TResult, curr: T, indexOrKey: any, list?: T[]): TResult;
+	}
+
+	interface Collection<T> { }
+
+	// Common interface between Arrays and jQuery objects
+	interface List<T> extends Collection<T> {
+		[index: number]: T;
+		length: number;
+	}
+
+	interface Dictionary<T> extends Collection<T> {
+		[index: string]: T;
+	}
+}
\ No newline at end of file