diff --git a/lodash/lodash-tests.disabled.ts b/lodash/lodash-tests.disabled.ts
index aca0bbdf0..97c270940 100644
--- a/lodash/lodash-tests.disabled.ts
+++ b/lodash/lodash-tests.disabled.ts
@@ -41,16 +41,16 @@ interface IKey {
 
 var foodsOrganic: IFoodOrganic[] = [
 	{ name: 'banana', organic: true },
-	{ name: 'beet',   organic: false },
+	{ name: 'beet', organic: false },
 ];
 var foodsType: IFoodType[] = [
-	{ name: 'apple',  type: 'fruit' },
+	{ name: 'apple', type: 'fruit' },
 	{ name: 'banana', type: 'fruit' },
-	{ name: 'beet',   type: 'vegetable' }
+	{ name: 'beet', type: 'vegetable' }
 ];
 var foodsCombined: IFoodCombined[] = [
-  { 'name': 'apple',  'organic': false, 'type': 'fruit' },
-  { 'name': 'carrot', 'organic': true,  'type': 'vegetable' }
+	{ 'name': 'apple', 'organic': false, 'type': 'fruit' },
+	{ 'name': 'carrot', 'organic': true, 'type': 'vegetable' }
 ];
 
 var stoogesQuotes: IStoogesQuote[] = [
@@ -63,24 +63,24 @@ var stoogesAges: IStoogesAge[] = [
 ];
 
 var stoogesCombined: IStoogesCombined[] = [
-  { 'name': 'curly', 'age': 30, 'quotes': ['Oh, a wise guy, eh?', 'Poifect!'] },
-  { 'name': 'moe', 'age': 40, 'quotes': ['Spread out!', 'You knucklehead!'] }
+	{ '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 }
+	{ 'dir': 'left', 'code': 97 },
+	{ 'dir': 'right', 'code': 100 }
 ];
 
 class Dog {
-	constructor(public name: string) {}
+	constructor(public name: string) { }
 
 	public bark() {
-	  console.log('Woof, woof!');
+		console.log('Woof, woof!');
 	}
 }
 
-var result : any;
+var result: any;
 
 /*************
  * Chaining *
@@ -89,7 +89,10 @@ 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'});
+// Appears to be a change in the compiler, if the type explicity implements the object indexer.
+// Looking at: https://typescript.codeplex.com/wikipage?title=Known%20breaking%20changes%20between%200.8%20and%200.9&referringTitle=Documentation
+// "The ‘noimplicitany’ option now warns on the use of the hidden default indexer"
+result = <_.LoDashObjectWrapper<_.Dictionary<string>>>_(<{ [index: string]: string; }>{ 'key1': 'test1', 'key2': 'test2' });
 
 result = <_.LoDashWrapper<string>>_.chain('test');
 result = <_.LoDashWrapper<string>>_('test').chain();
@@ -99,8 +102,8 @@ 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();
+result = <_.LoDashObjectWrapper<_.Dictionary<string>>>_.chain(<{ [index: string]: string; }>{ 'key1': 'test1', 'key2': 'test2' });
+result = <_.LoDashObjectWrapper<_.Dictionary<string>>>_(<{ [index: string]: string; }>{ 'key1': 'test1', 'key2': 'test2' }).chain();
 
 //Wrapped array shortcut methods
 result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).concat(5, 6);
@@ -116,31 +119,31 @@ 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 = <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>>>_(<{ [index: string]: 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>_({ 'key1': 'test1', 'key2': 'test2' }).toString();
 
 result = <string>_('test').valueOf();
 result = <number[]>_([1, 2, 3]).valueOf();
-result = <_.Dictionary<string>>_({'key1': 'test1', 'key2': 'test2'}).valueOf();
+result = <_.Dictionary<string>>_(<{ [index: string]: string; }>{ 'key1': 'test1', 'key2': 'test2' }).valueOf();
 
 result = <string>_('test').value();
 result = <number[]>_([1, 2, 3]).value();
-result = <_.Dictionary<string>>_({'key1': 'test1', 'key2': 'test2'}).value();
+result = <_.Dictionary<string>>_(<{ [index: string]: 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 = <_.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 = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4, 5]).difference([5, 2, 10]);
 
 result = <number[]>_.rest([1, 2, 3]);
 result = <number[]>_.rest([1, 2, 3], 2);
@@ -160,48 +163,48 @@ 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'], 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>_.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'], 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>_.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 = <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>_.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>_.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 = <_.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);
@@ -209,8 +212,8 @@ 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 = <number[]>_.initial([1, 2, 3], function (num) {
+	return num > 1;
 });
 result = <IFoodOrganic[]>_.initial(foodsOrganic, 'organic');
 result = <IFoodType[]>_.initial(foodsType, { 'type': 'vegetable' });
@@ -219,8 +222,8 @@ 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 = <number[]>_.last([1, 2, 3], function (num) {
+	return num > 1;
 });
 result = <IFoodOrganic[]>_.last(foodsOrganic, 'organic');
 result = <IFoodType[]>_.last(foodsType, { 'type': 'vegetable' });
@@ -228,8 +231,8 @@ 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 = <{ [key: string]: any }>_.zipObject(['moe', 'larry'], [30, 40]);
+result = <{ [key: string]: any }>_.object(['moe', 'larry'], [30, 40]);
 
 result = <number[]>_.pull([1, 2, 3, 1, 2, 3], 2, 3);
 
@@ -240,39 +243,39 @@ 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 = <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 = <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 }
+	'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 sortedIndexDict.wordToNumber[word];
 });
-result = <number>_.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
-  return this.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 = <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[]>_.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[]>_.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);
 
@@ -291,165 +294,165 @@ 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 = <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([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 = <_.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 = <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 = <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; }).value();
-	result = <IFoodCombined[]>_(foodsCombined).filter('organic').value();
-	result = <IFoodCombined[]>_(foodsCombined).filter({ 'type': 'fruit' }).value();
+result = <number[]>_([1, 2, 3, 4, 5, 6]).filter(function (num) { return num % 2 == 0; }).value();
+result = <IFoodCombined[]>_(foodsCombined).filter('organic').value();
+result = <IFoodCombined[]>_(foodsCombined).filter({ 'type': 'fruit' }).value();
 
-	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[]>_.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; }).value();
-		result = <IFoodCombined[]>_(foodsCombined).select('organic').value();
-		result = <IFoodCombined[]>_(foodsCombined).select({ 'type': 'fruit' }).value();
+result = <number[]>_([1, 2, 3, 4, 5, 6]).select(function (num) { return num % 2 == 0; }).value();
+result = <IFoodCombined[]>_(foodsCombined).select('organic').value();
+result = <IFoodCombined[]>_(foodsCombined).select({ 'type': 'fruit' }).value();
 
-result = <number>_.find([1, 2, 3, 4], function(num) {
-  return num % 2 == 0;
+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>_.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>_.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 = <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[]>_.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 = <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]).forEach(function (num) { console.log(num); });
+result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_(<{ [index: string]: 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 = <_.LoDashArrayWrapper<number>>_([1, 2, 3]).each(function (num) { console.log(num); });
+result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_(<{ [index: string]: 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[]>_.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 = <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]).forEachRight(function (num) { console.log(num); });
+result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_(<{ [index: string]: 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 = <_.LoDashArrayWrapper<number>>_([1, 2, 3]).eachRight(function (num) { console.log(num); });
+result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_(<{ [index: string]: 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<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 = <_.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 = <_.Dictionary<IKey>>_.indexBy(keys, function (key) { return String.fromCharCode(key.code); });
+result = <_.Dictionary<IKey>>_.indexBy(keys, function (key) { this.fromCharCode(key.code); }, String);
 
 result = <number[][]>_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
 result = <string[][]>_.invoke([123, 456], String.prototype.split, '');
 
-result = <number[]>_.map([1, 2, 3], function(num) { return num * 3; });
-result = <number[]>_.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });
+result = <number[]>_.map([1, 2, 3], function (num) { return num * 3; });
+result = <number[]>_.map({ 'one': 1, 'two': 2, 'three': 3 }, function (num) { return num * 3; });
 result = <IStoogesAge[]>_.map(stoogesAges, 'name');
 
-	result = <number[]>_([1, 2, 3]).map(function(num) { return num * 3; }).value();
-	result = <number[]>_({ 'one': 1, 'two': 2, 'three': 3 }).map(function(num) { return num * 3; }).value();
-	result = <IStoogesAge[]>_(stoogesAges).map('name').value();
+result = <number[]>_([1, 2, 3]).map(function (num) { return num * 3; }).value();
+result = <number[]>_({ 'one': 1, 'two': 2, 'three': 3 }).map(function (num) { return num * 3; }).value();
+result = <IStoogesAge[]>_(stoogesAges).map('name').value();
 
-result = <number[]>_.collect([1, 2, 3], function(num) { return num * 3; });
-result = <number[]>_.collect({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });
+result = <number[]>_.collect([1, 2, 3], function (num) { return num * 3; });
+result = <number[]>_.collect({ 'one': 1, 'two': 2, 'three': 3 }, function (num) { return num * 3; });
 result = <IStoogesAge[]>_.collect(stoogesAges, 'name');
 
-	result = <number[]>_([1, 2, 3]).collect(function(num) { return num * 3; }).value();
-	result = <number[]>_({ 'one': 1, 'two': 2, 'three': 3 }).collect(function(num) { return num * 3; }).value();
-	result = <IStoogesAge[]>_(stoogesAges).collect('name').value();
+result = <number[]>_([1, 2, 3]).collect(function (num) { return num * 3; }).value();
+result = <number[]>_({ 'one': 1, 'two': 2, 'three': 3 }).collect(function (num) { return num * 3; }).value();
+result = <IStoogesAge[]>_(stoogesAges).collect('name').value();
 
 result = <number>_.max([4, 2, 8, 6]);
-result = <IStoogesAge>_.max(stoogesAges, function(stooge) { return stooge.age; });
+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, 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 = <number>_.reduce<number, number>([1, 2, 3], function (sum: number, num: number) {
+	return sum + num;
 });
 interface ABC {
-  a: number;
-  b: number;
-  c: number;
+	a: number;
+	b: number;
+	c: number;
 }
-result = <ABC>_.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(r: ABC, num, key) {
-  r[key] = num * 3;
-  return r;
+result = <ABC>_.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function (r: ABC, num, key) {
+	r[key] = num * 3;
+	return r;
 }, {});
 
-result = <number>_.foldl([1, 2, 3], function(sum, num) {
-  return sum + num;
+result = <number>_.foldl([1, 2, 3], function (sum, num) {
+	return sum + num;
 });
-result = <ABC>_.foldl({ 'a': 1, 'b': 2, 'c': 3 }, function(r: ABC, num, key) {
-  r[key] = num * 3;
-  return r;
+result = <ABC>_.foldl({ 'a': 1, 'b': 2, 'c': 3 }, function (r: ABC, num, key) {
+	r[key] = num * 3;
+	return r;
 }, {});
 
-result = <number>_.inject([1, 2, 3], function(sum, num) {
-  return sum + num;
+result = <number>_.inject([1, 2, 3], function (sum, num) {
+	return sum + num;
 });
-result = <ABC>_.inject({ 'a': 1, 'b': 2, 'c': 3 }, function(r: ABC, num, key) {
-  r[key] = num * 3;
-  return r;
+result = <ABC>_.inject({ 'a': 1, 'b': 2, 'c': 3 }, function (r: ABC, num, key) {
+	r[key] = num * 3;
+	return r;
 }, {});
 
-result = <number[]>_.reduceRight([[0, 1], [2, 3], [4, 5]], function(a: number[], b: number[]) { return a.concat(b); }, <number[]>[]);
-result = <number[]>_.foldr([[0, 1], [2, 3], [4, 5]], function(a: number[], b: number[]) { return a.concat(b); }, <number[]>[]);
+result = <number[]>_.reduceRight([[0, 1], [2, 3], [4, 5]], function (a: number[], b: number[]) { return a.concat(b); }, <number[]>[]);
+result = <number[]>_.foldr([[0, 1], [2, 3], [4, 5]], function (a: number[], b: number[]) { return a.concat(b); }, <number[]>[]);
 
-result = <number[]>_.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+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' });
 
@@ -465,20 +468,20 @@ 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 = <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: number, b: number, c: number, d: number){ return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
+(function (a: number, b: number, c: number, d: number) { return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
 
 result = <IStoogesCombined[]>_.where(stoogesCombined, { 'age': 40 });
 result = <IStoogesCombined[]>_.where(stoogesCombined, { 'quotes': ['Poifect!'] });
-	
+
 /*************
  * Functions *
  *************/
@@ -486,20 +489,20 @@ var saves = ['profile', 'settings'];
 var asyncSave = (obj: any) => obj.done();
 var done: Function;
 
-done = _.after(saves.length, function() {
-  console.log('Done saving!');
+done = _.after(saves.length, function () {
+	console.log('Done saving!');
 });
 
-_.forEach(saves, function(type) {
-  asyncSave({ 'type': type, 'complete': done });
+_.forEach(saves, function (type) {
+	asyncSave({ 'type': type, 'complete': done });
 });
 
-done = _(saves.length).after(function() {
-  console.log('Done saving!');
+done = _(saves.length).after(function () {
+	console.log('Done saving!');
 }).value();
 
-_.forEach(saves, function(type) {
-  asyncSave({ 'type': type, 'complete': done });
+_.forEach(saves, function (type) {
+	asyncSave({ 'type': type, 'complete': done });
 });
 
 var funcBind = function (greeting: string) { return greeting + ' ' + this.name };
@@ -510,8 +513,8 @@ var funcBind3: () => any = _(funcBind).bind({ 'name': 'moe' }, 'hi').value();
 funcBind3();
 
 var view = {
- 'label': 'docs',
- 'onClick': function() { console.log('clicked ' + this.label); }
+	'label': 'docs',
+	'onClick': function () { console.log('clicked ' + this.label); }
 };
 
 view = _.bindAll(view);
@@ -521,17 +524,17 @@ view = _(view).bindAll().value();
 jQuery('#docs').on('click', view.onClick);
 
 var objectBindKey = {
-  'name': 'moe',
-  'greet': function(greeting: string) {
-    return greeting + ' ' + this.name;
-  }
+	'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 + '!';
+objectBindKey.greet = function (greeting) {
+	return greeting + ', ' + this.name + '!';
 };
 
 funcBindKey();
@@ -540,78 +543,78 @@ funcBindKey = _(objectBindKey).bindKey('greet', 'hi').value();
 funcBindKey();
 
 var realNameMap = {
-  'curly': 'jerome'
+	'curly': 'jerome'
 };
 
-var format = function(name: string) {
-  name = realNameMap[name.toLowerCase()] || name;
-  return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+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 + '!';
+var greet = function (formatted: string) {
+	return 'Hiya ' + formatted + '!';
 };
 
 result = <Function>_.compose(greet, format);
 result = <_.LoDashObjectWrapper<Function>>_(greet).compose(format);
 
-var createCallbackObj = { name: 'Joe' };
+var createCallbackObj: { [index: string]: string; } = { 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 = <Function>_.curry(function (a, b, c) {
+	console.log(a + b + c);
 });
 
-result = <_.LoDashObjectWrapper<Function>>_(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);
+result = <Function>_.debounce(function () { }, 150);
 
-jQuery('#postbox').on('click', <Function>_.debounce(function() {}, 300, {
-  'leading': true,
-  'trailing': false
+jQuery('#postbox').on('click', <Function>_.debounce(function () { }, 300, {
+	'leading': true,
+	'trailing': false
 }));
 
-source.addEventListener('message', <Function>_.debounce(function() {}, 250, {
-  'maxWait': 1000
+source.addEventListener('message', <Function>_.debounce(function () { }, 250, {
+	'maxWait': 1000
 }), false);
 
-result = <_.LoDashObjectWrapper<Function>>_(function() {}).debounce(150);
+result = <_.LoDashObjectWrapper<Function>>_(function () { }).debounce(150);
 
-jQuery('#postbox').on('click', <_.LoDashObjectWrapper<Function>>_(function() {}).debounce(300, {
-  'leading': true,
-  'trailing': false
+jQuery('#postbox').on('click', <_.LoDashObjectWrapper<Function>>_(function () { }).debounce(300, {
+	'leading': true,
+	'trailing': false
 }));
 
-source.addEventListener('message', <_.LoDashObjectWrapper<Function>>_(function() {}).debounce(250, {
-  'maxWait': 1000
+source.addEventListener('message', <_.LoDashObjectWrapper<Function>>_(function () { }).debounce(250, {
+	'maxWait': 1000
 }), false);
 
 var returnedDebounce = _.throttle(function (a) { return a * 5; }, 5);
 returnedThrottled(4);
 
-result = <number>_.defer(function() { console.log('deferred'); });
-result = <_.LoDashWrapper<number>>_(function() { console.log('deferred'); }).defer();
+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 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 }
+	'moe': { 'name': 'moe', 'age': 40 },
+	'curly': { 'name': 'curly', 'age': 60 }
 };
 
-var stooge = _.memoize(function(name: string) { return data[name]; }, _.identity);
+var stooge = _.memoize(function (name: string) { return data[name]; }, _.identity);
 stooge('curly');
 
 stooge['cache']['curly'].name = 'jerome';
@@ -620,21 +623,21 @@ stooge('curly');
 var returnedMemoize = _.throttle(function (a) { return a * 5; }, 5);
 returnedMemoize(4);
 
-var initialize = _.once(function(){ });
+var initialize = _.once(function () { });
 initialize();
 initialize();''
 var returnedOnce = _.throttle(function (a) { return a * 5; }, 5);
 returnedOnce(4);
 
-var greetPartial = function(greeting: string, name: string) { return greeting + ' ' + name; };
+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': $ }
+	'variable': 'data',
+	'imports': { 'jq': $ }
 };
 
 defaultsDeep(optionsPartialRight, _.templateSettings);
@@ -642,16 +645,16 @@ defaultsDeep(optionsPartialRight, _.templateSettings);
 var throttled = _.throttle(function () { }, 100);
 jQuery(window).on('scroll', throttled);
 
-jQuery('.interactive').on('click', _.throttle(function() { }, 300000, {
-  'trailing': false
+jQuery('.interactive').on('click', _.throttle(function () { }, 300000, {
+	'trailing': false
 }));
 
-var returnedThrottled = _.throttle(function (a) { return a*5; }, 5);
+var returnedThrottled = _.throttle(function (a) { return a * 5; }, 5);
 returnedThrottled(4);
 
-var helloWrap = function(name: string) { return 'hello ' + name; };
-var helloWrap2 = _.wrap(helloWrap, function(func) {
-  return 'before, ' + func('moe') + ', after';
+var helloWrap = function (name: string) { return 'hello ' + name; };
+var helloWrap2 = _.wrap(helloWrap, function (func) {
+	return 'before, ' + func('moe') + ', after';
 });
 helloWrap2();
 
@@ -659,93 +662,93 @@ helloWrap2();
 * Objects *
 ***********/
 interface NameAge {
-  name: string;
-  age: number;
+	name: string;
+	age: number;
 }
 result = <NameAge>_.assign({ 'name': 'moe' }, { 'age': 40 });
-result = <NameAge>_.assign({ 'name': 'moe' }, { 'age': 40 }, function(a, b) {
-  return typeof a == 'undefined' ? b : a;
+result = <NameAge>_.assign({ 'name': 'moe' }, { 'age': 40 }, function (a, b) {
+	return typeof a == 'undefined' ? b : a;
 });
 
 result = <_.LoDashObjectWrapper<NameAge>>_({ 'name': 'moe' }).assign({ 'age': 40 });
-result = <_.LoDashObjectWrapper<NameAge>>_({ 'name': 'moe' }).assign({ 'age': 40 }, function(a, b) {
-  return typeof a == 'undefined' ? b : a;
+result = <_.LoDashObjectWrapper<NameAge>>_({ 'name': 'moe' }).assign({ 'age': 40 }, function (a, b) {
+	return typeof a == 'undefined' ? b : a;
 });
 
 result = <NameAge>_.extend({ 'name': 'moe' }, { 'age': 40 });
-result = <NameAge>_.extend({ 'name': 'moe' }, { 'age': 40 }, function(a, b) {
-  return typeof a == 'undefined' ? b : a;
+result = <NameAge>_.extend({ 'name': 'moe' }, { 'age': 40 }, function (a, b) {
+	return typeof a == 'undefined' ? b : a;
 });
 
 result = <_.LoDashObjectWrapper<NameAge>>_({ 'name': 'moe' }).extend({ 'age': 40 });
-result = <_.LoDashObjectWrapper<NameAge>>_({ 'name': 'moe' }).extend({ 'age': 40 }, function(a, b) {
-  return typeof a == 'undefined' ? b : a;
+result = <_.LoDashObjectWrapper<NameAge>>_({ 'name': 'moe' }).extend({ 'age': 40 }, function (a, b) {
+	return typeof a == 'undefined' ? b : a;
 });
 
 result = <IStoogesAge[]>_.clone(stoogesAges);
 result = <IStoogesAge[]>_.clone(stoogesAges, true);
-result = <any>_.clone(stoogesAges, true, function(value) {
-    return _.isElement(value) ? value.cloneNode(false) : undefined;
+result = <any>_.clone(stoogesAges, true, function (value) {
+	return _.isElement(value) ? value.cloneNode(false) : undefined;
 });
 
 result = <IStoogesAge[]>_.cloneDeep(stoogesAges);
-result = <IStoogesAge[]>_.cloneDeep(stoogesAges, function(value) {
-    return _.isElement(value) ? value.cloneNode(false) : undefined;
+result = <IStoogesAge[]>_.cloneDeep(stoogesAges, function (value) {
+	return _.isElement(value) ? value.cloneNode(false) : undefined;
 });
 
 interface Food {
-  name: string;
-  type: string;
+	name: string;
+	type: string;
 }
 var foodDefaults = { 'name': 'apple' };
 result = <Food>_.defaults(foodDefaults, { 'name': 'banana', 'type': 'fruit' });
-  result = <_.LoDashObjectWrapper<Food>>_(foodDefaults).defaults({ 'name': 'banana', 'type': 'fruit' });
+result = <_.LoDashObjectWrapper<Food>>_(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>_.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 = <string>_.findLastKey({ 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, function (num) {
+	return num % 2 == 1;
 });
 
-result = <Dog>_.forIn(new Dog('Dagny'), function(value, key) {
-  console.log(key);
+result = <Dog>_.forIn(new Dog('Dagny'), function (value, key) {
+	console.log(key);
 });
 
-result = <_.LoDashObjectWrapper<Dog>>_(new Dog('Dagny')).forIn(function(value, key) {
-  console.log(key);
+result = <_.LoDashObjectWrapper<Dog>>_(new Dog('Dagny')).forIn(function (value, key) {
+	console.log(key);
 });
 
-result = <Dog>_.forInRight(new Dog('Dagny'), function(value, key) {
-  console.log(key);
+result = <Dog>_.forInRight(new Dog('Dagny'), function (value, key) {
+	console.log(key);
 });
 
-result = <_.LoDashObjectWrapper<Dog>>_(new Dog('Dagny')).forInRight(function(value, key) {
-  console.log(key);
+result = <_.LoDashObjectWrapper<Dog>>_(new Dog('Dagny')).forInRight(function (value, key) {
+	console.log(key);
 });
 
 interface ZeroOne {
-  0: string;
-  1: string;
-  one: string;
+	0: string;
+	1: string;
+	one: string;
 }
 
-result = <ZeroOne>_.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
-  console.log(key);
+result = <ZeroOne>_.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function (num, key) {
+	console.log(key);
 });
 
-	result = <_.LoDashObjectWrapper<ZeroOne>>_({ '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<ZeroOne>>_({ '0': 'zero', '1': 'one', 'length': 2 }).forOwn(function (num, key) {
+	console.log(key);
 });
 
-	result = <_.LoDashObjectWrapper<ZeroOne>>_({ '0': 'zero', '1': 'one', 'length': 2 }).forOwnRight(function(num, key) {
-	  console.log(key);
-	});
+result = <any>_.forOwnRight({ '0': 'zero', '1': 'one', 'length': 2 }, function (num, key) {
+	console.log(key);
+});
+
+result = <_.LoDashObjectWrapper<ZeroOne>>_({ '0': 'zero', '1': 'one', 'length': 2 }).forOwnRight(function (num, key) {
+	console.log(key);
+});
 
 result = <string[]>_.functions(_);
 result = <string[]>_.methods(_);
@@ -756,12 +759,12 @@ result = <_.LoDashArrayWrapper<string>>_(_).methods();
 result = <boolean>_.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');
 
 interface FirstSecond {
-  first: string;
-  second: string;
+	first: string;
+	second: string;
 }
 result = <FirstSecond>_.invert({ 'first': 'moe', 'second': 'larry' });
 
-(function(...args: any[]) { return <boolean>_.isArguments(arguments); })(1, 2, 3);
+(function (...args: any[]) { return <boolean>_.isArguments(arguments); })(1, 2, 3);
 
 (function () { return <boolean>_.isArray(arguments); })();
 result = <boolean>_.isArray([1, 2, 3]);
@@ -784,12 +787,12 @@ 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);
+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;
+	return (aGreet || bGreet) ? (aGreet == bGreet) : undefined;
 });
 
 result = <boolean>_.isFinite(-101);
@@ -817,7 +820,7 @@ class Stooge {
 	constructor(
 		public name: string,
 		public age: number
-	) {}
+		) { }
 }
 
 result = <boolean>_.isPlainObject(new Stooge('moe', 40));
@@ -833,67 +836,67 @@ result = <boolean>_.isUndefined(void 0);
 result = <string[]>_.keys({ 'one': 1, 'two': 2, 'three': 3 });
 
 var mergeNames = {
-  'stooges': [
-    { 'name': 'moe' },
-    { 'name': 'larry' }
-  ]
+	'stooges': [
+		{ 'name': 'moe' },
+		{ 'name': 'larry' }
+	]
 };
 
 var mergeAges = {
-  'stooges': [
-    { 'age': 40 },
-    { 'age': 50 }
-  ]
+	'stooges': [
+		{ 'age': 40 },
+		{ 'age': 50 }
+	]
 };
 
 result = <NameAge>_.merge(mergeNames, mergeAges);
 
 var mergeFood = {
-  'fruits': ['apple'],
-  'vegetables': ['beet']
+	'fruits': ['apple'],
+	'vegetables': ['beet']
 };
 
 var mergeOtherFood = {
-  'fruits': ['banana'],
-  'vegetables': ['carrot']
+	'fruits': ['banana'],
+	'vegetables': ['carrot']
 };
 
 interface FruitVeg {
-  fruits: string[];
-  vegetables: string[]
+	fruits: string[];
+	vegetables: string[]
 };
 
-result = <FruitVeg[]>_.merge(mergeFood, mergeOtherFood, function(a, b) {
-  return _.isArray(a) ? a.concat(b) : undefined;
+result = <FruitVeg[]>_.merge(mergeFood, mergeOtherFood, function (a, b) {
+	return _.isArray(a) ? a.concat(b) : undefined;
 });
 
 interface HasName {
-  name: string;
+	name: string;
 }
 result = <HasName>_.omit({ 'name': 'moe', 'age': 40 }, 'age');
 result = <HasName>_.omit({ 'name': 'moe', 'age': 40 }, ['age']);
-result = <HasName>_.omit({ 'name': 'moe', 'age': 40 }, function(value) {
-  return typeof value == 'number';
+result = <HasName>_.omit({ 'name': 'moe', 'age': 40 }, function (value) {
+	return typeof value == 'number';
 });
 
 result = <any[][]>_.pairs({ 'moe': 30, 'larry': 40 });
 
 result = <HasName>_.pick({ 'name': 'moe', '_userid': 'moe1' }, 'name');
 result = <HasName>_.pick({ 'name': 'moe', '_userid': 'moe1' }, ['name']);
-result = <HasName>_.pick({ 'name': 'moe', '_userid': 'moe1' }, function(value, key) {
-  return key.charAt(0) != '_';
+result = <HasName>_.pick({ 'name': 'moe', '_userid': 'moe1' }, function (value, key) {
+	return key.charAt(0) != '_';
 });
 
-result = <number[]>_.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(r, num) {
-  num *= num;
-  if (num % 2) {
-    return r.push(num) < 3;
-  }
+result = <number[]>_.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function (r, num) {
+	num *= num;
+	if (num % 2) {
+		return r.push(num) < 3;
+	}
 });
 // → [1, 9, 25]
 
-result = <{a:number;b:number;c:number;}>_.transform({ 'a': 1, 'b': 2, 'c': 3 }, function(r, num, key) {
-  r[key] = num * 3;
+result = <{ a: number; b: number; c: number; }>_.transform({ 'a': 1, 'b': 2, 'c': 3 }, function (r, num, key) {
+	r[key] = num * 3;
 });
 
 result = <number[]>_.values({ 'one': 1, 'two': 2, 'three': 3 });
@@ -907,9 +910,9 @@ 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();
-  }
+	'capitalize': function (string) {
+		return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+	}
 });
 
 var lodash = <typeof _>_.noConflict();
@@ -923,10 +926,10 @@ result = <number>_.random(1.2, 5.2);
 result = <number>_.random(0, 5, true);
 
 var object = {
-  'cheese': 'crumpets',
-  'stuff': function() {
-    return 'nonsense';
-  }
+	'cheese': 'crumpets',
+	'stuff': function () {
+		return 'nonsense';
+	}
 };
 
 result = <string>_.result(object, 'cheese');
@@ -960,10 +963,10 @@ class Mage {
 	}
 }
 
-var mage = new Mage(); 
+var mage = new Mage();
 result = _.times(3, <() => number>_.partial(_.random, 1, 6));
-result = _.times(3, function(n: number) { mage.castSpell(n); });
-result = _.times(3, function(n: number) { this.cast(n); }, mage);
+result = _.times(3, function (n: number) { mage.castSpell(n); });
+result = _.times(3, function (n: number) { this.cast(n); }, mage);
 
 result = <string>_.unescape('Moe, Larry &amp; Curly');
 
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index b48f7e603..3c4b572c1 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -181,15 +181,15 @@ declare module _ {
 		**/
 		valueOf(): T;
 
-			/**
-			* @see valueOf
-			**/
-			value(): T;
-	} 
+		/**
+		* @see valueOf
+		**/
+		value(): T;
+	}
 
-	interface LoDashWrapper<T> extends LoDashWrapperBase<T, LoDashWrapper<T>> {}
+	interface LoDashWrapper<T> extends LoDashWrapperBase<T, LoDashWrapper<T>> { }
 
-	interface LoDashObjectWrapper<T> extends LoDashWrapperBase<T, LoDashObjectWrapper<T>> {}
+	interface LoDashObjectWrapper<T> extends LoDashWrapperBase<T, LoDashObjectWrapper<T>> { }
 
 	interface LoDashArrayWrapper<T> extends LoDashWrapperBase<T[], LoDashArrayWrapper<T>> {
 		concat(...items: T[]): LoDashArrayWrapper<T>;
@@ -263,6 +263,11 @@ declare module _ {
 		* @param array Array to compact.
 		* @return (Array) Returns a new array of filtered values.
 		**/
+		compact<T>(array: Array<T>): T[];
+
+		/**
+		* @see _.compact
+		**/
 		compact<T>(array: List<T>): T[];
 	}
 
@@ -270,8 +275,8 @@ declare module _ {
 		/**
 		* @see _.compact
 		**/
-		compact<T>(): LoDashArrayWrapper<T>;
-	}	
+		compact(): LoDashArrayWrapper<T>;
+	}
 
 	//_.difference
 	interface LoDashStatic {
@@ -282,6 +287,12 @@ declare module _ {
 		* @param others The arrays of values to exclude.
 		* @return Returns a new array of filtered values.
 		**/
+		difference<T>(
+			array: Array<T>,
+			...others: Array<T>[]): T[];
+		/**
+		* @see _.difference
+		**/
 		difference<T>(
 			array: List<T>,
 			...others: List<T>[]): T[];
@@ -291,6 +302,11 @@ declare module _ {
 		/**
 		* @see _.difference
 		**/
+		difference(
+			...others: Array<T>[]): LoDashArrayWrapper<T>;
+		/**
+		* @see _.difference
+		**/
 		difference(
 			...others: List<T>[]): LoDashArrayWrapper<T>;
 	}
@@ -307,7 +323,7 @@ declare module _ {
 		* @return Returns the index of the found element, else -1.
 		**/
 		findIndex<T>(
-			array: List<T>,
+			array: Array<T>,
 			callback: ListIterator<T, boolean>,
 			thisArg?: any): number;
 
@@ -316,8 +332,30 @@ declare module _ {
 		**/
 		findIndex<T>(
 			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): number;
+
+		/**
+		* @see _.findIndex
+		**/
+		findIndex<T>(
+			array: Array<T>,
 			pluckValue: string): number;
-		
+
+		/**
+		* @see _.findIndex
+		**/
+		findIndex<T>(
+			array: List<T>,
+			pluckValue: string): number;
+
+		/**
+		* @see _.findIndex
+		**/
+		findIndex<W, T>(
+			array: Array<T>,
+			whereDictionary: W): number;
+
 		/**
 		* @see _.findIndex
 		**/
@@ -336,18 +374,40 @@ declare module _ {
 		* @param thisArg The this binding of callback.
 		* @return Returns the index of the found element, else -1.
 		**/
+		findLastIndex<T>(
+			array: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): number;
+
+		/**
+		* @see _.findLastIndex
+		**/
 		findLastIndex<T>(
 			array: List<T>,
 			callback: ListIterator<T, boolean>,
 			thisArg?: any): number;
-		
+
+		/**
+		* @see _.findLastIndex
+		**/
+		findLastIndex<T>(
+			array: Array<T>,
+			pluckValue: string): number;
+
 		/**
 		* @see _.findLastIndex
 		**/
 		findLastIndex<T>(
 			array: List<T>,
 			pluckValue: string): number;
-		
+
+		/**
+		* @see _.findLastIndex
+		**/
+		findLastIndex<T>(
+			array: Array<T>,
+			whereDictionary: Dictionary<any>): number;
+
 		/**
 		* @see _.findLastIndex
 		**/
@@ -372,8 +432,21 @@ declare module _ {
 		* @param array Retrieves the first element of this array.
 		* @return Returns the first element of `array`.
 		**/
+		first<T>(array: Array<T>): T;
+
+		/**
+		* @see _.first
+		**/
 		first<T>(array: List<T>): T;
 
+		/**
+		* @see _.first
+		* @param n The number of elements to return.
+		**/
+		first<T>(
+			array: Array<T>,
+			n: number): T[];
+
 		/**
 		* @see _.first
 		* @param n The number of elements to return.
@@ -382,6 +455,16 @@ declare module _ {
 			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: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
 		/**
 		* @see _.first
 		* @param callback The function called per element.
@@ -392,6 +475,14 @@ declare module _ {
 			callback: ListIterator<T, boolean>,
 			thisArg?: any): T[];
 
+		/**
+		* @see _.first
+		* @param pluckValue "_.pluck" style callback value
+		**/
+		first<T>(
+			array: Array<T>,
+			pluckValue: string): T[];
+
 		/**
 		* @see _.first
 		* @param pluckValue "_.pluck" style callback value
@@ -400,6 +491,14 @@ declare module _ {
 			array: List<T>,
 			pluckValue: string): T[];
 
+		/**
+		* @see _.first
+		* @param whereValue "_.where" style callback value
+		**/
+		first<W, T>(
+			array: Array<T>,
+			whereValue: W): T[];
+
 		/**
 		* @see _.first
 		* @param whereValue "_.where" style callback value
@@ -408,73 +507,141 @@ declare module _ {
 			array: List<T>,
 			whereValue: W): T[];
 
-			/**
-			* @see _.first
-			**/
-			head<T>(array: List<T>): T;
+		/**
+		* @see _.first
+		**/
+		head<T>(array: Array<T>): T;
 
-			/**
-			* @see _.first
-			**/
-			head<T>(
-				array: List<T>,
-				n: number): T[];
+		/**
+		* @see _.first
+		**/
+		head<T>(array: List<T>): T;
 
-			/**
-			* @see _.first
-			**/
-			head<T>(
-				array: List<T>,
-				callback: ListIterator<T, boolean>,
-				thisArg?: any): T[];
+		/**
+		* @see _.first
+		**/
+		head<T>(
+			array: Array<T>,
+			n: number): T[];
 
-			/**
-			* @see _.first
-			**/
-			head<T>(
-				array: List<T>,
-				pluckValue: string): T[];
+		/**
+		* @see _.first
+		**/
+		head<T>(
+			array: List<T>,
+			n: number): T[];
 
-			/**
-			* @see _.first
-			**/
-			head<W, T>(
-				array: List<T>,
-				whereValue: W): T[];
+		/**
+		* @see _.first
+		**/
+		head<T>(
+			array: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
 
-			/**
-			* @see _.first
-			**/
-			take<T>(array: List<T>): T;
+		/**
+		* @see _.first
+		**/
+		head<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
 
-			/**
-			* @see _.first
-			**/
-			take<T>(
-				array: List<T>,
-				n: number): T[];
+		/**
+		* @see _.first
+		**/
+		head<T>(
+			array: Array<T>,
+			pluckValue: string): T[];
 
-			/**
-			* @see _.first
-			**/
-			take<T>(
-				array: List<T>,
-				callback: ListIterator<T, boolean>,
-				thisArg?: any): T[];
+		/**
+		* @see _.first
+		**/
+		head<T>(
+			array: List<T>,
+			pluckValue: string): T[];
 
-			/**
-			* @see _.first
-			**/
-			take<T>(
-				array: List<T>,
-				pluckValue: string): T[];
+		/**
+		* @see _.first
+		**/
+		head<W, T>(
+			array: Array<T>,
+			whereValue: W): T[];
 
-			/**
-			* @see _.first
-			**/
-			take<W, T>(
-				array: List<T>,
-				whereValue: W): T[];
+		/**
+		* @see _.first
+		**/
+		head<W, T>(
+			array: List<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.first
+		**/
+		take<T>(array: Array<T>): T;
+
+		/**
+		* @see _.first
+		**/
+		take<T>(array: List<T>): T;
+
+		/**
+		* @see _.first
+		**/
+		take<T>(
+			array: Array<T>,
+			n: number): T[];
+
+		/**
+		* @see _.first
+		**/
+		take<T>(
+			array: List<T>,
+			n: number): T[];
+
+		/**
+		* @see _.first
+		**/
+		take<T>(
+			array: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.first
+		**/
+		take<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.first
+		**/
+		take<T>(
+			array: Array<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.first
+		**/
+		take<T>(
+			array: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.first
+		**/
+		take<W, T>(
+			array: Array<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.first
+		**/
+		take<W, T>(
+			array: List<T>,
+			whereValue: W): T[];
 	}
 
 	//_.flatten
@@ -494,65 +661,153 @@ declare module _ {
 		* @param shallow If true then only flatten one level, optional, default = false.
 		* @return `array` flattened.
 		**/
+		flatten<T>(array: Array<any>, isShallow?: boolean): T[];
+
+		/**
+		* @see _.flatten
+		**/
 		flatten<T>(array: List<any>, isShallow?: boolean): T[];
 
+		/**
+		* @see _.flatten
+		**/
+		flatten<T>(
+			array: Array<any>,
+			isShallow: boolean,
+			callback: ListIterator<any, T>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.flatten
+		**/
 		flatten<T>(
 			array: List<any>,
 			isShallow: boolean,
 			callback: ListIterator<any, T>,
-			thisArg?: any): T[];			
+			thisArg?: any): T[];
 
+		/**
+		* @see _.flatten
+		**/
+		flatten<T>(
+			array: Array<any>,
+			callback: ListIterator<any, T>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.flatten
+		**/
 		flatten<T>(
 			array: List<any>,
 			callback: ListIterator<any, T>,
-			thisArg?: any): T[];			
+			thisArg?: any): T[];
 
+		/**
+		* @see _.flatten
+		**/
+		flatten<W, T>(
+			array: Array<any>,
+			isShallow: boolean,
+			whereValue: W): T[];
+
+		/**
+		* @see _.flatten
+		**/
 		flatten<W, T>(
 			array: List<any>,
 			isShallow: boolean,
-			whereValue: W): T[];			
+			whereValue: W): T[];
 
+		/**
+		* @see _.flatten
+		**/
+		flatten<W, T>(
+			array: Array<any>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.flatten
+		**/
 		flatten<W, T>(
 			array: List<any>,
-			whereValue: W): T[];			
+			whereValue: W): T[];
 
+		/**
+		* @see _.flatten
+		**/
+		flatten<T>(
+			array: Array<any>,
+			isShallow: boolean,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.flatten
+		**/
 		flatten<T>(
 			array: List<any>,
 			isShallow: boolean,
-			pluckValue: string): T[];			
+			pluckValue: string): T[];
 
+		/**
+		* @see _.flatten
+		**/
+		flatten<T>(
+			array: Array<any>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.flatten
+		**/
 		flatten<T>(
 			array: List<any>,
-			pluckValue: string): T[];			
+			pluckValue: string): T[];
 	}
 
 	interface LoDashArrayWrapper<T> {
 		/**
 		* @see _.flatten
 		**/
-        flatten<Flat>(isShallow?: boolean): LoDashArrayWrapper<Flat>;
+		flatten<Flat>(isShallow?: boolean): LoDashArrayWrapper<Flat>;
 
-        flatten<Flat>(
+		/**
+		* @see _.flatten
+		**/
+		flatten<Flat>(
 			isShallow: boolean,
 			callback: ListIterator<T, Flat>,
 			thisArg?: any): LoDashArrayWrapper<Flat>;
 
-        flatten<Flat>(
+		/**
+		* @see _.flatten
+		**/
+		flatten<Flat>(
 			callback: ListIterator<T, Flat>,
 			thisArg?: any): LoDashArrayWrapper<Flat>;
 
-        flatten<Flat>(
+		/**
+		* @see _.flatten
+		**/
+		flatten<Flat>(
 			isShallow: boolean,
 			pluckValue: string): LoDashArrayWrapper<Flat>;
 
-        flatten<Flat>(
+		/**
+		* @see _.flatten
+		**/
+		flatten<Flat>(
 			pluckValue: string): LoDashArrayWrapper<Flat>;
 
-        flatten<Flat, W>(
+		/**
+		* @see _.flatten
+		**/
+		flatten<Flat, W>(
 			isShallow: boolean,
 			whereValue: W): LoDashArrayWrapper<Flat>;
 
-        flatten<Flat, W>(
+		/**
+		* @see _.flatten
+		**/
+		flatten<Flat, W>(
 			whereValue: W): LoDashArrayWrapper<Flat>;
 	}
 
@@ -567,10 +822,26 @@ declare module _ {
 		* @param fromIndex The index to search from.
 		* @return The index of `value` within `array`.
 		**/
+		indexOf<T>(
+			array: Array<T>,
+			value: T): number;
+
+		/**
+		* @see _.indexOf
+		**/
 		indexOf<T>(
 			array: List<T>,
 			value: T): number;
 
+		/**
+		* @see _.indexOf
+		* @param fromIndex The index to search from
+		**/
+		indexOf<T>(
+			array: Array<T>,
+			value: T,
+			fromIndex: number): number;
+
 		/**
 		* @see _.indexOf
 		* @param fromIndex The index to search from
@@ -580,6 +851,15 @@ declare module _ {
 			value: T,
 			fromIndex: number): number;
 
+		/**
+		* @see _.indexOf
+		* @param isSorted True to perform a binary search on a sorted array.
+		**/
+		indexOf<T>(
+			array: Array<T>,
+			value: T,
+			isSorted: boolean): number;
+
 		/**
 		* @see _.indexOf
 		* @param isSorted True to perform a binary search on a sorted array.
@@ -607,9 +887,23 @@ declare module _ {
 		* @param n Leaves this many elements behind, optional.
 		* @return Returns everything but the last `n` elements of `array`.
 		**/
+		initial<T>(
+			array: Array<T>): T[];
+
+		/**
+		* @see _.initial
+		**/
 		initial<T>(
 			array: List<T>): T[];
 
+		/**
+		* @see _.initial
+		* @param n The number of elements to exclude.
+		**/
+		initial<T>(
+			array: Array<T>,
+			n: number): T[];
+
 		/**
 		* @see _.initial
 		* @param n The number of elements to exclude.
@@ -618,6 +912,14 @@ declare module _ {
 			array: List<T>,
 			n: number): T[];
 
+		/**
+		* @see _.initial
+		* @param callback The function called per element
+		**/
+		initial<T>(
+			array: Array<T>,
+			callback: ListIterator<T, boolean>): T[];
+
 		/**
 		* @see _.initial
 		* @param callback The function called per element
@@ -626,6 +928,14 @@ declare module _ {
 			array: List<T>,
 			callback: ListIterator<T, boolean>): T[];
 
+		/**
+		* @see _.initial
+		* @param pluckValue _.pluck style callback
+		**/
+		initial<T>(
+			array: Array<T>,
+			pluckValue: string): T[];
+
 		/**
 		* @see _.initial
 		* @param pluckValue _.pluck style callback
@@ -634,6 +944,14 @@ declare module _ {
 			array: List<T>,
 			pluckValue: string): T[];
 
+		/**
+		* @see _.initial
+		* @param whereValue _.where style callback
+		**/
+		initial<W, T>(
+			array: Array<T>,
+			whereValue: W): T[];
+
 		/**
 		* @see _.initial
 		* @param whereValue _.where style callback
@@ -651,6 +969,11 @@ declare module _ {
 		* @param arrays The arrays to inspect.
 		* @return Returns an array of composite values.
 		**/
+		intersection<T>(...arrays: Array<T>[]): T[];
+
+		/**
+		* @see _.intersection
+		**/
 		intersection<T>(...arrays: List<T>[]): T[];
 	}
 
@@ -669,8 +992,21 @@ declare module _ {
 		* @param array The array to query.
 		* @return Returns the last element(s) of array.
 		**/
+		last<T>(array: Array<T>): T;
+
+		/**
+		* @see _.last
+		**/
 		last<T>(array: List<T>): T;
 
+		/**
+		* @see _.last
+		* @param n The number of elements to return
+		**/
+		last<T>(
+			array: Array<T>,
+			n: number): T[];
+
 		/**
 		* @see _.last
 		* @param n The number of elements to return
@@ -679,6 +1015,15 @@ declare module _ {
 			array: List<T>,
 			n: number): T[];
 
+		/**
+		* @see _.last
+		* @param callback The function called per element
+		**/
+		last<T>(
+			array: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
 		/**
 		* @see _.last
 		* @param callback The function called per element
@@ -688,6 +1033,14 @@ declare module _ {
 			callback: ListIterator<T, boolean>,
 			thisArg?: any): T[];
 
+		/**
+		* @see _.last
+		* @param pluckValue _.pluck style callback
+		**/
+		last<T>(
+			array: Array<T>,
+			pluckValue: string): T[];
+
 		/**
 		* @see _.last
 		* @param pluckValue _.pluck style callback
@@ -696,6 +1049,14 @@ declare module _ {
 			array: List<T>,
 			pluckValue: string): T[];
 
+		/**
+		* @see _.last
+		* @param whereValue _.where style callback
+		**/
+		last<W, T>(
+			array: Array<T>,
+			whereValue: W): T[];
+
 		/**
 		* @see _.last
 		* @param whereValue _.where style callback
@@ -716,12 +1077,20 @@ declare module _ {
 		* @param fromIndex The index to search from.
 		* @return The index of the matched value or -1.
 		**/
+		lastIndexOf<T>(
+			array: Array<T>,
+			value: T,
+			fromIndex?: number): number;
+
+		/**
+		* @see _.lastIndexOf
+		**/
 		lastIndexOf<T>(
 			array: List<T>,
 			value: T,
 			fromIndex?: number): number;
 	}
-	
+
 	//_.pull
 	interface LoDashStatic {
 		/**
@@ -731,6 +1100,13 @@ declare module _ {
 		* @param values The values to remove.
 		* @return array.
 		**/
+		pull(
+			array: Array<any>,
+			...values: any[]): any[];
+
+		/**
+		* @see _.pull
+		**/
 		pull(
 			array: List<any>,
 			...values: any[]): any[];
@@ -747,12 +1123,11 @@ declare module _ {
 		* @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.
@@ -779,11 +1154,27 @@ declare module _ {
 		* @param thisArg The this binding of callback.
 		* @return A new array of removed elements.
 		**/
+		remove(
+			array: Array<any>,
+			callback?: ListIterator<any, boolean>,
+			thisArg?: any): any[];
+
+		/**
+		* @see _.remove
+		**/
 		remove(
 			array: List<any>,
 			callback?: ListIterator<any, boolean>,
 			thisArg?: any): any[];
 
+		/**
+		* @see _.remove
+		* @param pluckValue _.pluck style callback
+		**/
+		remove(
+			array: Array<any>,
+			pluckValue?: string): any[];
+
 		/**
 		* @see _.remove
 		* @param pluckValue _.pluck style callback
@@ -792,6 +1183,14 @@ declare module _ {
 			array: List<any>,
 			pluckValue?: string): any[];
 
+		/**
+		* @see _.remove
+		* @param whereValue _.where style callback
+		**/
+		remove(
+			array: Array<any>,
+			wherealue?: Dictionary<any>): any[];
+
 		/**
 		* @see _.remove
 		* @param whereValue _.where style callback
@@ -821,14 +1220,19 @@ declare module _ {
 		* @param {*} [thisArg] The this binding of callback.
 		* @return Returns a slice of array.
 		**/
+		rest<T>(array: Array<T>): T[];
+
+		/**
+		* @see _.rest
+		**/
 		rest<T>(array: List<T>): T[];
 
 		/**
 		* @see _.rest
 		**/
 		rest<T>(
-			array: List<T>,
-            callback: ListIterator<T, boolean>,
+			array: Array<T>,
+			callback: ListIterator<T, boolean>,
 			thisArg?: any): T[];
 
 		/**
@@ -836,89 +1240,186 @@ declare module _ {
 		**/
 		rest<T>(
 			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.rest
+		**/
+		rest<T>(
+			array: Array<T>,
 			n: number): T[];
-		
+
+		/**
+		* @see _.rest
+		**/
+		rest<T>(
+			array: List<T>,
+			n: number): T[];
+
+		/**
+		* @see _.rest
+		**/
+		rest<T>(
+			array: Array<T>,
+			pluckValue: string): T[];
+
 		/**
 		* @see _.rest
 		**/
 		rest<T>(
 			array: List<T>,
 			pluckValue: string): T[];
-		
+
 		/**
 		* @see _.rest
 		**/
-        rest<W, T>(
+		rest<W, T>(
+			array: Array<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.rest
+		**/
+		rest<W, T>(
 			array: List<T>,
 			whereValue: W): T[];
 
-            /**
-            * @see _.rest
-            **/
-            drop<T>(array: List<T>): T[];
+		/**
+		* @see _.rest
+		**/
+		drop<T>(array: Array<T>): T[];
 
-            /**
-            * @see _.rest
-            **/
-            drop<T>(
-                array: List<T>,
-                callback: ListIterator<T, boolean>,
-                thisArg?: any): T[];
+		/**
+		* @see _.rest
+		**/
+		drop<T>(array: List<T>): 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>(
-                array: List<T>,
-                whereValue: W): T[];
+		/**
+		* @see _.rest
+		**/
+		drop<T>(
+			array: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
 
-                /**
-                * @see _.rest
-                **/
-                tail<T>(array: List<T>): T[];
+		/**
+		* @see _.rest
+		**/
+		drop<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
 
-                /**
-                * @see _.rest
-                **/
-                tail<T>(
-                    array: List<T>,
-                    callback: ListIterator<T, boolean>,
-                    thisArg?: any): T[];
+		/**
+		* @see _.rest
+		**/
+		drop<T>(
+			array: Array<T>,
+			n: number): 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>(
-                    array: List<T>,
-                    whereValue: W): T[];
+		/**
+		* @see _.rest
+		**/
+		drop<T>(
+			array: List<T>,
+			n: number): T[];
+
+		/**
+		* @see _.rest
+		**/
+		drop<T>(
+			array: Array<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.rest
+		**/
+		drop<T>(
+			array: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.rest
+		**/
+		drop<W, T>(
+			array: Array<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.rest
+		**/
+		drop<W, T>(
+			array: List<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.rest
+		**/
+		tail<T>(array: Array<T>): T[];
+
+		/**
+		* @see _.rest
+		**/
+		tail<T>(array: List<T>): T[];
+
+		/**
+		* @see _.rest
+		**/
+		tail<T>(
+			array: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.rest
+		**/
+		tail<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.rest
+		**/
+		tail<T>(
+			array: Array<T>,
+			n: number): T[];
+
+		/**
+		* @see _.rest
+		**/
+		tail<T>(
+			array: List<T>,
+			n: number): T[];
+
+		/**
+		* @see _.rest
+		**/
+		tail<T>(
+			array: Array<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.rest
+		**/
+		tail<T>(
+			array: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.rest
+		**/
+		tail<W, T>(
+			array: Array<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.rest
+		**/
+		tail<W, T>(
+			array: List<T>,
+			whereValue: W): T[];
 	}
 
 	//_.sortedIndex
@@ -939,12 +1440,30 @@ declare module _ {
 		* @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: Array<T>,
+			value: T,
+			callback?: (x: T) => TSort,
+			thisArg?: any): number;
+
+		/**
+		* @see _.sortedIndex
+		**/
 		sortedIndex<T, TSort>(
 			array: List<T>,
 			value: T,
-			callback?: (x: T) => TSort, 
+			callback?: (x: T) => TSort,
 			thisArg?: any): number;
 
+		/**
+		* @see _.sortedIndex
+		* @param pluckValue the _.pluck style callback
+		**/
+		sortedIndex<T>(
+			array: Array<T>,
+			value: T,
+			pluckValue: string): number;
+
 		/**
 		* @see _.sortedIndex
 		* @param pluckValue the _.pluck style callback
@@ -954,6 +1473,15 @@ declare module _ {
 			value: T,
 			pluckValue: string): number;
 
+		/**
+		* @see _.sortedIndex
+		* @param pluckValue the _.where style callback
+		**/
+		sortedIndex<W, T>(
+			array: Array<T>,
+			value: T,
+			whereValue: W): number;
+
 		/**
 		* @see _.sortedIndex
 		* @param pluckValue the _.where style callback
@@ -972,6 +1500,11 @@ declare module _ {
 		* @param arrays The arrays to inspect.
 		* @return Returns an array of composite values.
 		**/
+		union<T>(...arrays: Array<T>[]): T[];
+
+		/**
+		* @see _.union
+		**/
 		union<T>(...arrays: List<T>[]): T[];
 	}
 
@@ -995,14 +1528,39 @@ declare module _ {
 		* @param context 'this' object in `iterator`, optional.
 		* @return Copy of `array` where all elements are unique.
 		**/
+		uniq<T, TSort>(array: Array<T>, isSorted?: boolean): T[];
+
+		/**
+		* @see _.uniq
+		**/
 		uniq<T, TSort>(array: List<T>, isSorted?: boolean): T[];
 
+		/**
+		* @see _.uniq
+		**/
+		uniq<T, TSort>(
+			array: Array<T>,
+			isSorted: boolean,
+			callback: ListIterator<T, TSort>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.uniq
+		**/
 		uniq<T, TSort>(
 			array: List<T>,
 			isSorted: boolean,
 			callback: ListIterator<T, TSort>,
 			thisArg?: any): T[];
 
+		/**
+		* @see _.uniq
+		**/
+		uniq<T, TSort>(
+			array: Array<T>,
+			callback: ListIterator<T, TSort>,
+			thisArg?: any): T[];
+
 		/**
 		* @see _.uniq
 		**/
@@ -1011,6 +1569,15 @@ declare module _ {
 			callback: ListIterator<T, TSort>,
 			thisArg?: any): T[];
 
+		/**
+		* @see _.uniq
+		* @param pluckValue _.pluck style callback
+		**/
+		uniq<T>(
+			array: Array<T>,
+			isSorted: boolean,
+			pluckValue: string): T[];
+
 		/**
 		* @see _.uniq
 		* @param pluckValue _.pluck style callback
@@ -1020,10 +1587,31 @@ declare module _ {
 			isSorted: boolean,
 			pluckValue: string): T[];
 
+		/**
+		* @see _.uniq
+		* @param pluckValue _.pluck style callback
+		**/
+		uniq<T>(
+			array: Array<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.uniq
+		* @param pluckValue _.pluck style callback
+		**/
 		uniq<T>(
 			array: List<T>,
 			pluckValue: string): T[];
 
+		/**
+		* @see _.uniq
+		* @param whereValue _.where style callback
+		**/
+		uniq<W, T>(
+			array: Array<T>,
+			isSorted: boolean,
+			whereValue: W): T[];
+
 		/**
 		* @see _.uniq
 		* @param whereValue _.where style callback
@@ -1033,54 +1621,133 @@ declare module _ {
 			isSorted: boolean,
 			whereValue: W): T[];
 
+		/**
+		* @see _.uniq
+		* @param whereValue _.where style callback
+		**/
+		uniq<W, T>(
+			array: Array<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.uniq
+		* @param whereValue _.where style callback
+		**/
 		uniq<W, T>(
 			array: List<T>,
 			whereValue: W): T[];
 
-			/**
-			* @see _.uniq
-			**/
-			unique<T>(array: List<T>, isSorted?: boolean): T[];
+		/**
+		* @see _.uniq
+		**/
+		unique<T>(array: Array<T>, isSorted?: boolean): T[];
 
-			unique<T, TSort>(
-				array: List<T>,
-				callback: ListIterator<T, TSort>,
-				thisArg?: any): T[];
+		/**
+		* @see _.uniq
+		**/
+		unique<T>(array: List<T>, isSorted?: boolean): T[];
 
-			/**
-			* @see _.uniq
-			**/
-			unique<T, TSort>(
-				array: List<T>,
-				isSorted: boolean,
-				callback: ListIterator<T, TSort>,
-				thisArg?: any): T[];
+		/**
+		* @see _.uniq
+		**/
+		unique<T, TSort>(
+			array: Array<T>,
+			callback: ListIterator<T, TSort>,
+			thisArg?: any): T[];
 
-			/**
-			* @see _.uniq
-			* @param pluckValue _.pluck style callback
-			**/
-			unique<T>(
-				array: List<T>,
-				isSorted: boolean,
-				pluckValue: string): T[];
+		/**
+		* @see _.uniq
+		**/
+		unique<T, TSort>(
+			array: List<T>,
+			callback: ListIterator<T, TSort>,
+			thisArg?: any): T[];
 
-			unique<T>(
-				array: List<T>,
-				pluckValue: string): T[];
+		/**
+		* @see _.uniq
+		**/
+		unique<T, TSort>(
+			array: Array<T>,
+			isSorted: boolean,
+			callback: ListIterator<T, TSort>,
+			thisArg?: any): T[];
 
-			/**
-			* @see _.uniq
-			* @param whereValue _.where style callback
-			**/
-			unique<W, T>(
-				array: List<T>,
-				whereValue?: W): T[];
+		/**
+		* @see _.uniq
+		**/
+		unique<T, TSort>(
+			array: List<T>,
+			isSorted: boolean,
+			callback: ListIterator<T, TSort>,
+			thisArg?: any): T[];
 
-			unique<W, T>(
-				array: List<T>,
-				isSorted: boolean,
-				whereValue?: W): T[];
+		/**
+		* @see _.uniq
+		* @param pluckValue _.pluck style callback
+		**/
+		unique<T>(
+			array: Array<T>,
+			isSorted: boolean,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.uniq
+		* @param pluckValue _.pluck style callback
+		**/
+		unique<T>(
+			array: List<T>,
+			isSorted: boolean,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.uniq
+		* @param pluckValue _.pluck style callback
+		**/
+		unique<T>(
+			array: Array<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.uniq
+		* @param pluckValue _.pluck style callback
+		**/
+		unique<T>(
+			array: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.uniq
+		* @param whereValue _.where style callback
+		**/
+		unique<W, T>(
+			array: Array<T>,
+			whereValue?: W): T[];
+
+		/**
+		* @see _.uniq
+		* @param whereValue _.where style callback
+		**/
+		unique<W, T>(
+			array: List<T>,
+			whereValue?: W): T[];
+
+		/**
+		* @see _.uniq
+		* @param whereValue _.where style callback
+		**/
+		unique<W, T>(
+			array: Array<T>,
+			isSorted: boolean,
+			whereValue?: W): T[];
+
+		/**
+		* @see _.uniq
+		* @param whereValue _.where style callback
+		**/
+		unique<W, T>(
+			array: List<T>,
+			isSorted: boolean,
+			whereValue?: W): T[];
 	}
 
 	//_.without
@@ -1091,6 +1758,13 @@ declare module _ {
 		* @param values The value(s) to exclude.
 		* @return A new array of filtered values.
 		**/
+		without<T>(
+			array: Array<T>,
+			...values: T[]): T[];
+
+		/**
+		* @see _.without
+		**/
 		without<T>(
 			array: List<T>,
 			...values: T[]): T[];
@@ -1112,15 +1786,15 @@ declare module _ {
 		**/
 		zip(...arrays: any[]): any[];
 
-			/**
-			* @see _.zip
-			**/
-			unzip(...arrays: any[][]): any[][];
+		/**
+		* @see _.zip
+		**/
+		unzip(...arrays: any[][]): any[][];
 
-			/**
-			* @see _.zip
-			**/
-			unzip(...arrays: any[]): any[];
+		/**
+		* @see _.zip
+		**/
+		unzip(...arrays: any[]): any[];
 	}
 
 	//_.zipObject
@@ -1137,12 +1811,12 @@ declare module _ {
 			keys: List<string>,
 			values: List<any>): TResult;
 
-			/**
-			* @see _.object
-			**/
-			object<TResult extends {}>(
-				keys: List<string>,
-				values: List<any>): TResult;
+		/**
+		* @see _.object
+		**/
+		object<TResult extends {}>(
+			keys: List<string>,
+			values: List<any>): TResult;
 	}
 
 	/* *************
@@ -1160,14 +1834,42 @@ declare module _ {
 		* @return A new array of elements corresponding to the provided indexes.
 		**/
 		at<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
 			indexes: number[]): T[];
 
 		/**
 		* @see _.at
 		**/
 		at<T>(
-			collection: Collection<T>,
+			collection: List<T>,
+			indexes: number[]): T[];
+
+		/**
+		* @see _.at
+		**/
+		at<T>(
+			collection: Dictionary<T>,
+			indexes: number[]): T[];
+
+		/**
+		* @see _.at
+		**/
+		at<T>(
+			collection: Array<T>,
+			...indexes: number[]): T[];
+
+		/**
+		* @see _.at
+		**/
+		at<T>(
+			collection: List<T>,
+			...indexes: number[]): T[];
+
+		/**
+		* @see _.at
+		**/
+		at<T>(
+			collection: Dictionary<T>,
 			...indexes: number[]): T[];
 	}
 
@@ -1182,7 +1884,15 @@ declare module _ {
 		* @return True if the target element is found, else false.
 		**/
 		contains<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			target: T,
+			fromIndex?: number): boolean;
+
+		/**
+		* @see _.contains
+		**/
+		contains<T>(
+			collection: List<T>,
 			target: T,
 			fromIndex?: number): boolean;
 
@@ -1206,29 +1916,37 @@ declare module _ {
 			targetString: string,
 			fromIndex?: number): boolean;
 
-			/**
-			* @see _.contains
-			**/
-			include<T>(
-				collection: Collection<T>,
-				target: T,
-				fromIndex?: number): boolean;
+		/**
+		* @see _.contains
+		**/
+		include<T>(
+			collection: Array<T>,
+			target: T,
+			fromIndex?: number): boolean;
 
-			/**
-			* @see _.contains
-			**/
-			include<T>(
-				dictionary: Dictionary<T>,
-				key: string,
-				fromIndex?: number): boolean;
+		/**
+		* @see _.contains
+		**/
+		include<T>(
+			collection: List<T>,
+			target: T,
+			fromIndex?: number): boolean;
 
-			/**
-			* @see _.contains
-			**/
-			include(
-				searchString: string,
-				targetString: string,
-				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
@@ -1250,7 +1968,7 @@ declare module _ {
 		* @return Returns the composed aggregate object.
 		**/
 		countBy<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
 			callback?: ListIterator<T, any>,
 			thisArg?: any): Dictionary<number>;
 
@@ -1259,16 +1977,52 @@ declare module _ {
 		* @param callback Function name
 		**/
 		countBy<T>(
-			collection: Collection<T>,
+			collection: List<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): Dictionary<number>;
+
+		/**
+		* @see _.countBy
+		* @param callback Function name
+		**/
+		countBy<T>(
+			collection: Dictionary<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): Dictionary<number>;
+
+		/**
+		* @see _.countBy
+		* @param callback Function name
+		**/
+		countBy<T>(
+			collection: Array<T>,
 			callback: string,
-			thisArg?: any): Dictionary<number>;			
+			thisArg?: any): Dictionary<number>;
+
+		/**
+		* @see _.countBy
+		* @param callback Function name
+		**/
+		countBy<T>(
+			collection: List<T>,
+			callback: string,
+			thisArg?: any): Dictionary<number>;
+
+		/**
+		* @see _.countBy
+		* @param callback Function name
+		**/
+		countBy<T>(
+			collection: Dictionary<T>,
+			callback: string,
+			thisArg?: any): Dictionary<number>;
 	}
 
 	interface LoDashArrayWrapper<T> {
 		/**
 		* @see _.countBy
 		**/
-		countBy<T>(
+		countBy(
 			callback?: ListIterator<T, any>,
 			thisArg?: any): LoDashObjectWrapper<Dictionary<number>>;
 
@@ -1276,7 +2030,7 @@ declare module _ {
 		* @see _.countBy
 		* @param callback Function name
 		**/
-		countBy<T>(
+		countBy(
 			callback: string,
 			thisArg?: any): LoDashObjectWrapper<Dictionary<number>>;
 	}
@@ -1299,7 +2053,7 @@ declare module _ {
 		* @return True if all elements passed the callback check, else false.
 		**/
 		every<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
 			callback?: ListIterator<T, boolean>,
 			thisArg?: any): boolean;
 
@@ -1308,7 +2062,41 @@ declare module _ {
 		* @param pluckValue _.pluck style callback
 		**/
 		every<T>(
-			collection: Collection<T>,
+			collection: List<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.every
+		* @param pluckValue _.pluck style callback
+		**/
+		every<T>(
+			collection: Dictionary<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.every
+		* @param pluckValue _.pluck style callback
+		**/
+		every<T>(
+			collection: Array<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.every
+		* @param pluckValue _.pluck style callback
+		**/
+		every<T>(
+			collection: List<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.every
+		* @param pluckValue _.pluck style callback
+		**/
+		every<T>(
+			collection: Dictionary<T>,
 			pluckValue: string): boolean;
 
 		/**
@@ -1316,32 +2104,96 @@ declare module _ {
 		* @param whereValue _.where style callback
 		**/
 		every<W, T>(
-			collection: Collection<T>,
+			collection: Array<T>,
 			whereValue: W): boolean;
 
-			/**
-			* @see _.every
-			**/
-			all<T>(
-				collection: Collection<T>,
-				callback?: ListIterator<T, boolean>,
-				thisArg?: any): boolean;
+		/**
+		* @see _.every
+		* @param whereValue _.where style callback
+		**/
+		every<W, T>(
+			collection: List<T>,
+			whereValue: W): boolean;
 
-			/**
-			* @see _.every
-			* @param pluckValue _.pluck style callback
-			**/
-			all<T>(
-				collection: Collection<T>,
-				pluckValue: string): boolean;
+		/**
+		* @see _.every
+		* @param whereValue _.where style callback
+		**/
+		every<W, T>(
+			collection: Dictionary<T>,
+			whereValue: W): boolean;
 
-			/**
-			* @see _.every
-			* @param whereValue _.where style callback
-			**/
-			all<W, T>(
-				collection: Collection<T>,
-				whereValue: W): boolean;
+		/**
+		* @see _.every
+		**/
+		all<T>(
+			collection: Array<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.every
+		**/
+		all<T>(
+			collection: List<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.every
+		**/
+		all<T>(
+			collection: Dictionary<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.every
+		* @param pluckValue _.pluck style callback
+		**/
+		all<T>(
+			collection: Array<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.every
+		* @param pluckValue _.pluck style callback
+		**/
+		all<T>(
+			collection: List<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.every
+		* @param pluckValue _.pluck style callback
+		**/
+		all<T>(
+			collection: Dictionary<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.every
+		* @param whereValue _.where style callback
+		**/
+		all<W, T>(
+			collection: Array<T>,
+			whereValue: W): boolean;
+
+		/**
+		* @see _.every
+		* @param whereValue _.where style callback
+		**/
+		all<W, T>(
+			collection: List<T>,
+			whereValue: W): boolean;
+
+		/**
+		* @see _.every
+		* @param whereValue _.where style callback
+		**/
+		all<W, T>(
+			collection: Dictionary<T>,
+			whereValue: W): boolean;
 	}
 
 	//_.filter
@@ -1362,7 +2214,23 @@ declare module _ {
 		* @return Returns a new array of elements that passed the callback check.
 		**/
 		filter<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.filter
+		**/
+		filter<T>(
+			collection: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.filter
+		**/
+		filter<T>(
+			collection: Dictionary<T>,
 			callback: ListIterator<T, boolean>,
 			thisArg?: any): T[];
 
@@ -1371,47 +2239,127 @@ declare module _ {
 		* @param pluckValue _.pluck style callback
 		**/
 		filter<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
 			pluckValue: string): T[];
 
 		/**
 		* @see _.filter
 		* @param pluckValue _.pluck style callback
 		**/
-        filter<W, T>(
-			collection: Collection<T>,
-            whereValue: W): T[];
+		filter<T>(
+			collection: List<T>,
+			pluckValue: string): T[];
 
-			/**
-			* @see _.filter
-			**/
-			select<T>(
-				collection: Collection<T>,
-				callback: ListIterator<T, boolean>,
-				thisArg?: any): T[];
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		filter<T>(
+			collection: Dictionary<T>,
+			pluckValue: string): T[];
 
-			/**
-			* @see _.filter
-			* @param pluckValue _.pluck style callback
-			**/
-			select<T>(
-				collection: Collection<T>,
-				pluckValue: string): T[];
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		filter<W, T>(
+			collection: Array<T>,
+			whereValue: W): T[];
 
-			/**
-			* @see _.filter
-			* @param pluckValue _.pluck style callback
-			**/
-			select<W, T>(
-				collection: Collection<T>,
-				whereValue: W): T[];
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		filter<W, T>(
+			collection: List<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		filter<W, T>(
+			collection: Dictionary<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.filter
+		**/
+		select<T>(
+			collection: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.filter
+		**/
+		select<T>(
+			collection: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.filter
+		**/
+		select<T>(
+			collection: Dictionary<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		select<T>(
+			collection: Array<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		select<T>(
+			collection: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		select<T>(
+			collection: Dictionary<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		select<W, T>(
+			collection: Array<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		select<W, T>(
+			collection: List<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		select<W, T>(
+			collection: Dictionary<T>,
+			whereValue: W): T[];
 	}
 
 	interface LoDashArrayWrapper<T> {
 		/**
 		* @see _.filter
 		**/
-		filter<T>(
+		filter(
 			callback: ListIterator<T, boolean>,
 			thisArg?: any): LoDashArrayWrapper<T>;
 
@@ -1419,36 +2367,36 @@ declare module _ {
 		* @see _.filter
 		* @param pluckValue _.pluck style callback
 		**/
-		filter<T>(
+		filter(
 			pluckValue: string): LoDashArrayWrapper<T>;
 
 		/**
 		* @see _.filter
 		* @param pluckValue _.pluck style callback
 		**/
-		filter<W, T>(
+		filter<W>(
 			whereValue: W): LoDashArrayWrapper<T>;
 
-			/**
-			* @see _.filter
-			**/
-			select<T>(
-				callback: ListIterator<T, boolean>,
-				thisArg?: any): LoDashArrayWrapper<T>;
+		/**
+		* @see _.filter
+		**/
+		select(
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): LoDashArrayWrapper<T>;
 
-			/**
-			* @see _.filter
-			* @param pluckValue _.pluck style callback
-			**/
-			select<T>(
-				pluckValue: string): LoDashArrayWrapper<T>;
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		select(
+			pluckValue: string): LoDashArrayWrapper<T>;
 
-			/**
-			* @see _.filter
-			* @param pluckValue _.pluck style callback
-			**/
-			select<W, T>(
-				whereValue: W): LoDashArrayWrapper<T>;
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		select<W>(
+			whereValue: W): LoDashArrayWrapper<T>;
 	}
 
 	//_.find
@@ -1469,7 +2417,23 @@ declare module _ {
 		* @return The found element, else undefined.
 		**/
 		find<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.find
+		**/
+		find<T>(
+			collection: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.find
+		**/
+		find<T>(
+			collection: Dictionary<T>,
 			callback: ListIterator<T, boolean>,
 			thisArg?: any): T;
 
@@ -1478,7 +2442,23 @@ declare module _ {
 		* @param _.pluck style callback
 		**/
 		find<W, T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		find<W, T>(
+			collection: List<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		find<W, T>(
+			collection: Dictionary<T>,
 			whereValue: W): T;
 
 		/**
@@ -1486,56 +2466,168 @@ declare module _ {
 		* @param _.where style callback
 		**/
 		find<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
 			pluckValue: string): T;
 
-			/**
-			* @see _.find
-			**/
-			detect<T>(
-				collection: Collection<T>,
-				callback: ListIterator<T, boolean>,
-				thisArg?: any): T;
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		find<T>(
+			collection: List<T>,
+			pluckValue: string): T;
 
-			/**
-			* @see _.find
-			* @param _.pluck style callback
-			**/
-			detect<W, T>(
-				collection: Collection<T>,
-				whereValue: W): T;
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		find<T>(
+			collection: Dictionary<T>,
+			pluckValue: string): T;
 
-			/**
-			* @see _.find
-			* @param _.where style callback
-			**/
-			detect<T>(
-				collection: Collection<T>,
-				pluckValue: string): T;
+		/**
+		* @see _.find
+		**/
+		detect<T>(
+			collection: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
 
-			/**
-			* @see _.find
-			**/
-			findWhere<T>(
-				collection: Collection<T>,
-				callback: ListIterator<T, boolean>,
-				thisArg?: any): T;
+		/**
+		* @see _.find
+		**/
+		detect<T>(
+			collection: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
 
-			/**
-			* @see _.find
-			* @param _.pluck style callback
-			**/
-			findWhere<W, T>(
-				collection: Collection<T>,
-				whereValue: W): T;
+		/**
+		* @see _.find
+		**/
+		detect<T>(
+			collection: Dictionary<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
 
-			/**
-			* @see _.find
-			* @param _.where style callback
-			**/
-			findWhere<T>(
-				collection: Collection<T>,
-				pluckValue: string): T;
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		detect<W, T>(
+			collection: Array<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		detect<W, T>(
+			collection: List<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		detect<W, T>(
+			collection: Dictionary<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		detect<T>(
+			collection: Array<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		detect<T>(
+			collection: List<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		detect<T>(
+			collection: Dictionary<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.find
+		**/
+		findWhere<T>(
+			collection: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.find
+		**/
+		findWhere<T>(
+			collection: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.find
+		**/
+		findWhere<T>(
+			collection: Dictionary<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		findWhere<W, T>(
+			collection: Array<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		findWhere<W, T>(
+			collection: List<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		findWhere<W, T>(
+			collection: Dictionary<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		findWhere<T>(
+			collection: Array<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		findWhere<T>(
+			collection: List<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		findWhere<T>(
+			collection: Dictionary<T>,
+			pluckValue: string): T;
 	}
 
 	//_.findLast
@@ -1549,7 +2641,23 @@ declare module _ {
 		* @return The found element, else undefined.
 		**/
 		findLast<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.find
+		**/
+		findLast<T>(
+			collection: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.find
+		**/
+		findLast<T>(
+			collection: Dictionary<T>,
 			callback: ListIterator<T, boolean>,
 			thisArg?: any): T;
 
@@ -1558,7 +2666,23 @@ declare module _ {
 		* @param _.pluck style callback
 		**/
 		findLast<W, T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		findLast<W, T>(
+			collection: List<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		findLast<W, T>(
+			collection: Dictionary<T>,
 			whereValue: W): T;
 
 		/**
@@ -1566,7 +2690,23 @@ declare module _ {
 		* @param _.where style callback
 		**/
 		findLast<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		findLast<T>(
+			collection: List<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		findLast<T>(
+			collection: Dictionary<T>,
 			pluckValue: string): T;
 	}
 
@@ -1580,9 +2720,17 @@ declare module _ {
 		* @param callback The function called per iteration.
 		* @param thisArg The this binding of callback.
 		**/
+		forEach<T>(
+			collection: Array<T>,
+			callback: ListIterator<T, void>,
+			thisArg?: any): Array<T>;
+
+		/**
+		* @see _.forEach
+		**/
 		forEach<T>(
 			collection: List<T>,
-			callback: ListIterator<T, void >,
+			callback: ListIterator<T, void>,
 			thisArg?: any): List<T>;
 
 		/**
@@ -1590,43 +2738,51 @@ declare module _ {
 		**/
 		forEach<T extends {}>(
 			object: Dictionary<T>,
-			callback: ObjectIterator<T, void >,
+			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
+		**/
+		each<T>(
+			collection: Array<T>,
+			callback: ListIterator<T, void>,
+			thisArg?: any): Array<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>;			
+		/**
+		* @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 >,
+		forEach(
+			callback: ListIterator<T, void>,
 			thisArg?: any): LoDashArrayWrapper<T>;
 
-			/**
-			* @see _.forEach
-			**/
-			each<T>(
-				callback: ListIterator<T, void >,
-				thisArg?: any): LoDashArrayWrapper<T>;
+		/**
+		* @see _.forEach
+		**/
+		each(
+			callback: ListIterator<T, void>,
+			thisArg?: any): LoDashArrayWrapper<T>;
 	}
 
 	interface LoDashObjectWrapper<T> {
@@ -1634,15 +2790,15 @@ declare module _ {
 		* @see _.forEach
 		**/
 		forEach<T extends {}>(
-			callback: ObjectIterator<T, void >,
+			callback: ObjectIterator<T, void>,
 			thisArg?: any): LoDashObjectWrapper<T>;
 
-			/**
-			* @see _.forEach
-			**/
-			each<T extends {}>(
-				callback: ObjectIterator<T, void >,	
-				thisArg?: any): LoDashObjectWrapper<T>;
+		/**
+		* @see _.forEach
+		**/
+		each<T extends {}>(
+			callback: ObjectIterator<T, void>,
+			thisArg?: any): LoDashObjectWrapper<T>;
 	}
 
 	//_.forEachRight
@@ -1654,9 +2810,17 @@ declare module _ {
 		* @param callback The function called per iteration.
 		* @param thisArg The this binding of callback.
 		**/
+		forEachRight<T>(
+			collection: Array<T>,
+			callback: ListIterator<T, void>,
+			thisArg?: any): Array<T>;
+
+		/**
+		* @see _.forEachRight
+		**/
 		forEachRight<T>(
 			collection: List<T>,
-			callback: ListIterator<T, void >,
+			callback: ListIterator<T, void>,
 			thisArg?: any): List<T>;
 
 		/**
@@ -1664,43 +2828,51 @@ declare module _ {
 		**/
 		forEachRight<T extends {}>(
 			object: Dictionary<T>,
-			callback: ObjectIterator<T, void >,
+			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
+		**/
+		eachRight<T>(
+			collection: Array<T>,
+			callback: ListIterator<T, void>,
+			thisArg?: any): Array<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>;
+		/**
+		* @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 >,
+		forEachRight(
+			callback: ListIterator<T, void>,
 			thisArg?: any): LoDashArrayWrapper<T>;
 
-			/**
-			* @see _.forEachRight
-			**/
-			eachRight<T>(
-				callback: ListIterator<T, void >,
-				thisArg?: any): LoDashArrayWrapper<T>;
+		/**
+		* @see _.forEachRight
+		**/
+		eachRight(
+			callback: ListIterator<T, void>,
+			thisArg?: any): LoDashArrayWrapper<T>;
 	}
 
 	interface LoDashObjectWrapper<T> {
@@ -1708,18 +2880,18 @@ declare module _ {
 		* @see _.forEachRight
 		**/
 		forEachRight<T extends {}>(
-			callback: ObjectIterator<T, void >,
+			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>>;
+		/**
+		* @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
@@ -1739,11 +2911,27 @@ declare module _ {
 		* @param thisArg The this binding of callback.
 		* @return Returns the composed aggregate object.
 		**/
+		groupBy<T>(
+			collection: Array<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): Dictionary<T[]>;
+
+		/**
+		* @see _.groupBy
+		**/
 		groupBy<T>(
 			collection: List<T>,
 			callback?: ListIterator<T, any>,
 			thisArg?: any): Dictionary<T[]>;
 
+		/**
+		* @see _.groupBy
+		* @param pluckValue _.pluck style callback
+		**/
+		groupBy<T>(
+			collection: Array<T>,
+			pluckValue: string): Dictionary<T[]>;
+
 		/**
 		* @see _.groupBy
 		* @param pluckValue _.pluck style callback
@@ -1752,6 +2940,14 @@ declare module _ {
 			collection: List<T>,
 			pluckValue: string): Dictionary<T[]>;
 
+		/**
+		* @see _.groupBy
+		* @param whereValue _.where style callback
+		**/
+		groupBy<W, T>(
+			collection: Array<T>,
+			whereValue: W): Dictionary<T[]>;
+
 		/**
 		* @see _.groupBy
 		* @param whereValue _.where style callback
@@ -1761,24 +2957,24 @@ declare module _ {
 			whereValue: W): Dictionary<T[]>;
 	}
 
-    interface LoDashArrayWrapper<T> {
+	interface LoDashArrayWrapper<T> {
 		/**
 		* @see _.groupBy
 		**/
-		groupBy<T>(
+		groupBy(
 			callback: ListIterator<T, any>,
 			thisArg?: any): _.LoDashObjectWrapper<Dictionary<T[]>>;
 
 		/**
 		* @see _.groupBy
 		**/
-		groupBy<T>(
+		groupBy(
 			pluckValue: string): _.LoDashObjectWrapper<Dictionary<T[]>>;
 
 		/**
 		* @see _.groupBy
 		**/
-		groupBy<W, T>(
+		groupBy<W>(
 			whereValue: W): _.LoDashObjectWrapper<Dictionary<T[]>>;
 	}
 
@@ -1800,11 +2996,27 @@ declare module _ {
 		* @param thisArg The this binding of callback.
 		* @return Returns the composed aggregate object.
 		**/
+		indexBy<T>(
+			list: Array<T>,
+			iterator: ListIterator<T, any>,
+			context?: any): Dictionary<T>;
+
+		/**
+		* @see _.indexBy
+		**/
 		indexBy<T>(
 			list: List<T>,
 			iterator: ListIterator<T, any>,
 			context?: any): Dictionary<T>;
 
+		/**
+		* @see _.indexBy
+		* @param pluckValue _.pluck style callback
+		**/
+		indexBy<T>(
+			collection: Array<T>,
+			pluckValue: string): Dictionary<T>;
+
 		/**
 		* @see _.indexBy
 		* @param pluckValue _.pluck style callback
@@ -1813,6 +3025,14 @@ declare module _ {
 			collection: List<T>,
 			pluckValue: string): Dictionary<T>;
 
+		/**
+		* @see _.indexBy
+		* @param whereValue _.where style callback
+		**/
+		indexBy<W, T>(
+			collection: Array<T>,
+			whereValue: W): Dictionary<T>;
+
 		/**
 		* @see _.indexBy
 		* @param whereValue _.where style callback
@@ -1834,7 +3054,7 @@ declare module _ {
 		* @param args Arguments to invoke the method with.
 		**/
 		invoke<T extends {}>(
-			collection: Collection<T>,
+			collection: Array<T>,
 			methodName: string,
 			...args: any[]): any;
 
@@ -1842,7 +3062,39 @@ declare module _ {
 		* @see _.invoke
 		**/
 		invoke<T extends {}>(
-			collection: Collection<T>,
+			collection: List<T>,
+			methodName: string,
+			...args: any[]): any;
+
+		/**
+		* @see _.invoke
+		**/
+		invoke<T extends {}>(
+			collection: Dictionary<T>,
+			methodName: string,
+			...args: any[]): any;
+
+		/**
+		* @see _.invoke
+		**/
+		invoke<T extends {}>(
+			collection: Array<T>,
+			method: Function,
+			...args: any[]): any;
+
+		/**
+		* @see _.invoke
+		**/
+		invoke<T extends {}>(
+			collection: List<T>,
+			method: Function,
+			...args: any[]): any;
+
+		/**
+		* @see _.invoke
+		**/
+		invoke<T extends {}>(
+			collection: Dictionary<T>,
 			method: Function,
 			...args: any[]): any;
 	}
@@ -1864,6 +3116,14 @@ declare module _ {
 		* @param theArg The this binding of callback.
 		* @return The mapped array result.
 		**/
+		map<T, TResult>(
+			collection: Array<T>,
+			callback: ListIterator<T, TResult>,
+			thisArg?: any): TResult[];
+
+		/**
+		* @see _.map
+		**/
 		map<T, TResult>(
 			collection: List<T>,
 			callback: ListIterator<T, TResult>,
@@ -1881,6 +3141,14 @@ declare module _ {
 			callback: ObjectIterator<T, TResult>,
 			thisArg?: any): TResult[];
 
+		/**
+		* @see _.map
+		* @param pluckValue _.pluck style callback
+		**/
+		map<T, TResult>(
+			collection: Array<T>,
+			pluckValue: string): TResult[];
+
 		/**
 		* @see _.map
 		* @param pluckValue _.pluck style callback
@@ -1889,35 +3157,50 @@ declare module _ {
 			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, TResult>(
+			collection: Array<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>,
+			callback: ListIterator<T, TResult>,
+			thisArg?: any): TResult[];
 
-			/**
-			* @see _.map
-			**/
-			collect<T, TResult>(
-				collection: List<T>,
-				pluckValue: string): TResult[];
+		/**
+		* @see _.map
+		**/
+		collect<T extends {}, TResult>(
+			object: Dictionary<T>,
+			callback: ObjectIterator<T, TResult>,
+			thisArg?: any): TResult[];
+
+		/**
+		* @see _.map
+		**/
+		collect<T, TResult>(
+			collection: Array<T>,
+			pluckValue: string): TResult[];
+
+		/**
+		* @see _.map
+		**/
+		collect<T, TResult>(
+			collection: List<T>,
+			pluckValue: string): TResult[];
 	}
 
 	interface LoDashArrayWrapper<T> {
 		/**
 		* @see _.map
 		**/
-		map<T, TResult>(
+		map<TResult>(
 			callback: ListIterator<T, TResult>,
 			thisArg?: any): LoDashArrayWrapper<TResult>;
 
@@ -1925,21 +3208,21 @@ declare module _ {
 		* @see _.map
 		* @param pluckValue _.pluck style callback
 		**/
-		map<T, TResult>(
+		map<TResult>(
 			pluckValue: string): LoDashArrayWrapper<TResult>;
 
-			/**
-			* @see _.map
-			**/
-			collect<T, TResult>(
-				callback: ListIterator<T, TResult>,
-				thisArg?: any): LoDashArrayWrapper<TResult>;
+		/**
+		* @see _.map
+		**/
+		collect<TResult>(
+			callback: ListIterator<T, TResult>,
+			thisArg?: any): LoDashArrayWrapper<TResult>;
 
-			/**
-			* @see _.map
-			**/
-			collect<T, TResult>(
-				pluckValue: string): LoDashArrayWrapper<TResult>;
+		/**
+		* @see _.map
+		**/
+		collect<TResult>(
+			pluckValue: string): LoDashArrayWrapper<TResult>;
 	}
 
 	interface LoDashObjectWrapper<T> {
@@ -1948,14 +3231,14 @@ declare module _ {
 		**/
 		map<T extends {}, TResult>(
 			callback: ObjectIterator<T, TResult>,
-			thisArg?: any): LoDashObjectWrapper<TResult>;
+			thisArg?: any): LoDashArrayWrapper<TResult>;
 
-			/**
-			* @see _.map
-			**/
-			collect<T extends {}, TResult>(
-				callback: ObjectIterator<T, TResult>,
-				thisArg?: any): LoDashObjectWrapper<TResult>;
+		/**
+		* @see _.map
+		**/
+		collect<T extends {}, TResult>(
+			callback: ObjectIterator<T, TResult>,
+			thisArg?: any): LoDashArrayWrapper<TResult>;
 	}
 
 	//_.max
@@ -1977,7 +3260,23 @@ declare module _ {
 		* @return Returns the maximum value.
 		**/
 		max<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.max
+		**/
+		max<T>(
+			collection: List<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.max
+		**/
+		max<T>(
+			collection: Dictionary<T>,
 			callback?: ListIterator<T, any>,
 			thisArg?: any): T;
 
@@ -1986,7 +3285,23 @@ declare module _ {
 		* @param pluckValue _.pluck style callback
 		**/
 		max<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.max
+		* @param pluckValue _.pluck style callback
+		**/
+		max<T>(
+			collection: List<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.max
+		* @param pluckValue _.pluck style callback
+		**/
+		max<T>(
+			collection: Dictionary<T>,
 			pluckValue: string): T;
 
 		/**
@@ -1994,7 +3309,23 @@ declare module _ {
 		* @param whereValue _.where style callback
 		**/
 		max<W, T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.max
+		* @param whereValue _.where style callback
+		**/
+		max<W, T>(
+			collection: List<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.max
+		* @param whereValue _.where style callback
+		**/
+		max<W, T>(
+			collection: Dictionary<T>,
 			whereValue: W): T;
 	}
 
@@ -2017,7 +3348,23 @@ declare module _ {
 		* @return Returns the maximum value.
 		**/
 		min<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.min
+		**/
+		min<T>(
+			collection: List<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.min
+		**/
+		min<T>(
+			collection: Dictionary<T>,
 			callback?: ListIterator<T, any>,
 			thisArg?: any): T;
 
@@ -2026,7 +3373,23 @@ declare module _ {
 		* @param pluckValue _.pluck style callback
 		**/
 		min<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.min
+		* @param pluckValue _.pluck style callback
+		**/
+		min<T>(
+			collection: List<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.min
+		* @param pluckValue _.pluck style callback
+		**/
+		min<T>(
+			collection: Dictionary<T>,
 			pluckValue: string): T;
 
 		/**
@@ -2034,7 +3397,23 @@ declare module _ {
 		* @param whereValue _.where style callback
 		**/
 		min<W, T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.min
+		* @param whereValue _.where style callback
+		**/
+		min<W, T>(
+			collection: List<T>,
+			whereValue: W): T;
+
+		/**
+		* @see _.min
+		* @param whereValue _.where style callback
+		**/
+		min<W, T>(
+			collection: Dictionary<T>,
 			whereValue: W): T;
 	}
 
@@ -2047,7 +3426,21 @@ declare module _ {
 		* @return A new array of property values.
 		**/
 		pluck<T extends {}>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			property: string): any[];
+
+		/**
+		* @see _.pluck
+		**/
+		pluck<T extends {}>(
+			collection: List<T>,
+			property: string): any[];
+
+		/**
+		* @see _.pluck
+		**/
+		pluck<T extends {}>(
+			collection: Dictionary<T>,
 			property: string): any[];
 	}
 
@@ -2066,52 +3459,154 @@ declare module _ {
 		* @return Returns the accumulated value.
 		**/
 		reduce<T, TResult>(
-			collection: Collection<T>,
+			collection: Array<T>,
 			callback: MemoIterator<T, TResult>,
 			accumulator: TResult,
 			thisArg?: any): TResult;
 
-        /**
-        * @see _.reduce
-        **/
+		/**
+		* @see _.reduce
+		**/
 		reduce<T, TResult>(
-			collection: Collection<T>,
+			collection: List<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator: TResult,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduce
+		**/
+		reduce<T, TResult>(
+			collection: Dictionary<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator: TResult,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduce
+		**/
+		reduce<T, TResult>(
+			collection: Array<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
+		**/
+		reduce<T, TResult>(
+			collection: List<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
 
-			/**
-			* @see _.reduce
-			**/
-			inject<T, TResult>(
-				collection: Collection<T>,
-				callback: MemoIterator<T, TResult>,
-				thisArg?: any): TResult;
+		/**
+		* @see _.reduce
+		**/
+		reduce<T, TResult>(
+			collection: Dictionary<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
+		**/
+		inject<T, TResult>(
+			collection: Array<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;
+		/**
+		* @see _.reduce
+		**/
+		inject<T, TResult>(
+			collection: List<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator: TResult,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduce
+		**/
+		inject<T, TResult>(
+			collection: Dictionary<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator: TResult,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduce
+		**/
+		inject<T, TResult>(
+			collection: Array<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduce
+		**/
+		inject<T, TResult>(
+			collection: List<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduce
+		**/
+		inject<T, TResult>(
+			collection: Dictionary<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduce
+		**/
+		foldl<T, TResult>(
+			collection: Array<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator: TResult,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduce
+		**/
+		foldl<T, TResult>(
+			collection: List<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator: TResult,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduce
+		**/
+		foldl<T, TResult>(
+			collection: Dictionary<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator: TResult,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduce
+		**/
+		foldl<T, TResult>(
+			collection: Array<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduce
+		**/
+		foldl<T, TResult>(
+			collection: List<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduce
+		**/
+		foldl<T, TResult>(
+			collection: Dictionary<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
 	}
 
 	//_.reduceRight
@@ -2126,35 +3621,103 @@ declare module _ {
 		* @return The accumulated value.
 		**/
 		reduceRight<T, TResult>(
-			collection: Collection<T>,
+			collection: Array<T>,
 			callback: MemoIterator<T, TResult>,
 			accumulator: TResult,
 			thisArg?: any): TResult;
 
-        /**
-        * @see _.reduceRight
-        **/
+		/**
+		* @see _.reduceRight
+		**/
 		reduceRight<T, TResult>(
-			collection: Collection<T>,
+			collection: List<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator: TResult,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduceRight
+		**/
+		reduceRight<T, TResult>(
+			collection: Dictionary<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator: TResult,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduceRight
+		**/
+		reduceRight<T, TResult>(
+			collection: Array<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
+		**/
+		reduceRight<T, TResult>(
+			collection: List<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
 
-			/**
-			* @see _.reduceRight
-			**/
-			foldr<T, TResult>(
-				collection: Collection<T>,
-				callback: MemoIterator<T, TResult>,
-				thisArg?: any): TResult;
+		/**
+		* @see _.reduceRight
+		**/
+		reduceRight<T, TResult>(
+			collection: Dictionary<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduceRight
+		**/
+		foldr<T, TResult>(
+			collection: Array<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator: TResult,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduceRight
+		**/
+		foldr<T, TResult>(
+			collection: List<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator: TResult,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduceRight
+		**/
+		foldr<T, TResult>(
+			collection: Dictionary<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator: TResult,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduceRight
+		**/
+		foldr<T, TResult>(
+			collection: Array<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduceRight
+		**/
+		foldr<T, TResult>(
+			collection: List<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.reduceRight
+		**/
+		foldr<T, TResult>(
+			collection: Dictionary<T>,
+			callback: MemoIterator<T, TResult>,
+			thisArg?: any): TResult;
 	}
 
 	//_.reject
@@ -2174,7 +3737,23 @@ declare module _ {
 		* @return A new array of elements that failed the callback check.
 		**/
 		reject<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.reject
+		**/
+		reject<T>(
+			collection: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.reject
+		**/
+		reject<T>(
+			collection: Dictionary<T>,
 			callback: ListIterator<T, boolean>,
 			thisArg?: any): T[];
 
@@ -2183,7 +3762,23 @@ declare module _ {
 		* @param pluckValue _.pluck style callback
 		**/
 		reject<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.reject
+		* @param pluckValue _.pluck style callback
+		**/
+		reject<T>(
+			collection: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.reject
+		* @param pluckValue _.pluck style callback
+		**/
+		reject<T>(
+			collection: Dictionary<T>,
 			pluckValue: string): T[];
 
 		/**
@@ -2191,7 +3786,23 @@ declare module _ {
 		* @param whereValue _.where style callback
 		**/
 		reject<W, T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.reject
+		* @param whereValue _.where style callback
+		**/
+		reject<W, T>(
+			collection: List<T>,
+			whereValue: W): T[];
+
+		/**
+		* @see _.reject
+		* @param whereValue _.where style callback
+		**/
+		reject<W, T>(
+			collection: Dictionary<T>,
 			whereValue: W): T[];
 	}
 
@@ -2202,13 +3813,35 @@ declare module _ {
 		* @param collection The collection to sample.
 		* @return Returns the random sample(s) of collection.
 		**/
-		sample<T>(collection: Collection<T>): T;
+		sample<T>(collection: Array<T>): T;
+
+		/**
+		* @see _.sample
+		**/
+		sample<T>(collection: List<T>): T;
+
+		/**
+		* @see _.sample
+		**/
+		sample<T>(collection: Dictionary<T>): T;
 
 		/**
 		* @see _.sample
 		* @param n The number of elements to sample.
 		**/
-		sample<T>(collection: Collection<T>, n: number): T[];
+		sample<T>(collection: Array<T>, n: number): T[];
+
+		/**
+		* @see _.sample
+		* @param n The number of elements to sample.
+		**/
+		sample<T>(collection: List<T>, n: number): T[];
+
+		/**
+		* @see _.sample
+		* @param n The number of elements to sample.
+		**/
+		sample<T>(collection: Dictionary<T>, n: number): T[];
 	}
 
 	//_.shuffle
@@ -2219,7 +3852,17 @@ declare module _ {
 		* @param collection The collection to shuffle.
 		* @return Returns a new shuffled collection.
 		**/
-		shuffle<T>(collection: Collection<T>): T[];
+		shuffle<T>(collection: Array<T>): T[];
+
+		/**
+		* @see _.shuffle
+		**/
+		shuffle<T>(collection: List<T>): T[];
+
+		/**
+		* @see _.shuffle
+		**/
+		shuffle<T>(collection: Dictionary<T>): T[];
 	}
 
 	//_.size
@@ -2230,6 +3873,11 @@ declare module _ {
 		* @param collection The collection to inspect.
 		* @return collection.length
 		**/
+		size<T>(collection: Array<T>): number;
+
+		/**
+		* @see _.size
+		**/
 		size<T>(collection: List<T>): number;
 
 		/**
@@ -2265,7 +3913,23 @@ declare module _ {
 		* @return True if any element passed the callback check, else false.
 		**/
 		some<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.some
+		**/
+		some<T>(
+			collection: List<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.some
+		**/
+		some<T>(
+			collection: Dictionary<T>,
 			callback?: ListIterator<T, boolean>,
 			thisArg?: any): boolean;
 
@@ -2274,7 +3938,23 @@ declare module _ {
 		* @param pluckValue _.pluck style callback
 		**/
 		some<T>(
-			collection: Collection<T>,
+			collection: Array<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.some
+		* @param pluckValue _.pluck style callback
+		**/
+		some<T>(
+			collection: List<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.some
+		* @param pluckValue _.pluck style callback
+		**/
+		some<T>(
+			collection: Dictionary<T>,
 			pluckValue: string): boolean;
 
 		/**
@@ -2282,32 +3962,96 @@ declare module _ {
 		* @param whereValue _.where style callback
 		**/
 		some<W, T>(
-			collection: Collection<T>,
+			collection: Array<T>,
 			whereValue: W): boolean;
 
-			/**
-			* @see _.some
-			**/
-			any<T>(
-				collection: Collection<T>,
-				callback?: ListIterator<T, boolean>,
-				thisArg?: any): boolean;
+		/**
+		* @see _.some
+		* @param whereValue _.where style callback
+		**/
+		some<W, T>(
+			collection: List<T>,
+			whereValue: W): boolean;
 
-			/**
-			* @see _.some
-			* @param pluckValue _.pluck style callback
-			**/
-			any<T>(
-				collection: Collection<T>,
-				pluckValue: string): boolean;
+		/**
+		* @see _.some
+		* @param whereValue _.where style callback
+		**/
+		some<W, T>(
+			collection: Dictionary<T>,
+			whereValue: W): boolean;
 
-			/**
-			* @see _.some
-			* @param whereValue _.where style callback
-			**/
-			any<W, T>(
-				collection: Collection<T>,
-				whereValue: W): boolean;
+		/**
+		* @see _.some
+		**/
+		any<T>(
+			collection: Array<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.some
+		**/
+		any<T>(
+			collection: List<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.some
+		**/
+		any<T>(
+			collection: Dictionary<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.some
+		* @param pluckValue _.pluck style callback
+		**/
+		any<T>(
+			collection: Array<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.some
+		* @param pluckValue _.pluck style callback
+		**/
+		any<T>(
+			collection: List<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.some
+		* @param pluckValue _.pluck style callback
+		**/
+		any<T>(
+			collection: Dictionary<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.some
+		* @param whereValue _.where style callback
+		**/
+		any<W, T>(
+			collection: Array<T>,
+			whereValue: W): boolean;
+
+		/**
+		* @see _.some
+		* @param whereValue _.where style callback
+		**/
+		any<W, T>(
+			collection: List<T>,
+			whereValue: W): boolean;
+
+		/**
+		* @see _.some
+		* @param whereValue _.where style callback
+		**/
+		any<W, T>(
+			collection: Dictionary<T>,
+			whereValue: W): boolean;
 	}
 
 	//_.sortBy
@@ -2328,11 +4072,27 @@ declare module _ {
 		* @param thisArg The this binding of callback.
 		* @return A new array of sorted elements.
 		**/
+		sortBy<T, TSort>(
+			collection: Array<T>,
+			callback?: ListIterator<T, TSort>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.sortBy
+		**/
 		sortBy<T, TSort>(
 			collection: List<T>,
 			callback?: ListIterator<T, TSort>,
 			thisArg?: any): T[];
 
+		/**
+		* @see _.sortBy
+		* @param pluckValue _.pluck style callback
+		**/
+		sortBy<T>(
+			collection: Array<T>,
+			pluckValue: string): T[];
+
 		/**
 		* @see _.sortBy
 		* @param pluckValue _.pluck style callback
@@ -2341,6 +4101,14 @@ declare module _ {
 			collection: List<T>,
 			pluckValue: string): T[];
 
+		/**
+		* @see _.sortBy
+		* @param whereValue _.where style callback
+		**/
+		sortBy<W, T>(
+			collection: Array<T>,
+			whereValue: W): T[];
+
 		/**
 		* @see _.sortBy
 		* @param whereValue _.where style callback
@@ -2357,7 +4125,17 @@ declare module _ {
 		* @param collection The collection to convert.
 		* @return The new converted array.
 		**/
-		toArray<T>(collection: Collection<T>): T[];
+		toArray<T>(collection: Array<T>): T[];
+
+		/**
+		* @see _.toArray
+		**/
+		toArray<T>(collection: List<T>): T[];
+
+		/**
+		* @see _.toArray
+		**/
+		toArray<T>(collection: Dictionary<T>): T[];
 	}
 
 	//_.where
@@ -2370,7 +4148,21 @@ declare module _ {
 		* @return A new array of elements that have the given properties.
 		**/
 		where<T, U extends {}>(
-			list: Collection<T>,
+			list: Array<T>,
+			properties: U): T[];
+
+		/**
+		* @see _.where
+		**/
+		where<T, U extends {}>(
+			list: List<T>,
+			properties: U): T[];
+
+		/**
+		* @see _.where
+		**/
+		where<T, U extends {}>(
+			list: Dictionary<T>,
 			properties: U): T[];
 	}
 
@@ -2389,7 +4181,7 @@ declare module _ {
 		**/
 		after(
 			n: number,
-			func: Function): Function;			
+			func: Function): Function;
 	}
 
 	interface LoDashWrapper<T> {
@@ -2412,7 +4204,7 @@ declare module _ {
 		bind(
 			func: Function,
 			thisArg: any,
-			...args: any[]): () => any;			
+			...args: any[]): () => any;
 	}
 
 	interface LoDashObjectWrapper<T> {
@@ -2437,14 +4229,14 @@ declare module _ {
 		**/
 		bindAll<T>(
 			object: T,
-			...methodNames: string[]): T;			
+			...methodNames: string[]): T;
 	}
 
 	interface LoDashObjectWrapper<T> {
 		/**
 		* @see _.bindAll
 		**/
-		bindAll<T>(...methodNames: string[]): LoDashWrapper<T>;
+		bindAll(...methodNames: string[]): LoDashWrapper<T>;
 	}
 
 	//_.bindKey
@@ -2462,7 +4254,7 @@ declare module _ {
 		bindKey<T>(
 			object: T,
 			key: string,
-			...args: any[]): Function;			
+			...args: any[]): Function;
 	}
 
 	interface LoDashObjectWrapper<T> {
@@ -2484,7 +4276,7 @@ declare module _ {
 		* @param funcs Functions to compose.
 		* @return The new composed function.
 		**/
-		compose(...funcs: Function[]): Function;	
+		compose(...funcs: Function[]): Function;
 	}
 
 	interface LoDashObjectWrapper<T> {
@@ -2517,7 +4309,7 @@ declare module _ {
 		createCallback(
 			func: Dictionary<any>,
 			thisArg?: any,
-			argCount?: number): () => boolean;			
+			argCount?: number): () => boolean;
 	}
 
 	interface LoDashWrapper<T> {
@@ -2551,7 +4343,7 @@ declare module _ {
 		**/
 		curry(
 			func: Function,
-			arity?: number): Function;	
+			arity?: number): Function;
 	}
 
 	interface LoDashObjectWrapper<T> {
@@ -2583,7 +4375,7 @@ declare module _ {
 		debounce<T extends Function>(
 			func: T,
 			wait: number,
-			options?: DebounceSettings): T;			
+			options?: DebounceSettings): T;
 	}
 
 	interface LoDashObjectWrapper<T> {
@@ -2600,7 +4392,7 @@ declare module _ {
 		* Specify execution on the leading edge of the timeout.
 		**/
 		leading?: boolean;
-		
+
 		/**
 		* The maximum time func is allowed to be delayed before it’s called.
 		**/
@@ -2623,7 +4415,7 @@ declare module _ {
 		**/
 		defer(
 			func: Function,
-			...args: any[]): number;			
+			...args: any[]): number;
 	}
 
 	interface LoDashObjectWrapper<T> {
@@ -2646,7 +4438,7 @@ declare module _ {
 		delay(
 			func: Function,
 			wait: number,
-			...args: any[]): number;			
+			...args: any[]): number;
 	}
 
 	interface LoDashObjectWrapper<T> {
@@ -2670,7 +4462,7 @@ declare module _ {
 		* @param resolver Hash function for storing the result of `fn`.
 		* @return Returns the new memoizing function.
 		**/
-        memoize<T extends Function>(
+		memoize<T extends Function>(
 			func: T,
 			resolver?: Function): T;
 	}
@@ -2684,7 +4476,7 @@ declare module _ {
 		* @param func Function to only execute once.
 		* @return The new restricted function.
 		**/
-        once<T extends Function>(func: T): T;
+		once<T extends Function>(func: T): T;
 	}
 
 	//_.partial
@@ -2733,7 +4525,7 @@ declare module _ {
 		* @param options.trailing Specify execution on the trailing edge of the timeout.
 		* @return The new throttled function.
 		**/
-        throttle<T extends Function>(
+		throttle<T extends Function>(
 			func: T,
 			wait: number,
 			options?: ThrottleSettings): T;
@@ -2784,86 +4576,86 @@ declare module _ {
 		* @param thisArg The this binding of callback.
 		* @return The destination object.
 		**/
-        assign<P, T, S1, Value, Result>(
-            object: T,
-            s1: S1,
+		assign<P, T, S1, Value, Result>(
+			object: T,
+			s1: S1,
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
-            thisArg?: any): Result;
+			thisArg?: any): Result;
 
 		/**
 		* @see _.assign
 		**/
-        assign<P, T, S1, S2, Value, Result>(
-            object: T,
-            s1: S1,
-            s2: S2,
+		assign<P, T, S1, S2, Value, Result>(
+			object: T,
+			s1: S1,
+			s2: S2,
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
-            thisArg?: any): Result;
+			thisArg?: any): Result;
 
 		/**
 		* @see _.assign
 		**/
-        assign<P, T, S1, S2, S3, Value, Result>(
-            object: T,
-            s1: S1,
-            s2: S2,
-            s3: S3,
+		assign<P, T, S1, S2, S3, Value, Result>(
+			object: T,
+			s1: S1,
+			s2: S2,
+			s3: S3,
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
-            thisArg?: any): Result;
+			thisArg?: any): Result;
 
 		/**
 		* @see _.assign
 		**/
-        assign<P, T, S1, S2, S3, S4, Value, Result>(
-            object: T,
-            s1: S1,
-            s2: S2,
-            s3: S3,
-            s4: S4,
+		assign<P, T, S1, S2, S3, S4, Value, Result>(
+			object: T,
+			s1: S1,
+			s2: S2,
+			s3: S3,
+			s4: S4,
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
-            thisArg?: any): Result;
+			thisArg?: any): Result;
 
 		/**
 		* @see _.assign
 		**/
-	extend<P, T, S1, Value, Result>(
-            object: T,
-            s1: S1,
+		extend<P, T, S1, Value, Result>(
+			object: T,
+			s1: S1,
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
-            thisArg?: any): Result;
+			thisArg?: any): Result;
 
 		/**
 		* @see _.assign
 		**/
-        extend<P, T, S1, S2, Value, Result>(
-            object: T,
-            s1: S1,
-            s2: S2,
+		extend<P, T, S1, S2, Value, Result>(
+			object: T,
+			s1: S1,
+			s2: S2,
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
-            thisArg?: any): Result;
+			thisArg?: any): Result;
 
 		/**
 		* @see _.assign
 		**/
-        extend<P, T, S1, S2, S3, Value, Result>(
-            object: T,
-            s1: S1,
-            s2: S2,
-            s3: S3,
+		extend<P, T, S1, S2, S3, Value, Result>(
+			object: T,
+			s1: S1,
+			s2: S2,
+			s3: S3,
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
-            thisArg?: any): Result;
+			thisArg?: any): Result;
 
 		/**
 		* @see _.assign
 		**/
-        extend<P, T, S1, S2, S3, S4, Value, Result>(
-            object: T,
-            s1: S1,
-            s2: S2,
-            s3: S3,
-            s4: S4,
+		extend<P, T, S1, S2, S3, S4, Value, Result>(
+			object: T,
+			s1: S1,
+			s2: S2,
+			s3: S3,
+			s4: S4,
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
-            thisArg?: any): Result;
+			thisArg?: any): Result;
 	}
 
 	interface LoDashObjectWrapper<T> {
@@ -2914,52 +4706,52 @@ declare module _ {
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
 			thisArg?: any): TResult;
 
-          /**
-          * @see _.assign
-          **/
-          extend<S1, Value, TResult>(
-              s1: S1,
-              callback?: (objectValue: Value, sourceValue: Value) => Value,
-              thisArg?: any): TResult;
+		/**
+		* @see _.assign
+		**/
+		extend<S1, Value, TResult>(
+			s1: S1,
+			callback?: (objectValue: Value, sourceValue: Value) => Value,
+			thisArg?: any): TResult;
 
-          /**
-          * @see _.assign
-          **/
-          extend<S1, S2, Value, TResult>(
-              s1: S1,
-              s2: S2,
-              callback?: (objectValue: Value, sourceValue: Value) => Value,
-              thisArg?: any): TResult;
-          /**
-          * @see _.assign
-          **/
-          extend<S1, S2, S3, Value, TResult>(
-              s1: S1,
-              s2: S2,
-              s3: S3,
-              callback?: (objectValue: Value, sourceValue: Value) => Value,
-              thisArg?: any): TResult;
-          /**
-          * @see _.assign
-          **/
-          extend<S1, S2, S3, S4, Value, TResult>(
-              s1: S1,
-              s2: S2,
-              s3: S3,
-              s4: S4,
-              callback?: (objectValue: Value, sourceValue: Value) => Value,
-              thisArg?: any): TResult;
-          /**
-          * @see _.assign
-          **/
-          extend<S1, S2, S3, S4, S5, Value, TResult>(
-              s1: S1,
-              s2: S2,
-              s3: S3,
-              s4: S4,
-              s5: S5,
-              callback?: (objectValue: Value, sourceValue: Value) => Value,
-              thisArg?: any): TResult;
+		/**
+		* @see _.assign
+		**/
+		extend<S1, S2, Value, TResult>(
+			s1: S1,
+			s2: S2,
+			callback?: (objectValue: Value, sourceValue: Value) => Value,
+			thisArg?: any): TResult;
+		/**
+		* @see _.assign
+		**/
+		extend<S1, S2, S3, Value, TResult>(
+			s1: S1,
+			s2: S2,
+			s3: S3,
+			callback?: (objectValue: Value, sourceValue: Value) => Value,
+			thisArg?: any): TResult;
+		/**
+		* @see _.assign
+		**/
+		extend<S1, S2, S3, S4, Value, TResult>(
+			s1: S1,
+			s2: S2,
+			s3: S3,
+			s4: S4,
+			callback?: (objectValue: Value, sourceValue: Value) => Value,
+			thisArg?: any): TResult;
+		/**
+		* @see _.assign
+		**/
+		extend<S1, S2, S3, S4, S5, Value, TResult>(
+			s1: S1,
+			s2: S2,
+			s3: S3,
+			s4: S4,
+			s5: S5,
+			callback?: (objectValue: Value, sourceValue: Value) => Value,
+			thisArg?: any): TResult;
 
 	}
 
@@ -3017,7 +4809,7 @@ declare module _ {
 		**/
 		defaults<T, TResult>(
 			object: T,
-			...sources: any[]): TResult;	
+			...sources: any[]): TResult;
 	}
 
 	interface LoDashObjectWrapper<T> {
@@ -3054,7 +4846,7 @@ declare module _ {
 		* @see _.findKey
 		* @param whereValue _.where style callback
 		**/
-        findKey<W extends Dictionary<any>, T>(
+		findKey<W extends Dictionary<any>, T>(
 			object: T,
 			whereValue: W): string;
 	}
@@ -3085,7 +4877,7 @@ declare module _ {
 		* @see _.findLastKey
 		* @param whereValue _.where style callback
 		**/
-        findLastKey<W extends Dictionary<any>, T>(
+		findLastKey<W extends Dictionary<any>, T>(
 			object: T,
 			whereValue: W): string;
 	}
@@ -3105,9 +4897,17 @@ declare module _ {
 			object: Dictionary<T>,
 			callback?: ObjectIterator<T, void>,
 			thisArg?: any): Dictionary<T>;
+
+		/**
+		* @see _.forIn
+		**/
+		forIn<T>(
+			object: T,
+			callback?: ObjectIterator<any, void>,
+			thisArg?: any): T;
 	}
 
-    interface LoDashObjectWrapper<T> {
+	interface LoDashObjectWrapper<T> {
 		/**
 		* @see _.forIn
 		**/
@@ -3130,9 +4930,17 @@ declare module _ {
 			object: Dictionary<T>,
 			callback?: ObjectIterator<T, void>,
 			thisArg?: any): Dictionary<T>;
+
+		/**
+		* @see _.forInRight
+		**/
+		forInRight<T extends {}>(
+			object: T,
+			callback?: ObjectIterator<T, void>,
+			thisArg?: any): T;
 	}
 
-    interface LoDashObjectWrapper<T> {
+	interface LoDashObjectWrapper<T> {
 		/**
 		* @see _.forInRight
 		**/
@@ -3156,9 +4964,17 @@ declare module _ {
 			object: Dictionary<T>,
 			callback?: ObjectIterator<T, void>,
 			thisArg?: any): Dictionary<T>;
+
+		/**
+		* @see _.forOwn
+		**/
+		forOwn<T extends {}>(
+			object: T,
+			callback?: ObjectIterator<any, void>,
+			thisArg?: any): T;
 	}
 
-    interface LoDashObjectWrapper<T> {
+	interface LoDashObjectWrapper<T> {
 		/**
 		* @see _.forOwn
 		**/
@@ -3181,9 +4997,16 @@ declare module _ {
 			object: Dictionary<T>,
 			callback?: ObjectIterator<T, void>,
 			thisArg?: any): Dictionary<T>;
+		/**
+		* @see _.forOwnRight
+		**/
+		forOwnRight<T extends {}>(
+			object: T,
+			callback?: ObjectIterator<any, void>,
+			thisArg?: any): T;
 	}
 
-    interface LoDashObjectWrapper<T> {
+	interface LoDashObjectWrapper<T> {
 		/**
 		* @see _.forOwnRight
 		**/
@@ -3202,22 +5025,22 @@ declare module _ {
 		**/
 		functions(object: any): string[];
 
-			/**
-			* @see _functions
-			**/
-			methods(object: any): string[];
+		/**
+		* @see _functions
+		**/
+		methods(object: any): string[];
 	}
 
-    interface LoDashObjectWrapper<T> {
+	interface LoDashObjectWrapper<T> {
 		/**
 		* @see _.functions
 		**/
 		functions(): _.LoDashArrayWrapper<string>;
 
-			/**
-			* @see _.functions
-			**/
-			methods(): _.LoDashArrayWrapper<string>;
+		/**
+		* @see _.functions
+		**/
+		methods(): _.LoDashArrayWrapper<string>;
 	}
 
 	//_.has
@@ -3311,7 +5134,7 @@ declare module _ {
 		* @see _.isEmpty
 		**/
 		isEmpty(value: string): boolean;
-		
+
 		/**
 		* @see _.isEmpty
 		**/
@@ -3472,44 +5295,44 @@ declare module _ {
 		* @param thisArg The this binding of callback.
 		* @return The destination object.
 		**/
-        merge<P, T, S1, Value, Result>(
-            object: T,
-            s1: S1,
+		merge<P, T, S1, Value, Result>(
+			object: T,
+			s1: S1,
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
-            thisArg?: any): Result;
+			thisArg?: any): Result;
 
 		/**
 		* @see _.merge
 		**/
-        merge<P, T, S1, S2, Value, Result>(
-            object: T,
-            s1: S1,
-            s2: S2,
+		merge<P, T, S1, S2, Value, Result>(
+			object: T,
+			s1: S1,
+			s2: S2,
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
-            thisArg?: any): Result;
+			thisArg?: any): Result;
 
 		/**
 		* @see _.merge
 		**/
-        merge<P, T, S1, S2, S3, Value, Result>(
-            object: T,
-            s1: S1,
-            s2: S2,
-            s3: S3,
+		merge<P, T, S1, S2, S3, Value, Result>(
+			object: T,
+			s1: S1,
+			s2: S2,
+			s3: S3,
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
-            thisArg?: any): Result;
+			thisArg?: any): Result;
 
 		/**
 		* @see _.merge
 		**/
-        merge<P, T, S1, S2, S3, S4, Value, Result>(
-            object: T,
-            s1: S1,
-            s2: S2,
-            s3: S3,
-            s4: S4,
+		merge<P, T, S1, S2, S3, S4, Value, Result>(
+			object: T,
+			s1: S1,
+			s2: S2,
+			s3: S3,
+			s4: S4,
 			callback?: (objectValue: Value, sourceValue: Value) => Value,
-            thisArg?: any): Result;
+			thisArg?: any): Result;
 	}
 
 	//_.omit
@@ -3524,7 +5347,7 @@ declare module _ {
 		* @param keys The properties to omit.
 		* @return An object without the omitted properties.
 		**/
-        omit<Omitted, T>(
+		omit<Omitted, T>(
 			object: T,
 			...keys: string[]): Omitted;
 
@@ -3567,7 +5390,7 @@ declare module _ {
 		* @param keys Property names to pick
 		* @return An object composed of the picked properties.
 		**/
-        pick<Picked, T>(
+		pick<Picked, T>(
 			object: T,
 			...keys: string[]): Picked;
 
@@ -3602,7 +5425,7 @@ declare module _ {
 		* @return The accumulated value.
 		**/
 		transform<T, Acc>(
-			collection: Collection<T>,
+			collection: Array<T>,
 			callback: MemoVoidIterator<T, Acc>,
 			accumulator: Acc,
 			thisArg?: any): Acc;
@@ -3611,7 +5434,41 @@ declare module _ {
 		* @see _.transform
 		**/
 		transform<T, Acc>(
-			collection: Collection<T>,
+			collection: List<T>,
+			callback: MemoVoidIterator<T, Acc>,
+			accumulator: Acc,
+			thisArg?: any): Acc;
+
+		/**
+		* @see _.transform
+		**/
+		transform<T, Acc>(
+			collection: Dictionary<T>,
+			callback: MemoVoidIterator<T, Acc>,
+			accumulator: Acc,
+			thisArg?: any): Acc;
+
+		/**
+		* @see _.transform
+		**/
+		transform<T, Acc>(
+			collection: Array<T>,
+			callback?: MemoVoidIterator<T, Acc>,
+			thisArg?: any): Acc;
+
+		/**
+		* @see _.transform
+		**/
+		transform<T, Acc>(
+			collection: List<T>,
+			callback?: MemoVoidIterator<T, Acc>,
+			thisArg?: any): Acc;
+
+		/**
+		* @see _.transform
+		**/
+		transform<T, Acc>(
+			collection: Dictionary<T>,
 			callback?: MemoVoidIterator<T, Acc>,
 			thisArg?: any): Acc;
 	}
@@ -3693,7 +5550,7 @@ declare module _ {
 		* @return A random number.
 		**/
 		random(max: number, floating?: boolean): number;
-	
+
 		/**
 		* @see _.random
 		* @param min The minimum possible value.
@@ -3752,13 +5609,13 @@ declare module _ {
 		**/
 		template(
 			text: string): TemplateExecutor;
-		
+
 		/**
 		* @see _.template
 		**/
 		template(
 			text: string,
-			data: any, 
+			data: any,
 			options?: TemplateSettings,
 			sourceURL?: string,
 			variable?: string): any /* string or TemplateExecutor*/;
@@ -3768,7 +5625,7 @@ declare module _ {
 		(...data: any[]): string;
 		source: string;
 	}
-		
+
 	//_.times
 	interface LoDashStatic {
 		/**
@@ -3779,8 +5636,8 @@ declare module _ {
 		* @param thisArg The this binding of callback.
 		**/
 		times<TResult>(
-			n: number, 
-			callback: (num: number) => TResult, 
+			n: number,
+			callback: (num: number) => TResult,
 			context?: any): TResult[];
 	}
 
@@ -3820,24 +5677,24 @@ declare module _ {
 	interface MemoIterator<T, TResult> {
 		(prev: TResult, curr: T, indexOrKey: any, list?: T[]): TResult;
 	}
-    /*
+	/*
 	interface MemoListIterator<T, TResult> {
 		(prev: TResult, curr: T, index: number, list?: T[]): TResult;
 	}
 	interface MemoObjectIterator<T, TResult> {
 		(prev: TResult, curr: T, index: string, object?: Dictionary<T>): TResult;
 	}
-    */
+	*/
 
-	interface Collection<T> { }
+	//interface Collection<T> {}
 
 	// Common interface between Arrays and jQuery objects
-	interface List<T> extends Collection<T> {
+	interface List<T> {
 		[index: number]: T;
 		length: number;
 	}
 
-	interface Dictionary<T> extends Collection<T> {
+	interface Dictionary<T> {
 		[index: string]: T;
 	}
 }