From 6928dced9060c8479f6d23646853ee9a1210fac7 Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Tue, 22 Oct 2013 02:40:50 -0400
Subject: [PATCH] MAJOR!! code refactor to support some awesome chaining logic
 where only appropriate methods will be available to continue the chain.

---
 lodash/lodash-tests.ts |  229 +-
 lodash/lodash.d.ts     | 6918 +++++++++++++++++++++-------------------
 2 files changed, 3765 insertions(+), 3382 deletions(-)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index e4ac60e3a..2161f4a95 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -85,43 +85,62 @@ var result;
 /*************
  * Chaining *
  *************/
-result = <_.LoDashWrapper<string>>_('test');
-result = <_.LoDashWrapper<string[]>>_(['test1', 'test2']);
+result = <LoDash.LoDashWrapper<string>>_('test');
+result = <LoDash.LoDashWrapper<number>>_(1);
+result = <LoDash.LoDashWrapper<boolean>>_(true);
+result = <LoDash.LoDashArrayWrapper<string>>_(['test1', 'test2']);
+result = <LoDash.LoDashObjectWrapper<LoDash.Dictionary<string>>>_({'key1': 'test1', 'key2': 'test2'});
 
-result = <_.LoDashWrapper<string>>_('test').chain();
-result = <_.LoDashWrapper<string[]>>_(['test1', 'test2']).chain();
-result = <_.LoDashWrapper<string>>_.chain('test');
-result = <_.LoDashWrapper<string[]>>_.chain(['test1', 'test2']);
+result = <LoDash.LoDashWrapper<string>>_.chain('test');
+result = <LoDash.LoDashWrapper<string>>_('test').chain();
+result = <LoDash.LoDashWrapper<number>>_.chain(1);
+result = <LoDash.LoDashWrapper<number>>_(1).chain();
+result = <LoDash.LoDashWrapper<boolean>>_.chain(true);
+result = <LoDash.LoDashWrapper<boolean>>_(true).chain();
+result = <LoDash.LoDashArrayWrapper<string>>_.chain(['test1', 'test2']);
+result = <LoDash.LoDashArrayWrapper<string>>_(['test1', 'test2']).chain();
+result = <LoDash.LoDashObjectWrapper<LoDash.Dictionary<string>>>_.chain({'key1': 'test1', 'key2': 'test2'});
+result = <LoDash.LoDashObjectWrapper<LoDash.Dictionary<string>>>_({'key1': 'test1', 'key2': 'test2'}).chain();
 
-result = <_.LoDashWrapper<number[]>>_([1, 2, 3, 4]).concat([5, 6, 7]);
-result = <_.LoDashWrapper<string>>_([1, 2, 3, 4]).join(',');
-result = <_.LoDashWrapper<number>>_([1, 2, 3, 4]).pop();
+//Wrapped array shortcut methods
+result = <LoDash.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).concat(5, 6);
+result = <LoDash.LoDashWrapper<string>>_([1, 2, 3, 4]).join(',');
+result = <LoDash.LoDashWrapper<number>>_([1, 2, 3, 4]).pop();
 _([1, 2, 3, 4]).push(5, 6, 7);
-result = <_.LoDashWrapper<number[]>>_([1, 2, 3, 4]).reverse();
-result = <_.LoDashWrapper<number>>_([1, 2, 3, 4]).shift();
-result = <_.LoDashWrapper<number[]>>_([1, 2, 3, 4]).slice(1, 2);
-result = <_.LoDashWrapper<number[]>>_([1, 2, 3, 4]).slice(2);
-result = <_.LoDashWrapper<number[]>>_([1, 2, 3, 4]).sort((a, b) => 1);
-result = <_.LoDashWrapper<number[]>>_([1, 2, 3, 4]).splice(1);
-result = <_.LoDashWrapper<number[]>>_([1, 2, 3, 4]).splice(1, 2, 5, 6);
-result = <_.LoDashWrapper<number>>_([1, 2, 3, 4]).unshift(5, 6);
+result = <LoDash.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).reverse();
+result = <LoDash.LoDashWrapper<number>>_([1, 2, 3, 4]).shift();
+result = <LoDash.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).slice(1, 2);
+result = <LoDash.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).slice(2);
+result = <LoDash.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).sort((a, b) => 1);
+result = <LoDash.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).splice(1);
+result = <LoDash.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).splice(1, 2, 5, 6);
+result = <LoDash.LoDashWrapper<number>>_([1, 2, 3, 4]).unshift(5, 6);
 
 result = <number[]>_.tap([1, 2, 3, 4], function(array) { console.log(array); });
-result = <_.LoDashWrapper<number[]>>_([1, 2, 3, 4]).tap(function(array) { console.log(array); });
+result = <LoDash.LoDashWrapper<string>>_('test').tap(function(value) { console.log(value); });
+result = <LoDash.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).tap(function(array) { console.log(array); });
+result = <LoDash.LoDashObjectWrapper<LoDash.Dictionary<string>>>_({'key1': 'test1', 'key2': 'test2'}).tap(function(array) { console.log(array); });
 
+result = <string>_('test').toString();
 result = <string>_([1, 2, 3]).toString();
+result = <string>_({'key1': 'test1', 'key2': 'test2'}).toString();
 
+result = <string>_('test').valueOf();
 result = <number[]>_([1, 2, 3]).valueOf();
-	result = <number[]>_([1, 2, 3]).value();
+result = <LoDash.Dictionary<string>>_({'key1': 'test1', 'key2': 'test2'}).valueOf();
 
-/*************
- * Arrays *
- *************/
+result = <string>_('test').value();
+result = <number[]>_([1, 2, 3]).value();
+result = <LoDash.Dictionary<string>>_({'key1': 'test1', 'key2': 'test2'}).value();
+
+// /*************
+//  * Arrays *
+//  *************/
 result = <any[]>_.compact([0, 1, false, 2, '', 3]);
-	result = <_.LoDashWrapper<any[]>>_([0, 1, false, 2, '', 3]).compact();
+	result = <LoDash.LoDashArrayWrapper<any>>_([0, 1, false, 2, '', 3]).compact();
 
 result = <number[]>_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
-result = <_.LoDashWrapper<number[]>>_([1, 2, 3, 4, 5]).difference([5, 2, 10]);
+	result = <LoDash.LoDashArrayWrapper<number>>_([1, 2, 3, 4, 5]).difference([5, 2, 10]);
 
 result = <number[]>_.rest([1, 2, 3]);
 result = <number[]>_.rest([1, 2, 3], 2);
@@ -131,21 +150,21 @@ result = <number[]>_.rest([1, 2, 3], function(num) {
 result = <IFoodOrganic[]>_.rest(foodsOrganic, 'test');
 result = <IFoodType[]>_.rest(foodsType, { 'test': 'value' });
 
-	_.drop([1, 2, 3]);
-	_.drop([1, 2, 3], 2);
-	_.drop([1, 2, 3], function(num) {
+	result = <number[]>_.drop([1, 2, 3]);
+	result = <number[]>_.drop([1, 2, 3], 2);
+	result = <number[]>_.drop([1, 2, 3], function(num) {
 	  return num < 3;
 	});
-	_.drop(foodsOrganic, 'test');
-	_.drop(foodsType, { 'test': 'value' });
+	result = <IFoodOrganic[]>_.drop(foodsOrganic, 'test');
+	result = <IFoodType[]>_.drop(foodsType, { 'test': 'value' });
 
-	_.tail([1, 2, 3]);
-	_.tail([1, 2, 3], 2);
-	_.tail([1, 2, 3], function(num) {
+	result = <number[]>_.tail([1, 2, 3]);
+	result = <number[]>_.tail([1, 2, 3], 2);
+	result = <number[]>_.tail([1, 2, 3], function(num) {
 	  return num < 3;
 	});
-	_.tail(foodsOrganic, 'test');
-	_.tail(foodsType, { 'test': 'value' });
+	result = <IFoodOrganic[]>_.tail(foodsOrganic, 'test');
+	result = <IFoodType[]>_.tail(foodsType, { 'test': 'value' });
 
 result = <number>_.findIndex(['apple', 'banana', 'beet'], function(f) {
   return /^b/.test(f);
@@ -159,7 +178,6 @@ result = <number>_.findLastIndex(['apple', 'banana', 'beet'], function(f) {
 result = <number>_.findLastIndex(['apple', 'banana', 'beet'], 'apple');
 result = <number>_.findLastIndex([{ food: 'apple' }, { food: 'banana' }, { food: 'beet' }], { food: 'apple'});
 
-
 result = <number>_.first([1, 2, 3]);
 result = <number[]>_.first([1, 2, 3], 2);
 result = <number[]>_.first([1, 2, 3], function(num) {
@@ -168,29 +186,29 @@ result = <number[]>_.first([1, 2, 3], function(num) {
 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], function(num) {
-  return 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], function(num) {
+	  return 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);
 result = <string[]>_.flatten(stoogesQuotes, 'quotes');
 
-	result = <number[]>_([1, [2], [3, [[4]]]]).flatten();
-	result = <any[]>_([1, [2], [3, [[4]]]]).flatten(true);
-	result = <string[]>_(stoogesQuotes).flatten('quotes');
+	result = <LoDash.LoDashArrayWrapper<number>>_([1, [2], [3, [[4]]]]).flatten();
+	result = <LoDash.LoDashArrayWrapper<number>>_([1, [2], [3, [[4]]]]).flatten(true);
+	result = <LoDash.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);
@@ -263,14 +281,14 @@ result = <{x: number;}[]>_.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
 	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 = <any[][]>_.unzip(['moe', 'larry'], [30, 40], [true, false]);
-	result = <any[][]>_.zip(['moe', 'larry'], [30, 40], [true, false]);
-
 result = <number[]>_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
 
-/* *************
- * Collections *
- ************* */
+result = <any[][]>_.zip(['moe', 'larry'], [30, 40], [true, false]);
+	result = <any[][]>_.unzip(['moe', 'larry'], [30, 40], [true, false]);
+
+// /* *************
+//  * Collections *
+//  ************* */
 
 result = <string[]>_.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]);
 result = <string[]>_.at(['moe', 'larry', 'curly'], 0, 2);
@@ -285,13 +303,13 @@ result = <boolean>_.contains('curly', 'ur');
 	result = <boolean>_.include({ 'name': 'moe', 'age': 40 }, 'moe');
 	result = <boolean>_.include('curly', 'ur');
 
-result = <_.Dictionary<number>>_.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); });
-result = <_.Dictionary<number>>_.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
-result = <_.Dictionary<number>>_.countBy(['one', 'two', 'three'], 'length');
+result = <LoDash.Dictionary<number>>_.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); });
+result = <LoDash.Dictionary<number>>_.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+result = <LoDash.Dictionary<number>>_.countBy(['one', 'two', 'three'], 'length');
 
-	result = <_.LoDashWrapper<_.Dictionary<number>>>_([4.3, 6.1, 6.4]).countBy(function(num) { return Math.floor(num); });
-	result = <_.LoDashWrapper<_.Dictionary<number>>>_([4.3, 6.1, 6.4]).countBy(function(num) { return this.floor(num); }, Math);
-	result = <_.LoDashWrapper<_.Dictionary<number>>>_(['one', 'two', 'three']).countBy('length');
+	result = <LoDash.LoDashObjectWrapper<LoDash.Dictionary<number>>>_([4.3, 6.1, 6.4]).countBy(function(num) { return Math.floor(num); });
+	result = <LoDash.LoDashObjectWrapper<LoDash.Dictionary<number>>>_([4.3, 6.1, 6.4]).countBy(function(num) { return this.floor(num); }, Math);
+	result = <LoDash.LoDashObjectWrapper<LoDash.Dictionary<number>>>_(['one', 'two', 'three']).countBy('length');
 
 result = <boolean>_.every([true, 1, null, 'yes'], Boolean);
 result = <boolean>_.every(stoogesAges, 'age');
@@ -313,9 +331,9 @@ result = <IFoodCombined[]>_.filter(foodsCombined, { 'type': 'fruit' });
 	result = <IFoodCombined[]>_.select(foodsCombined, 'organic');
 	result = <IFoodCombined[]>_.select(foodsCombined, { 'type': 'fruit' });
 
-	result = <number[]>_([1, 2, 3, 4, 5, 6]).select(function(num) { return num % 2 == 0; });
-	result = <IFoodCombined[]>_(foodsCombined).select('organic');
-	result = <IFoodCombined[]>_(foodsCombined).select({ 'type': 'fruit' });
+		result = <number[]>_([1, 2, 3, 4, 5, 6]).select(function(num) { return num % 2 == 0; });
+		result = <IFoodCombined[]>_(foodsCombined).select('organic');
+		result = <IFoodCombined[]>_(foodsCombined).select({ 'type': 'fruit' });
 
 result = <number>_.find([1, 2, 3, 4], function(num) {
   return num % 2 == 0;
@@ -342,24 +360,30 @@ 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 = <LoDash.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 = <LoDash.Dictionary<number>>_.each({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
+
+	result = <LoDash.LoDashArrayWrapper<number>>_([1, 2, 3]).forEach(function(num) { console.log(num); });
+	result = <LoDash.LoDashObjectWrapper<LoDash.Dictionary<number>>>_({ 'one': 1, 'two': 2, 'three': 3 }).forEach(function(num) { console.log(num); });	
+
+		result = <LoDash.LoDashArrayWrapper<number>>_([1, 2, 3]).each(function(num) { console.log(num); });
+		result = <LoDash.LoDashObjectWrapper<LoDash.Dictionary<number>>>_({ 'one': 1, 'two': 2, 'three': 3 }).each(function(num) { console.log(num); });	
 
 result = <number[]>_.forEachRight([1, 2, 3], function(num) { console.log(num); });
-result = <_.Dictionary<number>>_.forEachRight({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
+result = <LoDash.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 = <LoDash.Dictionary<number>>_.eachRight({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
 
-result = <_.Dictionary<number[]>>_.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); });
-result = <_.Dictionary<number[]>>_.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
-result = <_.Dictionary<string[]>>_.groupBy(['one', 'two', 'three'], 'length');
+result = <LoDash.Dictionary<number[]>>_.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); });
+result = <LoDash.Dictionary<number[]>>_.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+result = <LoDash.Dictionary<string[]>>_.groupBy(['one', 'two', 'three'], '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 = <LoDash.Dictionary<IKey>>_.indexBy(keys, 'dir');
+result = <LoDash.Dictionary<IKey>>_.indexBy(keys, function(key) { return String.fromCharCode(key.code); });
+result = <LoDash.Dictionary<IKey>>_.indexBy(keys, function(key) { this.fromCharCode(key.code); }, String);
 
 result = <any[]>_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
 result = <any[]>_.invoke([123, 456], String.prototype.split, '');
@@ -407,7 +431,6 @@ result = <any>_.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {
 	}, {});
 
 result = <any>_.reduceRight([[0, 1], [2, 3], [4, 5]], function(a, b) { return a.concat(b); }, []);
-
 	result = <any>_.foldr([[0, 1], [2, 3], [4, 5]], function(a, b) { return a.concat(b); }, []);
 
 result = <number[]>_.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
@@ -514,21 +537,20 @@ var greet = function(formatted) {
 };
 
 result = <Function>_.compose(greet, format);
-result = <_.LoDashWrapper<Function>>_(greet).compose(format);
+result = <LoDash.LoDashObjectWrapper<Function>>_(greet).compose(format);
 
 var createCallbackObj = { name: 'Joe' };
 result = <() => any>_.createCallback('name');
 result = <() => boolean>_.createCallback(createCallbackObj);
-result = <_.LoDashWrapper<() => any>>_('name').createCallback();
-result = <_.LoDashWrapper<() => boolean>>_(createCallbackObj).createCallback();
-
+result = <LoDash.LoDashObjectWrapper<() => any>>_('name').createCallback();
+result = <LoDash.LoDashObjectWrapper<() => boolean>>_(createCallbackObj).createCallback();
 
 result = <Function>_.curry(function(a, b, c) {
-  console.log(a + b + c);
+  	console.log(a + b + c);
 });
 
-result = <_.LoDashWrapper<Function>>_(function(a, b, c) {
-  console.log(a + b + c);
+result = <LoDash.LoDashObjectWrapper<Function>>_(function(a, b, c) {
+  	console.log(a + b + c);
 }).curry();
 
 declare var source;
@@ -543,23 +565,23 @@ source.addEventListener('message', <Function>_.debounce(function() {}, 250, {
   'maxWait': 1000
 }), false);
 
-result = <_.LoDashWrapper<Function>>_(function() {}).debounce(150);
+result = <LoDash.LoDashObjectWrapper<Function>>_(function() {}).debounce(150);
 
-jQuery('#postbox').on('click', <_.LoDashWrapper<Function>>_(function() {}).debounce(300, {
+jQuery('#postbox').on('click', <LoDash.LoDashObjectWrapper<Function>>_(function() {}).debounce(300, {
   'leading': true,
   'trailing': false
 }));
 
-source.addEventListener('message', <_.LoDashWrapper<Function>>_(function() {}).debounce(250, {
+source.addEventListener('message', <LoDash.LoDashObjectWrapper<Function>>_(function() {}).debounce(250, {
   'maxWait': 1000
 }), false);
 
 result = <number>_.defer(function() { console.log('deferred'); });
-result = <_.LoDashWrapper<number>>_(function() { console.log('deferred'); }).defer();
+result = <LoDash.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');
+result = <LoDash.LoDashWrapper<number>>_(log).delay(1000, 'logged later');
 
 var fibonacci = <Function>_.memoize(function(n) {
   return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
@@ -614,8 +636,8 @@ result = <any>_.assign({ 'name': 'moe' }, { 'age': 40 }, function(a, b) {
   return typeof a == 'undefined' ? b : a;
 });
 
-result = <_.LoDashWrapper<any>>_({ 'name': 'moe' }).assign({ 'age': 40 });
-result = <_.LoDashWrapper<any>>_({ 'name': 'moe' }).assign({ 'age': 40 }, function(a, b) {
+result = <LoDash.LoDashObjectWrapper<any>>_({ 'name': 'moe' }).assign({ 'age': 40 });
+result = <LoDash.LoDashObjectWrapper<any>>_({ 'name': 'moe' }).assign({ 'age': 40 }, function(a, b) {
   return typeof a == 'undefined' ? b : a;
 });
 
@@ -624,8 +646,8 @@ result = <_.LoDashWrapper<any>>_({ 'name': 'moe' }).assign({ 'age': 40 }, functi
 	  return typeof a == 'undefined' ? b : a;
 	});
 
-	result = <_.LoDashWrapper<any>>_({ 'name': 'moe' }).extend({ 'age': 40 });
-	result = <_.LoDashWrapper<any>>_({ 'name': 'moe' }).extend({ 'age': 40 }, function(a, b) {
+	result = <LoDash.LoDashObjectWrapper<any>>_({ 'name': 'moe' }).extend({ 'age': 40 });
+	result = <LoDash.LoDashObjectWrapper<any>>_({ 'name': 'moe' }).extend({ 'age': 40 }, function(a, b) {
 	  return typeof a == 'undefined' ? b : a;
 	});
 
@@ -660,7 +682,6 @@ result = <any>_.forInRight(new Dog('Dagny'), function(value, key) {
   console.log(key);
 });
 
-
 result = <any>_.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
   console.log(key);
 });
@@ -670,7 +691,7 @@ result = <any>_.forOwnRight({ '0': 'zero', '1': 'one', 'length': 2 }, function(n
 });
 
 result = <string[]>_.functions(_);
-	result = <string[]>_.methods(_);
+ 	result = <string[]>_.methods(_);
 
 result = <boolean>_.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');
 
@@ -840,7 +861,7 @@ result = <any>_.result(object, 'stuff');
 var tempObject = {};
 result = <typeof _>_.runInContext(tempObject);
 
-result = <_.TemplateExecutor>_.template('hello <%= name %>');
+result = <LoDash.TemplateExecutor>_.template('hello <%= name %>');
 result = <string>_.template('<b><%- value %></b>', { 'value': '<script>' });
 
 var listTemplate = '<% _.forEach(people, function(name) { %><li><%- name %></li><% }); %>';
@@ -850,10 +871,10 @@ result = <string>_.template('<% print("hello " + name); %>!', { 'name': 'larry'
 
 var listTemplate = '<% $.each(people, function(name) { %><li><%- name %></li><% }); %>';
 result = <string>_.template(listTemplate, { 'people': ['moe', 'larry'] }, { 'imports': { '$': jQuery } });
-result = <_.TemplateExecutor>_.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });
+result = <LoDash.TemplateExecutor>_.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });
 
-result = <_.TemplateExecutor>_.template('hi <%= data.name %>!', null, { 'variable': 'data' });
-result = <string>(<_.TemplateExecutor>result).source;
+result = <LoDash.TemplateExecutor>_.template('hi <%= data.name %>!', null, { 'variable': 'data' });
+result = <string>(<LoDash.TemplateExecutor>result).source;
 
 function Mage() {
 	this.castSpell = (n:number) => n;
@@ -868,3 +889,11 @@ result = <string>_.unescape('Moe, Larry &amp; Curly');
 
 result = <string>_.uniqueId('contact_');
 result = <string>_.uniqueId();
+
+/**********
+* Utilities *
+***********/
+
+result = <string>_.VERSION;
+result = <LoDash.Support>_.support;
+result = <LoDash.TemplateSettings>_.templateSettings;
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 3ea253d6f..d2c0d06d4 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -1,81 +1,17 @@
-// Type definitions for Lo-Dash 2.2.1
-// Project: http://lodash.com/
-// Definitions by:
-// Brian Zengel <https://github.com/bczengel/>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-// Heavily based on Underscore definitions by Boris Yankov
+declare var _: LoDash.LoDashStatic;
 
-/**
-* Creates a lodash object which wraps the given value to enable intuitive method chaining.
-*
-* In addition to Lo-Dash methods, wrappers also have the following Array methods:
-* concat, join, pop, push, reverse, shift, slice, sort, splice, and unshift
-*
-* Chaining is supported in custom builds as long as the value method is implicitly or explicitly 
-* included in the build.
-*
-* The chainable wrapper functions are:
-* after, assign, bind, bindAll, bindKey, chain, compact, compose, concat, countBy, createCallback, 
-* curry, debounce, defaults, defer, delay, difference, filter, flatten, forEach, forEachRight, 
-* forIn, forInRight, forOwn, forOwnRight, functions, groupBy, indexBy, initial, intersection, 
-* invert, invoke, keys, map, max, memoize, merge, min, object, omit, once, pairs, partial, 
-* partialRight, pick, pluck, pull, push, range, reject, remove, rest, reverse, shuffle, slice, sort, 
-* sortBy, splice, tap, throttle, times, toArray, transform, union, uniq, unshift, unzip, values, 
-* where, without, wrap, and zip
-*
-* The non-chainable wrapper functions are:
-* clone, cloneDeep, contains, escape, every, find, findIndex, findKey, findLast, findLastIndex, 
-* findLastKey, has, identity, indexOf, isArguments, isArray, isBoolean, isDate, isElement, isEmpty, 
-* isEqual, isFinite, isFunction, isNaN, isNull, isNumber, isObject, isPlainObject, isRegExp, 
-* isString, isUndefined, join, lastIndexOf, mixin, noConflict, parseInt, pop, random, reduce, 
-* reduceRight, result, shift, size, some, sortedIndex, runInContext, template, unescape, uniqueId, 
-* and value
-*
-* The wrapper functions first and last return wrapped values when n is provided, otherwise they 
-* return unwrapped values.
-*
-* Explicit chaining can be enabled by using the _.chain method.
-* @param value The value to wrap in a lodash instance.
-* @return A lodash instance.
-**/
-declare function _<T>(value: T): _.LoDashWrapper<T>;
-declare function _<T>(value: T[]): _.LoDashWrapper<T[]>;
+declare module LoDash {
+	interface LoDashStatic {
+		(value: number): LoDashWrapper<number>;
+		(value: string): LoDashWrapper<string>;
+		(value: boolean): LoDashWrapper<boolean>;
+		<T>(value: Array<T>): LoDashArrayWrapper<T>;
+		<T extends {}>(value: T): LoDashObjectWrapper<T>;
+		(value: any): LoDashWrapper<any>;
 
-declare module _ {
-	/**
-	* lodash.js _.debounce options
-	**/
-	interface DebounceSettings {
-		/**
-		* Specify execution on the leading edge of the timeout.
-		**/
-		leading?: boolean;
-		
-		/**
-		* The maximum time func is allowed to be delayed before it’s called.
-		**/
-		maxWait?: number;
-
-		/**
-		* Specify execution on the trailing edge of the timeout.
-		**/
-		trailing?: boolean;
-	}
-
-	/**
-	* lodash.js _.throttle options.
-	**/
-	interface ThrottleSettings {
-
-		/**
-		* If you'd like to disable the leading-edge call, pass this as false.
-		**/
-		leading?: boolean;
-
-		/**
-		* If you'd like to disable the execution on the trailing-edge, pass false.
-		**/
-		trailing?: boolean;
+		VERSION: string;
+		templateSettings: TemplateSettings;
+		support: Support;
 	}
 
 	/**
@@ -184,10 +120,3633 @@ declare module _ {
 		unindexedChars: boolean;
 	}
 
+	interface LoDashWrapperBase<T, TWrapper> {
+		/**
+		* Produces the toString result of the wrapped value.
+		* @return Returns the string result.
+		**/
+		toString(): string;
+
+		/**
+		* Extracts the wrapped value.
+		* @return The wrapped value.
+		**/
+		valueOf(): T;
+
+			/**
+			* @see valueOf
+			**/
+			value(): T;
+	} 
+
+	interface LoDashWrapper<T> extends LoDashWrapperBase<T, LoDashWrapper<T>> {}
+
+	interface LoDashObjectWrapper<T> extends LoDashWrapperBase<T, LoDashObjectWrapper<T>> {}
+
+	interface LoDashArrayWrapper<T> extends LoDashWrapperBase<T[], LoDashArrayWrapper<T>> {
+		concat(...items: T[]): LoDashArrayWrapper<T>;
+		join(seperator?: string): LoDashWrapper<string>;
+		pop(): LoDashWrapper<T>;
+		push(...items: T[]): void;
+		reverse(): LoDashArrayWrapper<T>;
+		shift(): LoDashWrapper<T>;
+		slice(start: number, end?: number): LoDashArrayWrapper<T>;
+		sort(compareFn?: (a: T, b: T) => number): LoDashArrayWrapper<T>;
+		splice(start: number): LoDashArrayWrapper<T>;
+		splice(start: number, deleteCount: number, ...items: any[]): LoDashArrayWrapper<T>;
+		unshift(...items: any[]): LoDashWrapper<number>;
+	}
+
+	//_.chain
+	interface LoDashStatic {
+		/**
+		* Creates a lodash object that wraps the given value with explicit method chaining enabled.
+		* @param value The value to wrap.
+		* @return The wrapper object.
+		**/
+		chain(value: number): LoDashWrapper<number>;
+		chain(value: string): LoDashWrapper<string>;
+		chain(value: boolean): LoDashWrapper<boolean>;
+		chain<T>(value: Array<T>): LoDashArrayWrapper<T>;
+		chain<T extends {}>(value: T): LoDashObjectWrapper<T>;
+		chain(value: any): LoDashWrapper<any>;
+	}
+
+	interface LoDashWrapperBase<T, TWrapper> {
+		/**
+		* Enables explicit method chaining on the wrapper object.
+		* @see _.chain
+		* @return The wrapper object.
+		**/
+		chain(): TWrapper;
+	}
+
+	//_.tap
+	interface LoDashStatic {
+		/**
+		* Invokes interceptor with the value as the first argument and then returns value. The 
+		* purpose of this method is to "tap into" a method chain in order to perform operations on 
+		* intermediate results within the chain.
+		* @param value The value to provide to interceptor
+		* @param interceptor The function to invoke.
+		* @return value
+		**/
+		tap<T>(
+			value: T,
+			interceptor: (value: T) => void): T;
+	}
+
+	interface LoDashWrapperBase<T, TWrapper> {
+		/**
+		* @see _.tap
+		**/
+		tap(interceptor: (value: T) => void): TWrapper;
+	}
+
+	/*********
+	* Arrays *
+	**********/
+
+	//_.compact
+	interface LoDashStatic {
+		/**
+		* Returns a copy of the array with all falsy values removed. In JavaScript, false, null, 0, "",
+		* undefined and NaN are all falsy.
+		* @param array Array to compact.
+		* @return (Array) Returns a new array of filtered values.
+		**/
+		compact<T>(array: List<T>): T[];
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.compact
+		**/
+		compact<T>(): LoDashArrayWrapper<T>;
+	}	
+
+	//_.difference
+	interface LoDashStatic {
+		/**
+		* Creates an array excluding all values of the provided arrays using strict equality for comparisons
+		* , i.e. ===.
+		* @param array The array to process
+		* @param others The arrays of values to exclude.
+		* @return Returns a new array of filtered values.
+		**/
+		difference<T>(
+			array: List<T>,
+			...others: List<T>[]): T[];
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.difference
+		**/
+		difference(
+			...others: List<T>[]): LoDashArrayWrapper<T>;
+	}
+
+	//_.findIndex
+	interface LoDashStatic {
+		/**
+		* This method is like _.find except that it returns the index of the first element that passes 
+		* the callback check, instead of the element itself.
+		* @param array The array to search.
+		* @param {(Function|Object|string)} callback The function called per iteration. If a property name or object is provided it will be 
+		* used to create a ".pluck" or ".where" style callback, respectively.
+		* @param thisArg The this binding of callback.
+		* @return Returns the index of the found element, else -1.
+		**/
+		findIndex<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): number;
+
+		/**
+		* @see _.findIndex
+		**/
+		findIndex<T>(
+			array: List<T>,
+			pluckValue: string,
+			thisArg?: any): number;
+		
+		/**
+		* @see _.findIndex
+		**/
+		findIndex<T>(
+			array: List<T>,
+			whereDictionary: Dictionary<any>,
+			thisArg?: any): number;
+	}
+
+	//_.findLastIndex
+	interface LoDashStatic {
+		/**
+		* This method is like _.findIndex except that it iterates over elements of a collection from right to left.
+		* @param array The array to search.
+		* @param {(Function|Object|string)} callback The function called per iteration. If a property name or object is provided it will be 
+		* used to create a ".pluck" or ".where" style callback, respectively.
+		* @param thisArg The this binding of callback.
+		* @return Returns the index of the found element, else -1.
+		**/
+		findLastIndex<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): number;
+		
+		/**
+		* @see _.findLastIndex
+		**/
+		findLastIndex<T>(
+			array: List<T>,
+			pluckValue: string): number;
+		
+		/**
+		* @see _.findLastIndex
+		**/
+		findLastIndex<T>(
+			array: List<T>,
+			whereDictionary: Dictionary<any>): number;
+	}
+
+	//_.first
+	interface LoDashStatic {
+		/**
+		* Gets the first element or first n elements of an array. If a callback is provided 
+		* elements at the beginning of the array are returned as long as the callback returns 
+		* truey. The callback is bound to thisArg and invoked with three arguments; (value, 
+		* index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback 
+		* will return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return ]
+		* true for elements that have the properties of the given object, else false.
+		* @param array Retrieves the first element of this array.
+		* @return Returns the first element of `array`.
+		**/
+		first<T>(array: List<T>): T;
+
+		/**
+		* @see _.first
+		* @param n The number of elements to return.
+		**/
+		first<T>(
+			array: List<T>,
+			n: number): T[];
+
+		/**
+		* @see _.first
+		* @param callback The function called per element.
+		* @param [thisArg] The this binding of callback.
+		**/
+		first<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.first
+		* @param pluckValue "_.pluck" style callback value
+		**/
+		first<T>(
+			array: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.first
+		* @param whereValue "_.where" style callback value
+		**/
+		first<T>(
+			array: List<T>,
+			whereValue: Dictionary<string>): T[];
+
+			/**
+			* @see _.first
+			**/
+			head<T>(array: List<T>): T;
+
+			/**
+			* @see _.first
+			**/
+			head<T>(
+				array: List<T>,
+				n: number): T[];
+
+			/**
+			* @see _.first
+			**/
+			head<T>(
+				array: List<T>,
+				callback: ListIterator<T, boolean>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.first
+			**/
+			head<T>(
+				array: List<T>,
+				pluckValue: string): T[];
+
+			/**
+			* @see _.first
+			**/
+			head<T>(
+				array: List<T>,
+				whereValue: Dictionary<string>): T[];
+
+			/**
+			* @see _.first
+			**/
+			take<T>(array: List<T>): T;
+
+			/**
+			* @see _.first
+			**/
+			take<T>(
+				array: List<T>,
+				n: number): T[];
+
+			/**
+			* @see _.first
+			**/
+			take<T>(
+				array: List<T>,
+				callback: ListIterator<T, boolean>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.first
+			**/
+			take<T>(
+				array: List<T>,
+				pluckValue: string): T[];
+
+			/**
+			* @see _.first
+			**/
+			take<T>(
+				array: List<T>,
+				whereValue: Dictionary<string>): T[];
+	}
+
+	//_.flatten
+	interface LoDashStatic {
+		/**
+		* Flattens a nested array (the nesting can be to any depth). If isShallow is truey, the 
+		* array will only be flattened a single level. If a callback is provided each element of 
+		* the array is passed through the callback before flattening. The callback is bound to 
+		* thisArg and invoked with three arguments; (value, index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param array The array to flatten.
+		* @param shallow If true then only flatten one level, optional, default = false.
+		* @return `array` flattened.
+		**/
+		flatten<T>(
+			array: List<T>,
+			isShallow?,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): any[];			
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.flatten
+		**/
+		flatten(
+			isShallow?,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): LoDashArrayWrapper<any>;
+	}
+
+	//_.indexOf
+	interface LoDashStatic {
+		/**
+		* Gets the index at which the first occurrence of value is found using strict equality 
+		* for comparisons, i.e. ===. If the array is already sorted providing true for fromIndex 
+		* will run a faster binary search.
+		* @param array The array to search.
+		* @param value The value to search for.
+		* @param fromIndex The index to search from.
+		* @return The index of `value` within `array`.
+		**/
+		indexOf<T>(
+			array: List<T>,
+			value: T): number;
+
+		/**
+		* @see _.indexOf
+		* @param fromIndex The index to search from
+		**/
+		indexOf<T>(
+			array: List<T>,
+			value: T,
+			fromIndex: number): number;
+
+		/**
+		* @see _.indexOf
+		* @param isSorted True to perform a binary search on a sorted array.
+		**/
+		indexOf<T>(
+			array: List<T>,
+			value: T,
+			isSorted: boolean): number;
+	}
+
+	//_.initial
+	interface LoDashStatic {
+		/**
+		* Gets all but the last element or last n elements of an array. If a callback is provided 
+		* elements at the end of the array are excluded from the result as long as the callback 
+		* returns truey. The callback is bound to thisArg and invoked with three arguments; 
+		* (value, index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param array The array to query.
+		* @param n Leaves this many elements behind, optional.
+		* @return Returns everything but the last `n` elements of `array`.
+		**/
+		initial<T>(
+			array: List<T>): T[];
+
+		/**
+		* @see _.initial
+		* @param n The number of elements to exclude.
+		**/
+		initial<T>(
+			array: List<T>,
+			n: number): T[];
+
+		/**
+		* @see _.initial
+		* @param callback The function called per element
+		**/
+		initial<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>): T[];
+
+		/**
+		* @see _.initial
+		* @param pluckValue _.pluck style callback
+		**/
+		initial<T>(
+			array: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.initial
+		* @param whereValue _.where style callback
+		**/
+		initial<T>(
+			array: List<T>,
+			whereValue: Dictionary<any>): T[];
+	}
+
+	//_.intersection
+	interface LoDashStatic {
+		/**
+		* Creates an array of unique values present in all provided arrays using strict 
+		* equality for comparisons, i.e. ===.
+		* @param arrays The arrays to inspect.
+		* @return Returns an array of composite values.
+		**/
+		intersection<T>(...arrays: List<T>[]): T[];
+	}
+
+	//_.last
+	interface LoDashStatic {
+		/**
+		* Gets the last element or last n elements of an array. If a callback is provided 
+		* elements at the end of the array are returned as long as the callback returns truey. 
+		* The callback is bound to thisArg and invoked with three arguments; (value, index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param array The array to query.
+		* @return Returns the last element(s) of array.
+		**/
+		last<T>(array: List<T>): T;
+
+		/**
+		* @see _.last
+		* @param n The number of elements to return
+		**/
+		last<T>(
+			array: List<T>,
+			n: number): T[];
+
+		/**
+		* @see _.last
+		* @param callback The function called per element
+		**/
+		last<T>(
+			array: List<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.last
+		* @param pluckValue _.pluck style callback
+		**/
+		last<T>(
+			array: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.last
+		* @param whereValue _.where style callback
+		**/
+		last<T>(
+			array: List<T>,
+			whereValue: Dictionary<any>): T[];
+	}
+
+	//_.lastIndexOf
+	interface LoDashStatic {
+		/**
+		* Gets the index at which the last occurrence of value is found using strict equality 
+		* for comparisons, i.e. ===. If fromIndex is negative, it is used as the offset from the 
+		* end of the collection.
+		* @param array The array to search.
+		* @param value The value to search for.
+		* @param fromIndex The index to search from.
+		* @return The index of the matched value or -1.
+		**/
+		lastIndexOf<T>(
+			array: List<T>,
+			value: T,
+			fromIndex?: number): number;
+	}
+	
+	//_.pull
+	interface LoDashStatic {
+		/**
+		* Removes all provided values from the given array using strict equality for comparisons, 
+		* i.e. ===.
+		* @param array The array to modify.
+		* @param values The values to remove.
+		* @return array.
+		**/
+		pull(
+			array: List<any>,
+			...values: any[]): any[];
+	}
+
+	//_.range
+	interface LoDashStatic {
+		/**
+		* Creates an array of numbers (positive and/or negative) progressing from start up 
+		* to but not including end. If start is less than stop a zero-length range is created 
+		* unless a negative step is specified.
+		* @param start The start of the range.
+		* @param end The end of the range.
+		* @param step The value to increment or decrement by.
+		* @return Returns a new range array.
+		**/
+
+		range(
+			start: number,
+			stop: number,
+			step?: number): number[];
+		
+		/**
+		* @see _.range
+		* @param end The end of the range.
+		* @return Returns a new range array.
+		* @note If start is not specified the implementation will never pull the step (step = arguments[2] || 0)
+		**/
+		range(stop: number): number[];
+	}
+
+	//_.remove
+	interface LoDashStatic {
+		/**
+		* Removes all elements from an array that the callback returns truey for and returns 
+		* an array of removed elements. The callback is bound to thisArg and invoked with three 
+		* arguments; (value, index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param array The array to modify.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return A new array of removed elements.
+		**/
+		remove(
+			array: List<any>,
+			callback?: ListIterator<any, boolean>,
+			thisArg?: any): any[];
+
+		/**
+		* @see _.remove
+		* @param pluckValue _.pluck style callback
+		**/
+		remove(
+			array: List<any>,
+			pluckValue?: string): any[];
+
+		/**
+		* @see _.remove
+		* @param whereValue _.where style callback
+		**/
+		remove(
+			array: List<any>,
+			wherealue?: Dictionary<any>): any[];
+	}
+
+	//_.rest
+	interface LoDashStatic {
+		/**
+		* The opposite of _.initial this method gets all but the first element or first n elements of 
+		* an array. If a callback function is provided elements at the beginning of the array are excluded 
+		* from the result as long as the callback returns truey. The callback is bound to thisArg and 
+		* invoked with three arguments; (value, index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will return 
+		* the property value of the given element.
+		* 
+		* If an object is provided for callback the created "_.where" style callback will return true 
+		* for elements that have the properties of the given object, else false.
+		* @param array The array to query.
+		* @param {(Function|Object|number|string)} [callback=1] The function called per element or the number 
+		* of elements to exclude. If a property name or object is provided it will be used to create a 
+		* ".pluck" or ".where" style callback, respectively.
+		* @param {*} [thisArg] The this binding of callback.
+		* @return Returns a slice of array.
+		**/
+		rest<T>(
+			array: List<T>,
+			callback: (num: number) => boolean,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.rest
+		**/
+		rest<T>(
+			array: List<T>,
+			n?: number,
+			thisArg?: any): T[];
+		
+		/**
+		* @see _.rest
+		**/
+		rest<T>(
+			array: List<T>,
+			pluckValue: string,
+			thisArg?: any): T[];
+		
+		/**
+		* @see _.rest
+		**/
+		rest<T>(
+			array: List<T>,
+			whereValue: Dictionary<any>,
+			thisArg?: any): T[];
+
+			/**
+			* @see _.rest
+			**/
+			drop<T>(
+				array: List<T>,
+				callback: (num: number) => boolean,
+				thisArg?: any): T[];
+			
+			/**
+			* @see _.rest
+			**/
+			drop<T>(
+				array: List<T>,
+				n?: number,
+				thisArg?: any): T[];
+			
+			/**
+			* @see _.rest
+			**/
+			drop<T>(
+				array: List<T>,
+				pluckValue: string,
+				thisArg?: any): T[];
+			
+			/**
+			* @see _.rest
+			**/
+			drop<T>(
+				array: List<T>,
+				whereValue: Dictionary<any>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.rest
+			**/
+			tail<T>(
+				array: List<T>,
+				callback: (num: number) => boolean,
+				thisArg?: any): T[];
+			
+			/**
+			* @see _.rest
+			**/
+			tail<T>(
+				array: List<T>,
+				n?: number,
+				thisArg?: any): T[];
+			
+			/**
+			* @see _.rest
+			**/
+			tail<T>(
+				array: List<T>,
+				pluckValue: string,
+				thisArg?: any): T[];
+			
+			/**
+			* @see _.rest
+			**/
+			tail<T>(
+				array: List<T>,
+				whereValue: Dictionary<any>,
+				thisArg?: any): T[];
+	}
+
+	//_.sortedIndex
+	interface LoDashStatic {
+		/**
+		* Uses a binary search to determine the smallest index at which a value should be inserted 
+		* into a given sorted array in order to maintain the sort order of the array. If a callback 
+		* is provided it will be executed for value and each element of array to compute their sort 
+		* ranking. The callback is bound to thisArg and invoked with one argument; (value).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param array The sorted list.
+		* @param value The value to determine its index within `list`.
+		* @param callback Iterator to compute the sort ranking of each value, optional.
+		* @return The index at which value should be inserted into array.
+		**/
+		sortedIndex<T, TSort>(
+			array: List<T>,
+			value: T,
+			callback?: (x: T) => TSort, 
+			thisArg?: any): number;
+
+		/**
+		* @see _.sortedIndex
+		* @param pluckValue the _.pluck style callback
+		**/
+		sortedIndex<T, TSort>(
+			array: List<T>,
+			value: T,
+			pluckValue: string): number;
+
+		/**
+		* @see _.sortedIndex
+		* @param pluckValue the _.where style callback
+		**/
+		sortedIndex<T, TSort>(
+			array: List<T>,
+			value: T,
+			whereValue: Dictionary<any>): number;
+	}
+
+	//_.union
+	interface LoDashStatic {
+		/**
+		* Creates an array of unique values, in order, of the provided arrays using strict 
+		* equality for comparisons, i.e. ===.
+		* @param arrays The arrays to inspect.
+		* @return Returns an array of composite values.
+		**/
+		union<T>(...arrays: List<T>[]): T[];
+	}
+
+	//_.uniq
+	interface LoDashStatic {
+		/**
+		* Creates a duplicate-value-free version of an array using strict equality for comparisons, 
+		* i.e. ===. If the array is sorted, providing true for isSorted will use a faster algorithm. 
+		* If a callback is provided each element of array is passed through the callback before 
+		* uniqueness is computed. The callback is bound to thisArg and invoked with three arguments; 
+		* (value, index, array).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param array Array to remove duplicates from.
+		* @param isSorted True if `array` is already sorted, optiona, default = false.
+		* @param iterator Transform the elements of `array` before comparisons for uniqueness.
+		* @param context 'this' object in `iterator`, optional.
+		* @return Copy of `array` where all elements are unique.
+		**/
+		uniq<T, TSort>(
+			array: List<T>,
+			isSorted?: boolean,
+			callback?: ListIterator<T, TSort>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.uniq
+		**/
+		uniq<T, TSort>(
+			array: List<T>,
+			callback?: ListIterator<T, TSort>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.uniq
+		* @param pluckValue _.pluck style callback
+		**/
+		uniq<T, TSort>(
+			array: List<T>,
+			isSorted?: boolean,
+			pluckValue?: string): T[];
+
+		/**
+		* @see _.uniq
+		* @param whereValue _.where style callback
+		**/
+		uniq<T, TSort>(
+			array: List<T>,
+			whereValue?: Dictionary<any>): T[];
+
+			/**
+			* @see _.uniq
+			**/
+			unique<T, TSort>(
+				array: List<T>,
+				callback?: ListIterator<T, TSort>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.uniq
+			**/
+			unique<T, TSort>(
+				array: List<T>,
+				isSorted?: boolean,
+				callback?: ListIterator<T, TSort>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.uniq
+			* @param pluckValue _.pluck style callback
+			**/
+			unique<T, TSort>(
+				array: List<T>,
+				isSorted?: boolean,
+				pluckValue?: string): T[];
+
+			/**
+			* @see _.uniq
+			* @param whereValue _.where style callback
+			**/
+			unique<T, TSort>(
+				array: List<T>,
+				whereValue?: Dictionary<any>): T[];
+	}
+
+	//_.without
+	interface LoDashStatic {
+		/**
+		* Creates an array excluding all provided values using strict equality for comparisons, i.e. ===.
+		* @param array The array to filter.
+		* @param values The value(s) to exclude.
+		* @return A new array of filtered values.
+		**/
+		without<T>(
+			array: List<T>,
+			...values: T[]): T[];
+	}
+
+	//_.zip
+	interface LoDashStatic {
+		/**
+		* Creates an array of grouped elements, the first of which contains the first 
+		* elements of the given arrays, the second of which contains the second elements 
+		* of the given arrays, and so on.
+		* @param arrays Arrays to process.
+		* @return A new array of grouped elements.
+		**/
+		zip(...arrays: any[][]): any[][];
+
+		/**
+		* @see _.zip
+		**/
+		zip(...arrays: any[]): any[];
+
+			/**
+			* @see _.zip
+			**/
+			unzip(...arrays: any[][]): any[][];
+
+			/**
+			* @see _.zip
+			**/
+			unzip(...arrays: any[]): any[];
+	}
+
+	//_.zipObject
+	interface LoDashStatic {
+		/**
+		* Creates an object composed from arrays of keys and values. Provide either a single 
+		* two dimensional array, i.e. [[key1, value1], [key2, value2]] or two arrays, one of 
+		* keys and one of corresponding values.
+		* @param keys The array of keys.
+		* @param values The array of values.
+		* @return An object composed of the given keys and corresponding values.
+		**/
+		zipObject<TResult extends {}>(
+			keys: List<string>,
+			values: List<any>): TResult;
+
+			/**
+			* @see _.object
+			**/
+			object<TResult extends {}>(
+				keys: List<string>,
+				values: List<any>): TResult;
+	}
+
+	/* *************
+	 * Collections *
+	 ************* */
+
+	//_.at
+	interface LoDashStatic {
+		/**
+		* Creates an array of elements from the specified indexes, or keys, of the collection. 
+		* Indexes may be specified as individual arguments or as arrays of indexes.
+		* @param collection The collection to iterate over.
+		* @param indexes The indexes of collection to retrieve, specified as individual indexes or 
+		* arrays of indexes.
+		* @return A new array of elements corresponding to the provided indexes.
+		**/
+		at<T>(
+			collection: Collection<T>,
+			indexes: number[]): T[];
+
+		/**
+		* @see _.at
+		**/
+		at<T>(
+			collection: Collection<T>,
+			...indexes: number[]): T[];
+	}
+
+	//_.contains
+	interface LoDashStatic {
+		/**
+		* Checks if a given value is present in a collection using strict equality for comparisons, 
+		* i.e. ===. If fromIndex is negative, it is used as the offset from the end of the collection.
+		* @param collection The collection to iterate over.
+		* @param target The value to check for.
+		* @param fromIndex The index to search from.
+		* @return True if the target element is found, else false.
+		**/
+		contains<T>(
+			collection: Collection<T>,
+			target: T,
+			fromIndex?: number): boolean;
+
+		/**
+		* @see _.contains
+		* @param dictionary The dictionary to iterate over.
+		* @param key The key in the dictionary to search for.
+		**/
+		contains<T>(
+			dictionary: Dictionary<T>,
+			key: string,
+			fromIndex?: number): boolean;
+
+		/**
+		* @see _.contains
+		* @param searchString the string to search
+		* @param targetString the string to search for
+		**/
+		contains(
+			searchString: string,
+			targetString: string,
+			fromIndex?: number): boolean;
+
+			/**
+			* @see _.contains
+			**/
+			include<T>(
+				collection: Collection<T>,
+				target: T,
+				fromIndex?: number): boolean;
+
+			/**
+			* @see _.contains
+			**/
+			include<T>(
+				dictionary: Dictionary<T>,
+				key: string,
+				fromIndex?: number): boolean;
+
+			/**
+			* @see _.contains
+			**/
+			include(
+				searchString: string,
+				targetString: string,
+				fromIndex?: number): boolean;
+	}
+
+	//_.countBy
+	interface LoDashStatic {
+		/**
+		* Creates an object composed of keys generated from the results of running each element 
+		* of collection through the callback. The corresponding value of each key is the number 
+		* of times the key was returned by the callback. The callback is bound to thisArg and 
+		* invoked with three arguments; (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return Returns the composed aggregate object.
+		**/
+		countBy<T>(
+			collection: Collection<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): Dictionary<number>;
+
+		/**
+		* @see _.countBy
+		* @param callback Function name
+		**/
+		countBy<T>(
+			collection: Collection<T>,
+			callback: string,
+			thisArg?: any): Dictionary<number>;			
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.countBy
+		**/
+		countBy<T>(
+			callback?: ListIterator<T, any>,
+			thisArg?: any): LoDashObjectWrapper<Dictionary<number>>;
+
+		/**
+		* @see _.countBy
+		* @param callback Function name
+		**/
+		countBy<T>(
+			callback: string,
+			thisArg?: any): LoDashObjectWrapper<Dictionary<number>>;
+	}
+
+	//_.every
+	interface LoDashStatic {
+		/**
+		* Checks if the given callback returns truey value for all elements of a collection. 
+		* The callback is bound to thisArg and invoked with three arguments; (value, index|key, 
+		* collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return True if all elements passed the callback check, else false.
+		**/
+		every<T>(
+			collection: Collection<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.every
+		* @param pluckValue _.pluck style callback
+		**/
+		every<T>(
+			collection: Collection<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.every
+		* @param whereValue _.where style callback
+		**/
+		every<T>(
+			collection: Collection<T>,
+			whereValue: Dictionary<any>): boolean;
+
+			/**
+			* @see _.every
+			**/
+			all<T>(
+				collection: Collection<T>,
+				callback?: ListIterator<T, boolean>,
+				thisArg?: any): boolean;
+
+			/**
+			* @see _.every
+			* @param pluckValue _.pluck style callback
+			**/
+			all<T>(
+				collection: Collection<T>,
+				pluckValue: string): boolean;
+
+			/**
+			* @see _.every
+			* @param whereValue _.where style callback
+			**/
+			all<T>(
+				collection: Collection<T>,
+				whereValue: Dictionary<any>): boolean;
+	}
+
+	//_.filter
+	interface LoDashStatic {
+		/**
+		* Iterates over elements of a collection, returning an array of all elements the 
+		* callback returns truey for. The callback is bound to thisArg and invoked with three 
+		* arguments; (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param context The this binding of callback.
+		* @return Returns a new array of elements that passed the callback check.
+		**/
+		filter<T>(
+			collection: Collection<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		filter<T>(
+			collection: Collection<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		filter<T>(
+			collection: Collection<T>,
+			whereValue: Dictionary<any>): T[];
+
+			/**
+			* @see _.filter
+			**/
+			select<T>(
+				collection: Collection<T>,
+				callback: ListIterator<T, boolean>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.filter
+			* @param pluckValue _.pluck style callback
+			**/
+			select<T>(
+				collection: Collection<T>,
+				pluckValue: string): T[];
+
+			/**
+			* @see _.filter
+			* @param pluckValue _.pluck style callback
+			**/
+			select<T>(
+				collection: Collection<T>,
+				whereValue: Dictionary<any>): T[];				
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.filter
+		**/
+		filter<T>(
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		filter<T>(
+			pluckValue: string): T[];
+
+		/**
+		* @see _.filter
+		* @param pluckValue _.pluck style callback
+		**/
+		filter<T>(
+			whereValue: Dictionary<any>): T[];
+
+			/**
+			* @see _.filter
+			**/
+			select<T>(
+				callback: ListIterator<T, boolean>,
+				thisArg?: any): T[];
+
+			/**
+			* @see _.filter
+			* @param pluckValue _.pluck style callback
+			**/
+			select<T>(
+				pluckValue: string): T[];
+
+			/**
+			* @see _.filter
+			* @param pluckValue _.pluck style callback
+			**/
+			select<T>(
+				whereValue: Dictionary<any>): T[];
+	}
+
+	//_.find
+	interface LoDashStatic {
+		/**
+		* Iterates over elements of a collection, returning the first element that the callback 
+		* returns truey for. The callback is bound to thisArg and invoked with three arguments; 
+		* (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param collection Searches for a value in this list.
+		* @param callback The function called per iteration. 
+		* @param thisArg The this binding of callback.
+		* @return The found element, else undefined.
+		**/
+		find<T>(
+			collection: Collection<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		find<T>(
+			collection: Collection<T>,
+			whereValue: Dictionary<any>): T;
+
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		find<T>(
+			collection: Collection<T>,
+			pluckValue: string): T;
+
+			/**
+			* @see _.find
+			**/
+			detect<T>(
+				collection: Collection<T>,
+				callback: ListIterator<T, boolean>,
+				thisArg?: any): T;
+
+			/**
+			* @see _.find
+			* @param _.pluck style callback
+			**/
+			detect<T>(
+				collection: Collection<T>,
+				whereValue: Dictionary<any>): T;
+
+			/**
+			* @see _.find
+			* @param _.where style callback
+			**/
+			detect<T>(
+				collection: Collection<T>,
+				pluckValue: string): T;
+
+			/**
+			* @see _.find
+			**/
+			findWhere<T>(
+				collection: Collection<T>,
+				callback: ListIterator<T, boolean>,
+				thisArg?: any): T;
+
+			/**
+			* @see _.find
+			* @param _.pluck style callback
+			**/
+			findWhere<T>(
+				collection: Collection<T>,
+				whereValue: Dictionary<any>): T;
+
+			/**
+			* @see _.find
+			* @param _.where style callback
+			**/
+			findWhere<T>(
+				collection: Collection<T>,
+				pluckValue: string): T;
+	}
+
+	//_.findLast
+	interface LoDashStatic {
+		/**
+		* This method is like _.find except that it iterates over elements of a collection from 
+		* right to left.
+		* @param collection Searches for a value in this list.
+		* @param callback The function called per iteration. 
+		* @param thisArg The this binding of callback.
+		* @return The found element, else undefined.
+		**/
+		findLast<T>(
+			collection: Collection<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.find
+		* @param _.pluck style callback
+		**/
+		findLast<T>(
+			collection: Collection<T>,
+			whereValue: Dictionary<any>): T;
+
+		/**
+		* @see _.find
+		* @param _.where style callback
+		**/
+		findLast<T>(
+			collection: Collection<T>,
+			pluckValue: string): T;
+	}
+
+	//_.forEach
+	interface LoDashStatic {
+		/**
+		* Iterates over elements of a collection, executing the callback for each element. 
+		* The callback is bound to thisArg and invoked with three arguments; (value, index|key, 
+		* collection). Callbacks may exit iteration early by explicitly returning false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		**/
+		forEach<T>(
+			collection: List<T>,
+			callback: ListIterator<T, void >,
+			thisArg?: any): List<T>;
+
+		/**
+		* @see _.forEach
+		**/
+		forEach<T extends {}>(
+			object: Dictionary<T>,
+			callback: ObjectIterator<T, void >,
+			thisArg?: any): Dictionary<T>;
+
+			/**
+			* @see _.forEach
+			**/
+			each<T>(
+				collection: List<T>,
+				callback: ListIterator<T, void>,
+				thisArg?: any): List<T>;
+
+			/**
+			* @see _.forEach
+			* @param object The object to iterate over
+			* @param callback The function called per iteration.
+			* @param thisArg The this binding of callback.
+			**/
+			each<T extends {}>(
+				object: Dictionary<T>,
+				callback: ObjectIterator<T, void>,
+				thisArg?: any): Dictionary<T>;			
+	}
+
+	interface LoDashArrayWrapper<T> {
+		/**
+		* @see _.forEach
+		**/
+		forEach<T>(
+			callback: ListIterator<T, void >,
+			thisArg?: any): LoDashArrayWrapper<T>;
+
+			/**
+			* @see _.forEach
+			**/
+			each<T>(
+				callback: ListIterator<T, void >,
+				thisArg?: any): LoDashArrayWrapper<T>;
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.forEach
+		**/
+		forEach<T extends {}>(
+			callback: ObjectIterator<T, void >,
+			thisArg?: any): LoDashObjectWrapper<T>;
+
+			/**
+			* @see _.forEach
+			**/
+			each<T extends {}>(
+				callback: ObjectIterator<T, void >,	
+				thisArg?: any): LoDashObjectWrapper<T>;
+	}
+
+	//_.forEachRight
+	interface LoDashStatic {
+		/**
+		* This method is like _.forEach except that it iterates over elements of a 
+		* collection from right to left.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		**/
+		forEachRight<T>(
+			collection: List<T>,
+			callback: ListIterator<T, void >,
+			thisArg?: any): List<T>;
+
+		/**
+		* @see _.each
+		**/
+		forEachRight<T extends {}>(
+			object: Dictionary<T>,
+			callback: ObjectIterator<T, void >,
+			thisArg?: any): Dictionary<T>;
+
+			/**
+			* @see _.each
+			**/
+			eachRight<T>(
+				collection: List<T>,
+				callback: ListIterator<T, void>,
+				thisArg?: any): List<T>;
+
+			/**
+			* @see _.each
+			* @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>;
+	}
+
+	//_.groupBy
+	interface LoDashStatic {
+		/**
+		* Creates an object composed of keys generated from the results of running each element 
+		* of a collection through the callback. The corresponding value of each key is an array 
+		* of the elements responsible for generating the key. The callback is bound to thisArg 
+		* and invoked with three arguments; (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return Returns the composed aggregate object.
+		**/
+		groupBy<T>(
+			collection: List<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): Dictionary<T[]>;
+
+		/**
+		* @see _.groupBy
+		* @param pluckValue _.pluck style callback
+		**/
+		groupBy<T>(
+			collection: List<T>,
+			pluckValue: string): Dictionary<T[]>;
+
+		/**
+		* @see _.groupBy
+		* @param whereValue _.where style callback
+		**/
+		groupBy<T>(
+			collection: List<T>,
+			whereValue: Dictionary<any>): Dictionary<T[]>;
+	}
+
+	//_.indexBy
+	interface LoDashStatic {
+		/**
+		* Creates an object composed of keys generated from the results of running each element 
+		* of the collection through the given callback. The corresponding value of each key is 
+		* the last element responsible for generating the key. The callback is bound to thisArg 
+		* and invoked with three arguments; (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return Returns the composed aggregate object.
+		**/
+		indexBy<T>(
+			list: List<T>,
+			iterator: ListIterator<T, any>,
+			context?: any): Dictionary<T>;
+
+		/**
+		* @see _.indexBy
+		* @param pluckValue _.pluck style callback
+		**/
+		indexBy<T>(
+			collection: List<T>,
+			pluckValue: string): Dictionary<T>;
+
+		/**
+		* @see _.indexBy
+		* @param whereValue _.where style callback
+		**/
+		indexBy<T>(
+			collection: List<T>,
+			whereValue: Dictionary<any>): Dictionary<T>;
+	}
+
+	//_.invoke
+	interface LoDashStatic {
+		/**
+		* Invokes the method named by methodName on each element in the collection returning 
+		* an array of the results of each invoked method. Additional arguments will be provided 
+		* to each invoked method. If methodName is a function it will be invoked for, and this 
+		* bound to, each element in the collection.
+		* @param collection The collection to iterate over.
+		* @param methodName The name of the method to invoke.
+		* @param args Arguments to invoke the method with.
+		**/
+		invoke<T extends {}>(
+			collection: Collection<T>,
+			methodName: string,
+			...args: any[]): any;
+
+		/**
+		* @see _.invoke
+		**/
+		invoke<T extends {}>(
+			collection: Collection<T>,
+			method: Function,
+			...args: any[]): any;
+	}
+
+	//_.map
+	interface LoDashStatic {
+		/**
+		* Creates an array of values by running each element in the collection through the callback. 
+		* The callback is bound to thisArg and invoked with three arguments; (value, index|key, 
+		* collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will return 
+		* the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return true 
+		* for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param theArg The this binding of callback.
+		* @return The mapped array result.
+		**/
+		map<T, TResult>(
+			collection: List<T>,
+			callback: ListIterator<T, TResult>,
+			thisArg?: any): TResult[];
+
+		/**
+		* @see _.map
+		* @param object The object to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg `this` object in `iterator`, optional.
+		* @return The mapped object result.
+		**/
+		map<T extends {}, TResult>(
+			object: Dictionary<T>,
+			callback: ObjectIterator<T, TResult>,
+			thisArg?: any): TResult[];
+
+		/**
+		* @see _.map
+		* @param pluckValue _.pluck style callback
+		**/
+		map<T, TResult>(
+			collection: List<T>,
+			pluckValue: string): TResult[];
+
+			/**
+			* @see _.map
+			**/
+			collect<T, TResult>(
+				collection: List<T>,
+				callback: ListIterator<T, TResult>,
+				thisArg?: any): TResult[];
+
+			/**
+			* @see _.map
+			**/
+			collect<T extends {}, TResult>(
+				object: Dictionary<T>,
+				callback: ObjectIterator<T, TResult>,
+				thisArg?: any): TResult[];
+
+			/**
+			* @see _.map
+			**/
+			collect<T, TResult>(
+				collection: List<T>,
+				pluckValue: string): TResult[];
+	}
+
+	//_.max
+	interface LoDashStatic {
+		/**
+		* Retrieves the maximum value of a collection. If the collection is empty or falsey -Infinity is 
+		* returned. If a callback is provided it will be executed for each value in the collection to 
+		* generate the criterion by which the value is ranked. The callback is bound to thisArg and invoked 
+		* with three arguments; (value, index, collection).
+		* 
+		* If a property name is provided for callback the created "_.pluck" style callback will return the 
+		* property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return true for 
+		* elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return Returns the maximum value.
+		**/
+		max<T>(
+			collection: Collection<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.max
+		* @param pluckValue _.pluck style callback
+		**/
+		max<T>(
+			collection: Collection<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.max
+		* @param whereValue _.where style callback
+		**/
+		max<T>(
+			collection: Collection<T>,
+			whereValue: Dictionary<any>): T;
+	}
+
+	//_.min
+	interface LoDashStatic {
+		/**
+		* Retrieves the minimum value of a collection. If the collection is empty or falsey 
+		* Infinity is returned. If a callback is provided it will be executed for each value 
+		* in the collection to generate the criterion by which the value is ranked. The callback 
+		* is bound to thisArg and invoked with three arguments; (value, index, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback 
+		* will return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will 
+		* return true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return Returns the maximum value.
+		**/
+		min<T>(
+			collection: Collection<T>,
+			callback?: ListIterator<T, any>,
+			thisArg?: any): T;
+
+		/**
+		* @see _.min
+		* @param pluckValue _.pluck style callback
+		**/
+		min<T>(
+			collection: Collection<T>,
+			pluckValue: string): T;
+
+		/**
+		* @see _.min
+		* @param whereValue _.where style callback
+		**/
+		min<T>(
+			collection: Collection<T>,
+			whereValue: Dictionary<any>): T;
+	}
+
+	//_.pluck
+	interface LoDashStatic {
+		/**
+		* Retrieves the value of a specified property from all elements in the collection.
+		* @param collection The collection to iterate over.
+		* @param property The property to pluck.
+		* @return A new array of property values.
+		**/
+		pluck<T extends {}>(
+			collection: Collection<T>,
+			property: string): any[];
+	}
+
+	//_.reduce
+	interface LoDashStatic {
+		/**
+		* Reduces a collection to a value which is the accumulated result of running each 
+		* element in the collection through the callback, where each successive callback execution 
+		* consumes the return value of the previous execution. If accumulator is not provided the 
+		* first element of the collection will be used as the initial accumulator value. The callback 
+		* is bound to thisArg and invoked with four arguments; (accumulator, value, index|key, collection).
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param accumulator Initial value of the accumulator.
+		* @param thisArg The this binding of callback.
+		* @return Returns the accumulated value.
+		**/
+		reduce<T, TResult>(
+			collection: Collection<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator?: TResult,
+			thisArg?: any): TResult;
+
+			/**
+			* @see _.reduce
+			**/
+			inject<T, TResult>(
+				collection: Collection<T>,
+				callback: MemoIterator<T, TResult>,
+				accumulator?: TResult,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.reduce
+			**/
+			foldl<T, TResult>(
+				collection: Collection<T>,
+				callback: MemoIterator<T, TResult>,
+				accumulator?: TResult,
+				thisArg?: any): TResult;
+	}
+
+	//_.reduceRight
+	interface LoDashStatic {
+		/**
+		* This method is like _.reduce except that it iterates over elements of a collection from 
+		* right to left.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param accumulator Initial value of the accumulator.
+		* @param thisArg The this binding of callback.
+		* @return The accumulated value.
+		**/
+		reduceRight<T, TResult>(
+			collection: Collection<T>,
+			callback: MemoIterator<T, TResult>,
+			accumulator?: TResult,
+			thisArg?: any): TResult;
+
+			/**
+			* @see _.reduceRight
+			**/
+			foldr<T, TResult>(
+				collection: Collection<T>,
+				callback: MemoIterator<T, TResult>,
+				accumulator?: TResult,
+				thisArg?: any): TResult;
+	}
+
+	//_.reject
+	interface LoDashStatic {
+		/**
+		* The opposite of _.filter this method returns the elements of a collection that 
+		* the callback does not return truey for.
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback 
+		* will return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will 
+		* return true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return A new array of elements that failed the callback check.
+		**/
+		reject<T>(
+			collection: Collection<T>,
+			callback: ListIterator<T, boolean>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.reject
+		* @param pluckValue _.pluck style callback
+		**/
+		reject<T>(
+			collection: Collection<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.reject
+		* @param whereValue _.where style callback
+		**/
+		reject<T>(
+			collection: Collection<T>,
+			whereValue: Dictionary<any>): T[];
+	}
+
+	//_.sample
+	interface LoDashStatic {
+		/**
+		* Retrieves a random element or n random elements from a collection.
+		* @param collection The collection to sample.
+		* @return Returns the random sample(s) of collection.
+		**/
+		sample<T>(collection: Collection<T>): T;
+
+		/**
+		* @see _.sample
+		* @param n The number of elements to sample.
+		**/
+		sample<T>(collection: Collection<T>, n: number): T[];
+	}
+
+	//_.shuffle
+	interface LoDashStatic {
+		/**
+		* Creates an array of shuffled values, using a version of the Fisher-Yates shuffle. 
+		* See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.
+		* @param collection The collection to shuffle.
+		* @return Returns a new shuffled collection.
+		**/
+		shuffle<T>(collection: Collection<T>): T[];
+	}
+
+	//_.size
+	interface LoDashStatic {
+		/**
+		* Gets the size of the collection by returning collection.length for arrays and array-like 
+		* objects or the number of own enumerable properties for objects.
+		* @param collection The collection to inspect.
+		* @return collection.length
+		**/
+		size<T>(collection: List<T>): number;
+
+		/**
+		* @see _.size
+		* @param object The object to inspect
+		* @return The number of own enumerable properties.
+		**/
+		size<T extends {}>(object: T): number;
+
+		/**
+		* @see _.size
+		* @param aString The string to inspect
+		* @return The length of aString
+		**/
+		size(aString: string): number;
+	}
+
+	//_.some
+	interface LoDashStatic {
+		/**
+		* Checks if the callback returns a truey value for any element of a collection. The function 
+		* returns as soon as it finds a passing value and does not iterate over the entire collection. 
+		* The callback is bound to thisArg and invoked with three arguments; (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will return 
+		* the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return true for 
+		* elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return True if any element passed the callback check, else false.
+		**/
+		some<T>(
+			collection: Collection<T>,
+			callback?: ListIterator<T, boolean>,
+			thisArg?: any): boolean;
+
+		/**
+		* @see _.some
+		* @param pluckValue _.pluck style callback
+		**/
+		some<T>(
+			collection: Collection<T>,
+			pluckValue: string): boolean;
+
+		/**
+		* @see _.some
+		* @param whereValue _.where style callback
+		**/
+		some<T>(
+			collection: Collection<T>,
+			whereValue: Dictionary<any>): boolean;
+
+			/**
+			* @see _.some
+			**/
+			any<T>(
+				collection: Collection<T>,
+				callback?: ListIterator<T, boolean>,
+				thisArg?: any): boolean;
+
+			/**
+			* @see _.some
+			* @param pluckValue _.pluck style callback
+			**/
+			any<T>(
+				collection: Collection<T>,
+				pluckValue: string): boolean;
+
+			/**
+			* @see _.some
+			* @param whereValue _.where style callback
+			**/
+			any<T>(
+				collection: Collection<T>,
+				whereValue: Dictionary<any>): boolean;
+	}
+
+	//_.sortBy
+	interface LoDashStatic {
+		/**
+		* Creates an array of elements, sorted in ascending order by the results of running each 
+		* element in a collection through the callback. This method performs a stable sort, that 
+		* is, it will preserve the original sort order of equal elements. The callback is bound 
+		* to thisArg and invoked with three arguments; (value, index|key, collection).
+		*
+		* If a property name is provided for callback the created "_.pluck" style callback will 
+		* return the property value of the given element.
+		*
+		* If an object is provided for callback the created "_.where" style callback will return 
+		* true for elements that have the properties of the given object, else false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return A new array of sorted elements.
+		**/
+		sortBy<T, TSort>(
+			collection: List<T>,
+			callback?: ListIterator<T, TSort>,
+			thisArg?: any): T[];
+
+		/**
+		* @see _.sortBy
+		* @param pluckValue _.pluck style callback
+		**/
+		sortBy<T>(
+			collection: List<T>,
+			pluckValue: string): T[];
+
+		/**
+		* @see _.sortBy
+		* @param whereValue _.where style callback
+		**/
+		sortBy<T>(
+			collection: List<T>,
+			whereValue: Dictionary<any>): T[];
+	}
+
+	//_.toArray
+	interface LoDashStatic {
+		/**
+		* Converts the collection to an array.
+		* @param collection The collection to convert.
+		* @return The new converted array.
+		**/
+		toArray<T>(collection: Collection<T>): T[];
+	}
+
+	//_.where
+	interface LoDashStatic {
+		/**
+		* Performs a deep comparison of each element in a collection to the given properties 
+		* object, returning an array of all elements that have equivalent property values.
+		* @param collection The collection to iterate over.
+		* @param properties The object of property values to filter by.
+		* @return A new array of elements that have the given properties.
+		**/
+		where<T, U extends {}>(
+			list: Collection<T>,
+			properties: U): T[];
+	}
+
+	/*************
+	 * Functions *
+	 *************/
+
+	//_.after
+	interface LoDashStatic {
+		/**
+		* Creates a function that executes func, with the this binding and arguments of the 
+		* created function, only after being called n times.
+		* @param n The number of times the function must be called before func is executed.
+		* @param func The function to restrict.
+		* @return The new restricted function.
+		**/
+		after(
+			n: number,
+			func: Function): Function;			
+	}
+
+	interface LoDashWrapper<T> {
+		/**
+		* @see _.after
+		**/
+		after(func: Function): LoDashObjectWrapper<Function>;
+	}
+
+	//_.bind
+	interface LoDashStatic {
+		/**
+		* Creates a function that, when called, invokes func with the this binding of thisArg 
+		* and prepends any additional bind arguments to those provided to the bound function.
+		* @param func The function to bind.
+		* @param thisArg The this binding of func.
+		* @param args Arguments to be partially applied.
+		* @return The new bound function.
+		**/
+		bind(
+			func: Function,
+			thisArg: any,
+			...args: any[]): () => any;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.bind
+		**/
+		bind(
+			thisArg: any,
+			...args: any[]): LoDashObjectWrapper<() => any>;
+	}
+
+	//_.bindAll
+	interface LoDashStatic {
+		/**
+		* Binds methods of an object to the object itself, overwriting the existing method. Method 
+		* names may be specified as individual arguments or as arrays of method names. If no method 
+		* names are provided all the function properties of object will be bound.
+		* @param object The object to bind and assign the bound methods to.
+		* @param methodNames The object method names to bind, specified as individual method names 
+		* or arrays of method names.
+		* @return object
+		**/
+		bindAll<T>(
+			object: T,
+			...methodNames: string[]): T;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.bindAll
+		**/
+		bindAll<T>(...methodNames: string[]): LoDashWrapper<T>;
+	}
+
+	//_.bindKey
+	interface LoDashStatic {
+		/**
+		* Creates a function that, when called, invokes the method at object[key] and prepends any 
+		* additional bindKey arguments to those provided to the bound function. This method differs 
+		* from _.bind by allowing bound functions to reference methods that will be redefined or don't 
+		* yet exist. See http://michaux.ca/articles/lazy-function-definition-pattern.
+		* @param object The object the method belongs to.
+		* @param key The key of the method.
+		* @param args Arguments to be partially applied.
+		* @return The new bound function.
+		**/
+		bindKey<T>(
+			object: T,
+			key: string,
+			...args: any[]): Function;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.bindKey
+		**/
+		bindKey(
+			key: string,
+			...args: any[]): LoDashObjectWrapper<Function>;
+	}
+
+	//_.compose
+	interface LoDashStatic {
+		/**
+		* Creates a function that is the composition of the provided functions, where each function 
+		* consumes the return value of the function that follows. For example, composing the functions 
+		* f(), g(), and h() produces f(g(h())). Each function is executed with the this binding of the 
+		* composed function.
+		* @param funcs Functions to compose.
+		* @return The new composed function.
+		**/
+		compose(...funcs: Function[]): Function;	
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.compose
+		**/
+		compose(...funcs: Function[]): LoDashObjectWrapper<Function>;
+	}
+
+	//_.createCallback
+	interface LoDashStatic {
+		/**
+		* Produces a callback bound to an optional thisArg. If func is a property name the created 
+		* callback will return the property value for a given element. If func is an object the created 
+		* callback will return true for elements that contain the equivalent object properties, 
+		* otherwise it will return false.
+		* @param func The value to convert to a callback.
+		* @param thisArg The this binding of the created callback.
+		* @param argCount The number of arguments the callback accepts.
+		* @return A callback function.
+		**/
+		createCallback(
+			func: string,
+			thisArg?: any,
+			argCount?: number): () => any;
+
+		/**
+		* @see _.createCallback
+		**/
+		createCallback(
+			func: Dictionary<any>,
+			thisArg?: any,
+			argCount?: number): () => boolean;			
+	}
+
+	interface LoDashWrapper<T> {
+		/**
+		* @see _.createCallback
+		**/
+		createCallback(
+			thisArg?: any,
+			argCount?: number): LoDashObjectWrapper<() => any>;
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.createCallback
+		**/
+		createCallback(
+			thisArg?: any,
+			argCount?: number): LoDashObjectWrapper<() => any>;
+	}
+
+	//_.curry
+	interface LoDashStatic {
+		/**
+		* Creates a function which accepts one or more arguments of func that when invoked either 
+		* executes func returning its result, if all func arguments have been provided, or returns 
+		* a function that accepts one or more of the remaining func arguments, and so on. The arity 
+		* of func can be specified if func.length is not sufficient.
+		* @param func The function to curry.
+		* @param arity The arity of func.
+		* @return The new curried function.
+		**/
+		curry(
+			func: Function,
+			arity?: number): Function;	
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.curry
+		**/
+		curry(arity?: number): LoDashObjectWrapper<Function>;
+	}
+
+	//_.debounce
+	interface LoDashStatic {
+		/**
+		* Creates a function that will delay the execution of func until after wait milliseconds have 
+		* elapsed since the last time it was invoked. Provide an options object to indicate that func 
+		* should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent calls 
+		* to the debounced function will return the result of the last func call.
+		*
+		* Note: If leading and trailing options are true func will be called on the trailing edge of 
+		* the timeout only if the the debounced function is invoked more than once during the wait 
+		* timeout.
+		* @param func The function to debounce.
+		* @param wait The number of milliseconds to delay.
+		* @param options The options object.
+		* @param options.leading Specify execution on the leading edge of the timeout.
+		* @param options.maxWait The maximum time func is allowed to be delayed before it’s called.
+		* @param options.trailing Specify execution on the trailing edge of the timeout.
+		* @return The new debounced function.
+		**/
+		debounce(
+			func: Function,
+			wait: number,
+			options?: DebounceSettings): Function;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.debounce
+		**/
+		debounce(
+			wait: number,
+			options?: DebounceSettings): LoDashObjectWrapper<Function>;
+	}
+
+	interface DebounceSettings {
+		/**
+		* Specify execution on the leading edge of the timeout.
+		**/
+		leading?: boolean;
+		
+		/**
+		* The maximum time func is allowed to be delayed before it’s called.
+		**/
+		maxWait?: number;
+
+		/**
+		* Specify execution on the trailing edge of the timeout.
+		**/
+		trailing?: boolean;
+	}
+
+	//_.defer
+	interface LoDashStatic {
+		/**
+		* Defers executing the func function until the current call stack has cleared. Additional 
+		* arguments will be provided to func when it is invoked.
+		* @param func The function to defer.
+		* @param args Arguments to invoke the function with.
+		* @return The timer id.
+		**/
+		defer(
+			func: Function,
+			...args: any[]): number;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.defer
+		**/
+		defer(...args: any[]): LoDashWrapper<number>;
+	}
+
+	//_.delay
+	interface LoDashStatic {
+		/**
+		* Executes the func function after wait milliseconds. Additional arguments will be provided 
+		* to func when it is invoked.
+		* @param func The function to delay.
+		* @param wait The number of milliseconds to delay execution.
+		* @param args Arguments to invoke the function with.
+		* @return The timer id.
+		**/
+		delay(
+			func: Function,
+			wait: number,
+			...args: any[]): number;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.delay
+		**/
+		delay(
+			wait: number,
+			...args: any[]): LoDashWrapper<number>;
+	}
+
+	//_.memoize
+	interface LoDashStatic {
+		/**
+		* Creates a function that memoizes the result of func. If resolver is provided it will be 
+		* used to determine the cache key for storing the result based on the arguments provided to 
+		* the memoized function. By default, the first argument provided to the memoized function is 
+		* used as the cache key. The func is executed with the this binding of the memoized function. 
+		* The result cache is exposed as the cache property on the memoized function.
+		* @param func Computationally expensive function that will now memoized results.
+		* @param resolver Hash function for storing the result of `fn`.
+		* @return Returns the new memoizing function.
+		**/
+		memoize(
+			func: Function,
+			resolver?: (n: any) => string): Function;
+	}
+
+	//_.once
+	interface LoDashStatic {
+		/**
+		* Creates a function that is restricted to execute func once. Repeat calls to the function 
+		* will return the value of the first call. The func is executed with the this binding of the 
+		* created function.
+		* @param func Function to only execute once.
+		* @return The new restricted function.
+		**/
+		once(func: Function): Function;
+	}
+
+	//_.partial
+	interface LoDashStatic {
+		/**
+		* Creates a function that, when called, invokes func with any additional partial arguments 
+		* prepended to those provided to the new function. This method is similar to _.bind except 
+		* it does not alter the this binding.
+		* @param func The function to partially apply arguments to.
+		* @param args Arguments to be partially applied.
+		* @return The new partially applied function.
+		**/
+		partial(
+			func: Function,
+			...args: any[]): Function;
+	}
+
+	//_.partialRight
+	interface LoDashStatic {
+		/**
+		* This method is like _.partial except that partial arguments are appended to those provided 
+		* to the new function.
+		* @param func The function to partially apply arguments to.
+		* @param args Arguments to be partially applied.
+		* @return The new partially applied function.
+		**/
+		partialRight(
+			func: Function,
+			...args: any[]): Function;
+	}
+
+	//_.throttle
+	interface LoDashStatic {
+		/**
+		* Creates a function that, when executed, will only call the func function at most once per 
+		* every wait milliseconds. Provide an options object to indicate that func should be invoked 
+		* on the leading and/or trailing edge of the wait timeout. Subsequent calls to the throttled 
+		* function will return the result of the last func call.
+		*
+		* Note: If leading and trailing options are true func will be called on the trailing edge of 
+		* the timeout only if the the throttled function is invoked more than once during the wait timeout.
+		* @param func The function to throttle.
+		* @param wait The number of milliseconds to throttle executions to.
+		* @param options The options object.
+		* @param options.leading Specify execution on the leading edge of the timeout.
+		* @param options.trailing Specify execution on the trailing edge of the timeout.
+		* @return The new throttled function.
+		**/
+		throttle(
+			func: any,
+			wait: number,
+			options?: ThrottleSettings): Function;
+	}
+
+	interface ThrottleSettings {
+
+		/**
+		* If you'd like to disable the leading-edge call, pass this as false.
+		**/
+		leading?: boolean;
+
+		/**
+		* If you'd like to disable the execution on the trailing-edge, pass false.
+		**/
+		trailing?: boolean;
+	}
+
+	//_.wrap
+	interface LoDashStatic {
+		/**
+		* Creates a function that provides value to the wrapper function as its first argument. 
+		* Additional arguments provided to the function are appended to those provided to the 
+		* wrapper function. The wrapper is executed with the this binding of the created function.
+		* @param value The value to wrap.
+		* @param wrapper The wrapper function.
+		* @return The new function.
+		**/
+		wrap(
+			value: any,
+			wrapper: (func: Function, ...args: any[]) => any): Function;
+	}
+
+	/*************
+	 * Objects   *
+	 *************/
+
+	//_.assign
+	interface LoDashStatic {
+		/**
+		* Assigns own enumerable properties of source object(s) to the destination object. Subsequent 
+		* sources will overwrite property assignments of previous sources. If a callback is provided 
+		* it will be executed to produce the assigned values. The callback is bound to thisArg and 
+		* invoked with two arguments; (objectValue, sourceValue).
+		* @param object The destination object.
+		* @param s1-8 The source object(s)
+		* @param callback The function to customize merging properties.
+		* @param thisArg The this binding of callback.
+		* @return The destination object.
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/		
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			s3: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			s7: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<T, TResult>(
+			object: T,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			s7: any,
+			s8: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/				
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				s3: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				s6: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				s6: any,
+				s7: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.extend
+			**/
+			extend<T, TResult>(
+				object: T,
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				s6: any,
+				s7: any,
+				s8: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;			
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/		
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			s3: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			s7: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+		/**
+		* @see _.assign
+		**/
+		assign<TResult>(
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			s7: any,
+			s8: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/		
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				s3: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				s6: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				s6: any,
+				s7: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+
+			/**
+			* @see _.assign
+			**/
+			extend<TResult>(
+				s1: any,
+				s2: any,
+				s3: any,
+				s4: any,
+				s5: any,
+				s6: any,
+				s7: any,
+				s8: any,
+				callback?: (objectValue: any, sourceValue: any) => any,
+				thisArg?: any): TResult;
+	}
+
+	//_.clone
+	interface LoDashStatic {
+		/**
+		* Creates a clone of value. If deep is true nested objects will also be cloned, otherwise 
+		* they will be assigned by reference. If a callback is provided it will be executed to produce 
+		* the cloned values. If the callback returns undefined cloning will be handled by the method 
+		* instead. The callback is bound to thisArg and invoked with one argument; (value).
+		* @param value The value to clone.
+		* @param deep Specify a deep clone.
+		* @param callback The function to customize cloning values.
+		* @param thisArg The this binding of callback.
+		* @return The cloned value.
+		**/
+		clone<T>(
+			value: T,
+			deep?: boolean,
+			callback?: (value: any) => any,
+			thisArg?: any): T;
+	}
+
+	//_.cloneDeep
+	interface LoDashStatic {
+		/**
+		* Creates a deep clone of value. If a callback is provided it will be executed to produce the 
+		* cloned values. If the callback returns undefined cloning will be handled by the method instead. 
+		* The callback is bound to thisArg and invoked with one argument; (value).
+		*
+		* Note: This method is loosely based on the structured clone algorithm. Functions and DOM nodes 
+		* are not cloned. The enumerable properties of arguments objects and objects created by constructors 
+		* other than Object are cloned to plain Object objects. 
+		* See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.
+		* @param value The value to clone.
+		* @param callback The function to customize cloning values.
+		* @param thisArg The this binding of callback.
+		* @return The cloned value.
+		**/
+		cloneDeep<T>(
+			value: T,
+			callback?: (value: any) => any,
+			thisArg?: any): T;
+	}
+
+	//_.defaults
+	interface LoDashStatic {
+		/**
+		* Assigns own enumerable properties of source object(s) to the destination object for all 
+		* destination properties that resolve to undefined. Once a property is set, additional defaults 
+		* of the same property will be ignored.
+		* @param object The destination object.
+		* @param sources The source objects.
+		* @return The destination object.
+		**/
+		defaults<T, TResult>(
+			object: T,
+			...sources: any[]): TResult;	
+	}
+
+	interface LoDashObjectWrapper<T> {
+		/**
+		* @see _.defaults
+		**/
+		defaults<T, TResult>(...sources: any[]): LoDashObjectWrapper<TResult>
+	}
+
+	//_.findKey
+	interface LoDashStatic {
+		/**
+		* This method is like _.findIndex except that it returns the key of the first element that 
+		* passes the callback check, instead of the element itself.
+		* @param object The object to search.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return The key of the found element, else undefined.
+		**/
+		findKey(
+			object: any,
+			callback: (value: any) => boolean,
+			thisArg?: any): string;
+
+		/**
+		* @see _.findKey
+		* @param pluckValue _.pluck style callback
+		**/
+		findKey(
+			object: any,
+			pluckValue: string): string;
+
+		/**
+		* @see _.findKey
+		* @param whereValue _.where style callback
+		**/
+		findKey(
+			object: any,
+			whereValue: Dictionary<any>): string;
+	}
+
+	//_.findLastKey
+	interface LoDashStatic {
+		/**
+		* This method is like _.findKey except that it iterates over elements of a collection in the opposite order.
+		* @param object The object to search.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return The key of the found element, else undefined.
+		**/
+		findLastKey(
+			object: any,
+			callback: (value: any) => boolean,
+			thisArg?: any): string;
+
+		/**
+		* @see _.findLastKey
+		* @param pluckValue _.pluck style callback
+		**/
+		findLastKey(
+			object: any,
+			pluckValue: string): string;
+
+		/**
+		* @see _.findLastKey
+		* @param whereValue _.where style callback
+		**/
+		findLastKey(
+			object: any,
+			whereValue: Dictionary<any>): string;
+	}
+
+	//_.forIn
+	interface LoDashStatic {
+		/**
+		* Iterates over own and inherited enumerable properties of an object, executing the callback for 
+		* each property. The callback is bound to thisArg and invoked with three arguments; (value, key, 
+		* object). Callbacks may exit iteration early by explicitly returning false.
+		* @param object The object to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return object
+		**/
+		forIn<T extends {}>(
+			object: Dictionary<T>,
+			callback?: ObjectIterator<T, void>,
+			thisArg?: any): Dictionary<T>;
+	}
+
+	//_.forInRight
+	interface LoDashStatic {
+		/**
+		* This method is like _.forIn except that it iterates over elements of a collection in the 
+		* opposite order.
+		* @param object The object to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return object
+		**/
+		forInRight<T extends {}>(
+			object: Dictionary<T>,
+			callback?: ObjectIterator<T, void>,
+			thisArg?: any): Dictionary<T>;
+	}
+
+	//_.forOwn
+	interface LoDashStatic {
+		/**
+		* Iterates over own enumerable properties of an object, executing the callback for each 
+		* property. The callback is bound to thisArg and invoked with three arguments; (value, key, 
+		* object). Callbacks may exit iteration early by explicitly returning false.
+		* @param object The object to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return object
+		**/
+		forOwn<T extends {}>(
+			object: Dictionary<T>,
+			callback?: ObjectIterator<T, void>,
+			thisArg?: any): Dictionary<T>;
+	}
+
+	//_.forOwnRight
+	interface LoDashStatic {
+		/**
+		* This method is like _.forOwn except that it iterates over elements of a collection in the 
+		* opposite order.
+		* @param object The object to iterate over.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		* @return object
+		**/
+		forOwnRight<T extends {}>(
+			object: Dictionary<T>,
+			callback?: ObjectIterator<T, void>,
+			thisArg?: any): Dictionary<T>;
+	}
+
+	//_.functions
+	interface LoDashStatic {
+		/**
+		* Creates a sorted array of property names of all enumerable properties, own and inherited, of 
+		* object that have function values.
+		* @param object The object to inspect.
+		* @return An array of property names that have function values.
+		**/
+		functions(object: any): string[];
+
+			/**
+			* @see _functions
+			**/
+			methods(object: any): string[];
+	}
+
+	//_.has
+	interface LoDashStatic {
+		/**
+		* Checks if the specified object property exists and is a direct property, instead of an 
+		* inherited property.
+		* @param object The object to check.
+		* @param property The property to check for.
+		* @return True if key is a direct property, else false.
+		**/
+		has(object: any, property: string): boolean;
+	}
+
+	//_.invert
+	interface LoDashStatic {
+		/**
+		* Creates an object composed of the inverted keys and values of the given object.
+		* @param object The object to invert.
+		* @return The created inverted object.
+		**/
+		invert(object: any): any;
+	}
+
+	//_.isArguments
+	interface LoDashStatic {
+		/**
+		* Checks if value is an arguments object.
+		* @param value The value to check.
+		* @return True if the value is an arguments object, else false.
+		**/
+		isArguments(value: any): boolean;
+	}
+
+	//_.isArray
+	interface LoDashStatic {
+		/**
+		* Checks if value is an array.
+		* @param value The value to check.
+		* @return True if the value is an array, else false.
+		**/
+		isArray(value: any): boolean;
+	}
+
+	//_.isBoolean
+	interface LoDashStatic {
+		/**
+		* Checks if value is a boolean value.
+		* @param value The value to check.
+		* @return True if the value is a boolean value, else false.
+		**/
+		isBoolean(value: any): boolean;
+	}
+
+	//_.isDate
+	interface LoDashStatic {
+		/**
+		* Checks if value is a date.
+		* @param value The value to check.
+		* @return True if the value is a date, else false.
+		**/
+		isDate(value: any): boolean;
+	}
+
+	//_.isElement
+	interface LoDashStatic {
+		/**
+		* Checks if value is a DOM element.
+		* @param value The value to check.
+		* @return True if the value is a DOM element, else false.
+		**/
+		isElement(value: any): boolean;
+	}
+
+	//_.isEmpty
+	interface LoDashStatic {
+		/**
+		* Checks if value is empty. Arrays, strings, or arguments objects with a length of 0 and objects 
+		* with no own enumerable properties are considered "empty".
+		* @param value The value to inspect.
+		* @return True if the value is empty, else false.
+		**/
+		isEmpty(value: any[]): boolean;
+
+		/**
+		* @see _.isEmpty
+		**/
+		isEmpty(value: Dictionary<any>): boolean;
+
+		/**
+		* @see _.isEmpty
+		**/
+		isEmpty(value: string): boolean;
+	}
+
+	//_.isEqual
+	interface LoDashStatic {
+		/**
+		* Performs a deep comparison between two values to determine if they are equivalent to each 
+		* other. If a callback is provided it will be executed to compare values. If the callback 
+		* returns undefined comparisons will be handled by the method instead. The callback is bound to 
+		* thisArg and invoked with two arguments; (a, b).
+		* @param a The value to compare.
+		* @param b The other value to compare.
+		* @param callback The function to customize comparing values.
+		* @param thisArg The this binding of callback.
+		* @return True if the values are equivalent, else false.
+		**/
+		isEqual(
+			a: any,
+			b: any,
+			callback?: (a, b) => boolean,
+			thisArg?: any): boolean;
+	}
+
+	//_.isFinite
+	interface LoDashStatic {
+		/**
+		* Checks if value is, or can be coerced to, a finite number.
+		*
+		* Note: This is not the same as native isFinite which will return true for booleans and empty 
+		* strings. See http://es5.github.io/#x15.1.2.5.
+		* @param value The value to check.
+		* @return True if the value is finite, else false.
+		**/
+		isFinite(value: any): boolean;
+	}
+
+	//_.isFunction
+	interface LoDashStatic {
+		/**
+		* Checks if value is a function.
+		* @param value The value to check.
+		* @return True if the value is a function, else false.
+		**/
+		isFunction(value: any): boolean;
+	}
+
+	//_.isNaN
+	interface LoDashStatic {
+		/**
+		* Checks if value is NaN.
+		*
+		* Note: This is not the same as native isNaN which will return true for undefined and other 
+		* non-numeric values. See http://es5.github.io/#x15.1.2.4.
+		* @param value The value to check.
+		* @return True if the value is NaN, else false.
+		**/
+		isNaN(value: any): boolean;
+	}
+
+	//_.isNull
+	interface LoDashStatic {
+		/**
+		* Checks if value is null.
+		* @param value The value to check.
+		* @return True if the value is null, else false.
+		**/
+		isNull(value: any): boolean;
+	}
+
+	//_.isNumber
+	interface LoDashStatic {
+		/**
+		* Checks if value is a number.
+		*
+		* Note: NaN is considered a number. See http://es5.github.io/#x8.5.
+		* @param value The value to check.
+		* @return True if the value is a number, else false.
+		**/
+		isNumber(value: any): boolean;
+	}
+
+	//_.isObject
+	interface LoDashStatic {
+		/**
+		* Checks if value is the language type of Object. (e.g. arrays, functions, objects, regexes, 
+		* new Number(0), and new String(''))
+		* @param value The value to check.
+		* @return True if the value is an object, else false.
+		**/
+		isObject(value: any): boolean;
+	}
+
+	//_.isPlainObject
+	interface LoDashStatic {
+		/**
+		* Checks if value is an object created by the Object constructor.
+		* @param value The value to check.
+		* @return True if value is a plain object, else false.
+		**/
+		isPlainObject(value: any): boolean;
+	}
+
+	//_.isRegExp
+	interface LoDashStatic {
+		/**
+		* Checks if value is a regular expression.
+		* @param value The value to check.
+		* @return True if the value is a regular expression, else false.
+		**/
+		isRegExp(value: any): boolean;
+	}
+
+	//_.isString
+	interface LoDashStatic {
+		/**
+		* Checks if value is a string.
+		* @param value The value to check.
+		* @return True if the value is a string, else false.
+		**/
+		isString(value: any): boolean;
+	}
+
+	//_.isUndefined
+	interface LoDashStatic {
+		/**
+		* Checks if value is undefined.
+		* @param value The value to check.
+		* @return True if the value is undefined, else false.
+		**/
+		isUndefined(value: any): boolean;
+	}
+
+	//_.keys
+	interface LoDashStatic {
+		/**
+		* Creates an array composed of the own enumerable property names of an object.
+		* @param object The object to inspect.
+		* @return An array of property names.
+		**/
+		keys(object: any): string[];
+	}
+
+	//_.merge
+	interface LoDashStatic {
+		/**
+		* Recursively merges own enumerable properties of the source object(s), that don't resolve 
+		* to undefined into the destination object. Subsequent sources will overwrite property 
+		* assignments of previous sources. If a callback is provided it will be executed to produce 
+		* the merged values of the destination and source properties. If the callback returns undefined 
+		* merging will be handled by the method instead. The callback is bound to thisArg and invoked 
+		* with two arguments; (objectValue, sourceValue).
+		* @param object The destination object.
+		* @param s1-8 The source object(s)
+		* @param callback The function to customize merging properties.
+		* @param thisArg The this binding of callback.
+		* @return The destination object.
+		**/
+		merge(
+			object: any,
+			s1: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			s3: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			s7: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+
+		/**
+		* @see _.merge
+		**/
+		merge(
+			object: any,
+			s1: any,
+			s2: any,
+			s3: any,
+			s4: any,
+			s5: any,
+			s6: any,
+			s7: any,
+			s8: any,
+			callback?: (objectValue: any, sourceValue: any) => any,
+			thisArg?: any): any;
+	}
+
+	//_.omit
+	interface LoDashStatic {
+		/**
+		* Creates a shallow clone of object excluding the specified properties. Property names may be 
+		* specified as individual arguments or as arrays of property names. If a callback is provided 
+		* it will be executed for each property of object omitting the properties the callback returns 
+		* truey for. The callback is bound to thisArg and invoked with three arguments; (value, key, 
+		* object).
+		* @param object The source object.
+		* @param keys The properties to omit.
+		* @return An object without the omitted properties.
+		**/
+		omit(
+			object: any,
+			...keys: string[]): any;
+
+		/**
+		* @see _.omit
+		**/
+		omit(
+			object: any,
+			keys: string[]): any;	
+
+		/**
+		* @see _.omit
+		**/
+		omit<T>(
+			object: any,
+			callback: ObjectIterator<T, boolean>,
+			thisArg?: any): any;
+	}
+
+	//_.pairs
+	interface LoDashStatic {
+		/**
+		* Creates a two dimensional array of an object’s key-value pairs, 
+		* i.e. [[key1, value1], [key2, value2]].
+		* @param object The object to inspect.
+		* @return Aew array of key-value pairs.
+		**/
+		pairs(object: any): any[][];
+	}
+
+	//_.picks
+	interface LoDashStatic {
+		/**
+		* Creates a shallow clone of object composed of the specified properties. Property names may be 
+		* specified as individual arguments or as arrays of property names. If a callback is provided 
+		* it will be executed for each property of object picking the properties the callback returns 
+		* truey for. The callback is bound to thisArg and invoked with three arguments; (value, key, 
+		* object).
+		* @param object Object to strip unwanted key/value pairs.
+		* @param keys Property names to pick
+		* @return An object composed of the picked properties.
+		**/
+		pick(
+			object: any,
+			...keys: string[]): any;
+
+		/**
+		* @see _.pick
+		**/
+		pick(
+			object: any,
+			keys: string[]): any;
+
+		/**
+		* @see _.pick
+		**/
+		pick(
+			object: any,
+			callback: ObjectIterator<any, boolean>,
+			thisArg?: any): any;
+	}
+
+	//_.transform
+	interface LoDashStatic {
+		/**
+		* An alternative to _.reduce this method transforms object to a new accumulator object which is 
+		* the result of running each of its elements through a callback, with each callback execution 
+		* potentially mutating the accumulator object. The callback is bound to thisArg and invoked with 
+		* four arguments; (accumulator, value, key, object). Callbacks may exit iteration early by 
+		* explicitly returning false.
+		* @param collection The collection to iterate over.
+		* @param callback The function called per iteration.
+		* @param accumulator The custom accumulator value.
+		* @param thisArg The this binding of callback.
+		* @return The accumulated value.
+		**/
+		transform<T>(
+			collection: Collection<T>,
+			callback?: MemoIterator<T, any>,
+			accumulator?: any,
+			thisArg?: any): any;
+	}
+
+	//_.values
+	interface LoDashStatic {
+		/**
+		* Creates an array composed of the own enumerable property values of object.
+		* @param object The object to inspect.
+		* @return Returns an array of property values.
+		**/
+		values(object: any): any[];
+	}
+
+	/*************
+	 * Utilities *
+	 *************/
+	//_.escape
+	interface LoDashStatic {
+		/**
+		* Converts the characters &, <, >, ", and ' in string to their corresponding HTML entities.
+		* @param string The string to escape.
+		* @return The escaped string.
+		**/
+		escape(str: string): string;
+	}
+
+	//_.identity
+	interface LoDashStatic {
+		/**
+		* This method returns the first argument provided to it.
+		* @param value Any value.
+		* @return value.
+		**/
+		identity<T>(value: T): T;
+	}
+
+	//_.mixin
+	interface LoDashStatic {
+		/**
+		* Adds function properties of a source object to the lodash function and chainable wrapper.
+		* @param object The object of function properties to add to lodash.
+		**/
+		mixin(object: Dictionary<(value: any) => any>): void;
+	}
+
+	//_.noConflict
+	interface LoDashStatic {
+		/**
+		* Reverts the '_' variable to its previous value and returns a reference to the lodash function.
+		* @return The lodash function.
+		**/
+		noConflict(): typeof _;
+	}
+
+	//_.parseInt
+	interface LoDashStatic {
+		/**
+		* Converts the given value into an integer of the specified radix. If radix is undefined or 0 a 
+		* radix of 10 is used unless the value is a hexadecimal, in which case a radix of 16 is used.
+		*
+		* Note: This method avoids differences in native ES3 and ES5 parseInt implementations. See 
+		* http://es5.github.io/#E.
+		* @param value The value to parse.
+		* @param radix The radix used to interpret the value to parse.
+		* @return The new integer value.
+		**/
+		parseInt(value: string): number;
+	}
+
+	//_.random
+	interface LoDashStatic {
+		/**
+		* Produces a random number between min and max (inclusive). If only one argument is provided a 
+		* number between 0 and the given number will be returned. If floating is truey or either min or 
+		* max are floats a floating-point number will be returned instead of an integer.
+		* @param max The maximum possible value.
+		* @param floating Specify returning a floating-point number.
+		* @return A random number.
+		**/
+		random(max: number, floating?: boolean): number;
+	
+		/**
+		* @see _.random
+		* @param min The minimum possible value.
+		* @return A random number between `min` and `max`.
+		**/
+		random(min: number, max: number, floating?: boolean): number;
+	}
+
+	//_.result
+	interface LoDashStatic {
+		/**
+		* Resolves the value of property on object. If property is a function it will be invoked with 
+		* the this binding of object and its result returned, else the property value is returned. If 
+		* object is falsey then undefined is returned.
+		* @param object The object to inspect.
+		* @param property The property to get the value of.
+		* @return The resolved value.
+		**/
+		result(object: any, property: string): any;
+	}
+
+	//_.runInContext
+	interface LoDashStatic {
+		/**
+		* Create a new lodash function using the given context object.
+		* @param context The context object
+		* @returns The lodash function.
+		**/
+		runInContext(context: any): typeof _;
+	}
+
+	//_.template
+	interface LoDashStatic {
+		/**
+		* A micro-templating method that handles arbitrary delimiters, preserves whitespace, and 
+		* correctly escapes quotes within interpolated code.
+		*
+		* Note: In the development build, _.template utilizes sourceURLs for easier debugging. See 
+		* http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+		*
+		* For more information on precompiling templates see:
+		* http://lodash.com/#custom-builds
+		*
+		* For more information on Chrome extension sandboxes see:
+		* http://developer.chrome.com/stable/extensions/sandboxingEval.html
+		* @param text The template text.
+		* @param data The data object used to populate the text.
+		* @param options The options object.
+		* @param options.escape The "escape" delimiter.
+		* @param options.evaluate The "evaluate" delimiter.
+		* @param options.import An object to import into the template as local variables.
+		* @param options.interpolate The "interpolate" delimiter.
+		* @param sourceURL The sourceURL of the template’s compiled source.
+		* @param variable The data object variable name.
+		* @return Returns the compiled Lo-Dash HTML template or a TemplateExecutor if no data is passed.
+		**/
+		template(
+			text: string): TemplateExecutor;
+		
+		/**
+		* @see _.template
+		**/
+		template(
+			text: string,
+			data: any, 
+			options?: TemplateSettings,
+			sourceURL?: string,
+			variable?: string): any /* string or TemplateExecutor*/;
+	}
+
 	interface TemplateExecutor {
 		(...data: any[]): string;
 		source: string;
 	}
+		
+	//_.times
+	interface LoDashStatic {
+		/**
+		* Executes the callback n times, returning an array of the results of each callback execution. 
+		* The callback is bound to thisArg and invoked with one argument; (index).
+		* @param n The number of times to execute the callback.
+		* @param callback The function called per iteration.
+		* @param thisArg The this binding of callback.
+		**/
+		times<TResult>(
+			n: number, 
+			callback: Function, 
+			context?: any): TResult[];
+	}
+
+	//_.unescape
+	interface LoDashStatic {
+		/**
+		* The inverse of _.escape this method converts the HTML entities &amp;, <, &gt;, &quot;, and 
+		* &#39; in string to their corresponding characters.
+		* @param string The string to unescape.
+		* @return The unescaped string.
+		**/
+		unescape(
+			string: string): string;
+	}
+
+	//_.uniqueId
+	interface LoDashStatic {
+		/**
+		* Generates a unique ID. If prefix is provided the ID will be appended to it.
+		* @param prefix The value to prefix the ID with.
+		* @return Returns the unique ID.
+		**/
+		uniqueId(prefix?: string): string;
+	}
 
 	interface ListIterator<T, TResult> {
 		(value: T, index: number, list: T[]): TResult;
@@ -212,3209 +3771,4 @@ declare module _ {
 	interface Dictionary<T> extends Collection<T> {
 		[index: string]: T;
 	}
-
-	/*********
-	* Chaining *
-	**********/
-
-	//Wrapper Array methods
-	interface LoDashWrapper<T> {
-		concat(...items: any[]): LoDashWrapper<T>;
-		join(seperator?: string): LoDashWrapper<string>;
-		pop(): LoDashWrapper<any>;
-		push(...items: any[]): void;
-		reverse(): LoDashWrapper<T>;
-		shift(): LoDashWrapper<any>;
-		slice(start: number, end?: number): LoDashWrapper<T>;
-		sort(compareFn?: (a: any, b: any) => number): LoDashWrapper<T>;
-		splice(start: number): LoDashWrapper<T>;
-		splice(start: number, deleteCount: number, ...items: any[]): LoDashWrapper<T>;
-		unshift(...items: any[]): LoDashWrapper<number>;
-	}
-	
-	/**
-	* Creates a lodash object that wraps the given value with explicit method chaining enabled.
-	* @param value The value to wrap.
-	* @return The wrapper object.
-	**/
-	export function chain<T>(value: T): LoDashWrapper<T>;
-
-	/**
-	* @see _.chain
-	**/
-	export function chain<T>(value: Array<T>): LoDashWrapper<Array<T>>;	
-
-		interface LoDashWrapper<T> {
-			/**
-			* Enables explicit method chaining on the wrapper object.
-			* @see _.chain
-			* @return The wrapper object.
-			**/
-			chain(): LoDashWrapper<T>;
-		}
-
-	/**
-	* Invokes interceptor with the value as the first argument and then returns value. The 
-	* purpose of this method is to "tap into" a method chain in order to perform operations on 
-	* intermediate results within the chain.
-	* @param value The value to provide to interceptor
-	* @param interceptor The function to invoke.
-	* @return value
-	**/
-	export function tap<T>(
-		value: T,
-		interceptor: (value: T) => void): T;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.tap
-			**/
-			tap(interceptor: (value: T) => void): LoDashWrapper<T>;
-		}
-
-	interface LoDashWrapper<T> {
-		/**
-		* Produces the toString result of the wrapped value.
-		* @return Returns the string result.
-		**/
-		toString(): string;
-
-		/**
-		* Extracts the wrapped value.
-		* @return The wrapped value.
-		**/
-		valueOf(): T;
-
-			/**
-			* @see valueOf
-			**/
-			value(): T;
-	}
-
-	/*********
-	* Arrays *
-	**********/
-
-	/**
-	* Returns a copy of the array with all falsy values removed. In JavaScript, false, null, 0, "",
-	* undefined and NaN are all falsy.
-	* @param array Array to compact.
-	* @return (Array) Returns a new array of filtered values.
-	**/
-	export function compact<T>(array: List<T>): T[];
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.compact
-			**/
-			compact<T>(): LoDashWrapper<T[]>;
-		}
-
-	/**
-	* Creates an array excluding all values of the provided arrays using strict equality for comparisons
-	* , i.e. ===.
-	* @param array The array to process
-	* @param others The arrays of values to exclude.
-	* @return Returns a new array of filtered values.
-	**/
-	export function difference<T>(
-		array: List<T>,
-		...others: List<T>[]): T[];
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.difference
-			**/
-			difference(
-				...others: List<any>[]): LoDashWrapper<any[]>;
-		}
-
-	/**
-	* @see _.rest
-	**/
-	export function drop<T>(
-		array: List<T>,
-		callback: (num: number) => boolean,
-		thisArg?: any): T[];
-	export function drop<T>(
-		array: List<T>,
-		n?: number,
-		thisArg?: any): T[];
-	export function drop<T>(
-		array: List<T>,
-		pluckValue: string,
-		thisArg?: any): T[];
-	export function drop<T>(
-		array: List<T>,
-		whereValue: Dictionary<any>,
-		thisArg?: any): T[];
-
-	/**
-	* This method is like _.find except that it returns the index of the first element that passes 
-	* the callback check, instead of the element itself.
-	* @param array The array to search.
-	* @param {(Function|Object|string)} callback The function called per iteration. If a property name or object is provided it will be 
-	* used to create a ".pluck" or ".where" style callback, respectively.
-	* @param thisArg The this binding of callback.
-	* @return Returns the index of the found element, else -1.
-	**/
-	export function findIndex<T>(
-		array: List<T>,
-		callback: ListIterator<T, boolean>,
-		thisArg?: any): number;
-	export function findIndex<T>(
-		array: List<T>,
-		pluckValue: string,
-		thisArg?: any): number;
-	export function findIndex<T>(
-		array: List<T>,
-		whereDictionary: Dictionary<any>,
-		thisArg?: any): number;
-
-	/**
-	* This method is like _.findIndex except that it iterates over elements of a collection from right to left.
-	* @param array The array to search.
-	* @param {(Function|Object|string)} callback The function called per iteration. If a property name or object is provided it will be 
-	* used to create a ".pluck" or ".where" style callback, respectively.
-	* @param thisArg The this binding of callback.
-	* @return Returns the index of the found element, else -1.
-	**/
-	export function findLastIndex<T>(
-		array: List<T>,
-		callback: ListIterator<T, boolean>,
-		thisArg?: any): number;
-	export function findLastIndex<T>(
-		array: List<T>,
-		pluckValue: string): number;
-	export function findLastIndex<T>(
-		array: List<T>,
-		whereDictionary: Dictionary<any>): number;
-
-	/**
-	* Gets the first element or first n elements of an array. If a callback is provided 
-	* elements at the beginning of the array are returned as long as the callback returns 
-	* truey. The callback is bound to thisArg and invoked with three arguments; (value, 
-	* index, array).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback 
-	* will return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return ]
-	* true for elements that have the properties of the given object, else false.
-	* @param array Retrieves the first element of this array.
-	* @return Returns the first element of `array`.
-	**/
-	export function first<T>(array: List<T>): T;
-
-	/**
-	* @see _.first
-	* @param n The number of elements to return.
-	**/
-	export function first<T>(
-		array: List<T>,
-		n: number): T[];
-
-	/**
-	* @see _.first
-	* @param callback The function called per element.
-	* @param [thisArg] The this binding of callback.
-	**/
-	export function first<T>(
-		array: List<T>,
-		callback: ListIterator<T, boolean>,
-		thisArg?: any): T[];
-
-	/**
-	* @see _.first
-	* @param pluckValue "_.pluck" style callback value
-	**/
-	export function first<T>(
-		array: List<T>,
-		pluckValue: string): T[];
-
-	/**
-	* @see _.first
-	* @param whereValue "_.where" style callback value
-	**/
-	export function first<T>(
-		array: List<T>,
-		whereValue: Dictionary<string>): T[];
-
-	/**
-	* @see _.first
-	**/
-	export function take<T>(array: List<T>): T;
-
-	/**
-	* @see _.first
-	**/
-	export function take<T>(
-		array: List<T>,
-		n: number): T[];
-
-	/**
-	* @see _.first
-	**/
-	export function take<T>(
-		array: List<T>,
-		callback: ListIterator<T, boolean>,
-		thisArg?: any): T[];
-
-	/**
-	* @see _.first
-	**/
-	export function take<T>(
-		array: List<T>,
-		pluckValue: string): T[];
-
-	/**
-	* @see _.first
-	**/
-	export function take<T>(
-		array: List<T>,
-		whereValue: Dictionary<string>): T[];
-	
-	/**
-	* Flattens a nested array (the nesting can be to any depth). If isShallow is truey, the 
-	* array will only be flattened a single level. If a callback is provided each element of 
-	* the array is passed through the callback before flattening. The callback is bound to 
-	* thisArg and invoked with three arguments; (value, index, array).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false.
-	* @param array The array to flatten.
-	* @param shallow If true then only flatten one level, optional, default = false.
-	* @return `array` flattened.
-	**/
-	export function flatten(
-		array: List<any>,
-		isShallow?,
-		callback?: ListIterator<any, any>,
-		thisArg?: any): any[];
-
-		interface LoDashWrapper<T> {
-			flatten(
-				isShallow?,
-				callback?: ListIterator<any, any>,
-				thisArg?: any): any[];
-		}
-
-	/**
-	* @see _.first
-	**/
-	export function head<T>(array: List<T>): T;
-
-	/**
-	* @see _.first
-	**/
-	export function head<T>(
-		array: List<T>,
-		n: number): T[];
-
-	/**
-	* @see _.first
-	**/
-	export function head<T>(
-		array: List<T>,
-		callback: ListIterator<T, boolean>,
-		thisArg?: any): T[];
-
-	/**
-	* @see _.first
-	**/
-	export function head<T>(
-		array: List<T>,
-		pluckValue: string): T[];
-
-	/**
-	* @see _.first
-	**/
-	export function head<T>(
-		array: List<T>,
-		whereValue: Dictionary<string>): T[];
-
-	/**
-	* Gets the index at which the first occurrence of value is found using strict equality 
-	* for comparisons, i.e. ===. If the array is already sorted providing true for fromIndex 
-	* will run a faster binary search.
-	* @param array The array to search.
-	* @param value The value to search for.
-	* @param fromIndex The index to search from.
-	* @return The index of `value` within `array`.
-	**/
-	export function indexOf<T>(
-		array: List<T>,
-		value: T): number;
-
-	/**
-	* @see _.indexOf
-	* @param fromIndex The index to search from
-	**/
-	export function indexOf<T>(
-		array: List<T>,
-		value: T,
-		fromIndex: number): number;
-
-	/**
-	* @see _.indexOf
-	* @param isSorted True to perform a binary search on a sorted array.
-	**/
-	export function indexOf<T>(
-		array: List<T>,
-		value: T,
-		isSorted: boolean): number;
-
-	/**
-	* Gets all but the last element or last n elements of an array. If a callback is provided 
-	* elements at the end of the array are excluded from the result as long as the callback 
-	* returns truey. The callback is bound to thisArg and invoked with three arguments; 
-	* (value, index, array).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false.
-	* @param array The array to query.
-	* @param n Leaves this many elements behind, optional.
-	* @return Returns everything but the last `n` elements of `array`.
-	**/
-	export function initial<T>(
-		array: List<T>): T[];
-
-	/**
-	* @see _.initial
-	* @param n The number of elements to exclude.
-	**/
-	export function initial<T>(
-		array: List<T>,
-		n: number): T[];
-
-	/**
-	* @see _.initial
-	* @param callback The function called per element
-	**/
-	export function initial<T>(
-		array: List<T>,
-		callback: ListIterator<T, boolean>): T[];
-
-	/**
-	* @see _.initial
-	* @param pluckValue _.pluck style callback
-	**/
-	export function initial<T>(
-		array: List<T>,
-		pluckValue: string): T[];
-
-	/**
-	* @see _.initial
-	* @param whereValue _.where style callback
-	**/
-	export function initial<T>(
-		array: List<T>,
-		whereValue: Dictionary<any>): T[];
-
-	/**
-	* Creates an array of unique values present in all provided arrays using strict 
-	* equality for comparisons, i.e. ===.
-	* @param arrays The arrays to inspect.
-	* @return Returns an array of composite values.
-	**/
-	export function intersection<T>(...arrays: List<T>[]): T[];
-
-	/**
-	* Gets the last element or last n elements of an array. If a callback is provided 
-	* elements at the end of the array are returned as long as the callback returns truey. 
-	* The callback is bound to thisArg and invoked with three arguments; (value, index, array).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false.
-	* @param array The array to query.
-	* @return Returns the last element(s) of array.
-	**/
-	export function last<T>(array: List<T>): T;
-
-	/**
-	* @see _.last
-	* @param n The number of elements to return
-	**/
-	export function last<T>(
-		array: List<T>,
-		n: number): T[];
-
-	/**
-	* @see _.last
-	* @param callback The function called per element
-	**/
-	export function last<T>(
-		array: List<T>,
-		callback: ListIterator<T, boolean>,
-		thisArg?: any): T[];
-
-	/**
-	* @see _.last
-	* @param pluckValue _.pluck style callback
-	**/
-	export function last<T>(
-		array: List<T>,
-		pluckValue: string): T[];
-
-	/**
-	* @see _.last
-	* @param whereValue _.where style callback
-	**/
-	export function last<T>(
-		array: List<T>,
-		whereValue: Dictionary<any>): T[];
-
-	/**
-	* Gets the index at which the last occurrence of value is found using strict equality 
-	* for comparisons, i.e. ===. If fromIndex is negative, it is used as the offset from the 
-	* end of the collection.
-	* @param array The array to search.
-	* @param value The value to search for.
-	* @param fromIndex The index to search from.
-	* @return The index of the matched value or -1.
-	**/
-	export function lastIndexOf<T>(
-		array: List<T>,
-		value: T,
-		fromIndex?: number): number;
-
-	/**
-	* Creates an object composed from arrays of keys and values. Provide either a single 
-	* two dimensional array, i.e. [[key1, value1], [key2, value2]] or two arrays, one of 
-	* keys and one of corresponding values.
-	* @param keys The array of keys.
-	* @param values The array of values.
-	* @return An object composed of the given keys and corresponding values.
-	**/
-	export function zipObject<TResult extends {}>(
-		keys: List<string>,
-		values: List<any>): TResult;
-
-	/**
-	* @see _.object
-	**/
-	export function object<TResult extends {}>(
-		keys: List<string>,
-		values: List<any>): TResult;
-
-	/**
-	* Converts arrays into objects. Pass either a single list of [key, value] pairs, or a
-	* list of keys, and a list of values.
-	* @param keyValuePairs Array of [key, value] pairs.
-	* @return An object containing the `keys` as properties and `values` as the property values.
-	**/
-	export function object<TResult extends {}>(...keyValuePairs: any[][]): TResult;
-
-	/**
-	* @see _.object
-	**/
-	export function object<TResult extends {}>(
-		list: List<any>,
-		values?: any): TResult;
-
-	/**
-	* Removes all provided values from the given array using strict equality for comparisons, 
-	* i.e. ===.
-	* @param array The array to modify.
-	* @param values The values to remove.
-	* @return array.
-	**/
-	export function pull(
-		array: List<any>,
-		...values: any[]): any[];
-
-	/**
-	* Creates an array of numbers (positive and/or negative) progressing from start up 
-	* to but not including end. If start is less than stop a zero-length range is created 
-	* unless a negative step is specified.
-	* @param start The start of the range.
-	* @param end The end of the range.
-	* @param step The value to increment or decrement by.
-	* @return Returns a new range array.
-	**/
-
-	export function range(
-		start: number,
-		stop: number,
-		step?: number): number[];
-	
-	/**
-	* @see _.range
-	* @param end The end of the range.
-	* @return Returns a new range array.
-	* @note If start is not specified the implementation will never pull the step (step = arguments[2] || 0)
-	**/
-	export function range(stop: number): number[];
-
-	/**
-	* Removes all elements from an array that the callback returns truey for and returns 
-	* an array of removed elements. The callback is bound to thisArg and invoked with three 
-	* arguments; (value, index, array).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false.
-	* @param array The array to modify.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return A new array of removed elements.
-	**/
-	export function remove(
-		array: List<any>,
-		callback?: ListIterator<any, boolean>,
-		thisArg?: any): any[];
-
-	/**
-	* @see _.remove
-	* @param pluckValue _.pluck style callback
-	**/
-	export function remove(
-		array: List<any>,
-		pluckValue?: string): any[];
-
-	/**
-	* @see _.remove
-	* @param whereValue _.where style callback
-	**/
-	export function remove(
-		array: List<any>,
-		wherealue?: Dictionary<any>): any[];
-
-	/**
-	* The opposite of _.initial this method gets all but the first element or first n elements of 
-	* an array. If a callback function is provided elements at the beginning of the array are excluded 
-	* from the result as long as the callback returns truey. The callback is bound to thisArg and 
-	* invoked with three arguments; (value, index, array).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will return 
-	* the property value of the given element.
-	* 
-	* If an object is provided for callback the created "_.where" style callback will return true 
-	* for elements that have the properties of the given object, else false.
-	* @param array The array to query.
-	* @param {(Function|Object|number|string)} [callback=1] The function called per element or the number 
-	* of elements to exclude. If a property name or object is provided it will be used to create a 
-	* ".pluck" or ".where" style callback, respectively.
-	* @param {*} [thisArg] The this binding of callback.
-	* @return Returns a slice of array.
-	**/
-	export function rest<T>(
-		array: List<T>,
-		callback: (num: number) => boolean,
-		thisArg?: any): T[];
-	export function rest<T>(
-		array: List<T>,
-		n?: number,
-		thisArg?: any): T[];
-	export function rest<T>(
-		array: List<T>,
-		pluckValue: string,
-		thisArg?: any): T[];
-	export function rest<T>(
-		array: List<T>,
-		whereValue: Dictionary<any>,
-		thisArg?: any): T[];
-
-	/**
-	* @see _.rest
-	**/
-	export function tail<T>(
-		array: List<T>,
-		callback: (num: number) => boolean,
-		thisArg?: any): T[];
-	export function tail<T>(
-		array: List<T>,
-		n?: number,
-		thisArg?: any): T[];
-	export function tail<T>(
-		array: List<T>,
-		pluckValue: string,
-		thisArg?: any): T[];
-	export function tail<T>(
-		array: List<T>,
-		whereValue: Dictionary<any>,
-		thisArg?: any): T[];
-
-	/**
-	* Uses a binary search to determine the smallest index at which a value should be inserted 
-	* into a given sorted array in order to maintain the sort order of the array. If a callback 
-	* is provided it will be executed for value and each element of array to compute their sort 
-	* ranking. The callback is bound to thisArg and invoked with one argument; (value).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false.
-	* @param array The sorted list.
-	* @param value The value to determine its index within `list`.
-	* @param callback Iterator to compute the sort ranking of each value, optional.
-	* @return The index at which value should be inserted into array.
-	**/
-	export function sortedIndex<T, TSort>(
-		array: List<T>,
-		value: T,
-		callback?: (x: T) => TSort, 
-		thisArg?: any): number;
-
-	/**
-	* @see _.sortedIndex
-	* @param pluckValue the _.pluck style callback
-	**/
-	export function sortedIndex<T, TSort>(
-		array: List<T>,
-		value: T,
-		pluckValue: string): number;
-
-	/**
-	* @see _.sortedIndex
-	* @param pluckValue the _.where style callback
-	**/
-	export function sortedIndex<T, TSort>(
-		array: List<T>,
-		value: T,
-		whereValue: Dictionary<any>): number;
-
-	/**
-	* Creates an array of unique values, in order, of the provided arrays using strict 
-	* equality for comparisons, i.e. ===.
-	* @param arrays The arrays to inspect.
-	* @return Returns an array of composite values.
-	**/
-	export function union<T>(...arrays: List<T>[]): T[];
-
-	/**
-	* Creates a duplicate-value-free version of an array using strict equality for comparisons, 
-	* i.e. ===. If the array is sorted, providing true for isSorted will use a faster algorithm. 
-	* If a callback is provided each element of array is passed through the callback before 
-	* uniqueness is computed. The callback is bound to thisArg and invoked with three arguments; 
-	* (value, index, array).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false.
-	* @param array Array to remove duplicates from.
-	* @param isSorted True if `array` is already sorted, optiona, default = false.
-	* @param iterator Transform the elements of `array` before comparisons for uniqueness.
-	* @param context 'this' object in `iterator`, optional.
-	* @return Copy of `array` where all elements are unique.
-	**/
-	export function uniq<T, TSort>(
-		array: List<T>,
-		isSorted?: boolean,
-		callback?: ListIterator<T, TSort>,
-		thisArg?: any): T[];
-
-	/**
-	* @see _.uniq
-	**/
-	export function uniq<T, TSort>(
-		array: List<T>,
-		callback?: ListIterator<T, TSort>,
-		thisArg?: any): T[];
-
-	/**
-	* @see _.uniq
-	* @param pluckValue _.pluck style callback
-	**/
-	export function uniq<T, TSort>(
-		array: List<T>,
-		isSorted?: boolean,
-		pluckValue?: string): T[];
-
-	/**
-	* @see _.uniq
-	* @param whereValue _.where style callback
-	**/
-	export function uniq<T, TSort>(
-		array: List<T>,
-		whereValue?: Dictionary<any>): T[];
-
-	/**
-	* @see _.uniq
-	**/
-	export function unique<T, TSort>(
-		array: List<T>,
-		callback?: ListIterator<T, TSort>,
-		thisArg?: any): T[];
-
-	/**
-	* @see _.uniq
-	**/
-	export function unique<T, TSort>(
-		array: List<T>,
-		isSorted?: boolean,
-		callback?: ListIterator<T, TSort>,
-		thisArg?: any): T[];
-
-	/**
-	* @see _.uniq
-	* @param pluckValue _.pluck style callback
-	**/
-	export function unique<T, TSort>(
-		array: List<T>,
-		isSorted?: boolean,
-		pluckValue?: string): T[];
-
-	/**
-	* @see _.uniq
-	* @param whereValue _.where style callback
-	**/
-	export function unique<T, TSort>(
-		array: List<T>,
-		whereValue?: Dictionary<any>): T[];
-
-	/**
-	* Creates an array of grouped elements, the first of which contains the first 
-	* elements of the given arrays, the second of which contains the second elements 
-	* of the given arrays, and so on.
-	* @param arrays Arrays to process.
-	* @return A new array of grouped elements.
-	**/
-	export function zip(...arrays: any[][]): any[][];
-
-	/**
-	* @see _.zip
-	**/
-	export function zip(...arrays: any[]): any[];
-
-	/**
-	* @see _.zip
-	**/
-	export function unzip(...arrays: any[][]): any[][];
-
-	/**
-	* @see _.zip
-	**/
-	export function unzip(...arrays: any[]): any[];
-
-	/**
-	* Creates an array excluding all provided values using strict equality for comparisons, i.e. ===.
-	* @param array The array to filter.
-	* @param values The value(s) to exclude.
-	* @return A new array of filtered values.
-	**/
-	export function without<T>(
-		array: List<T>,
-		...values: T[]): T[];
-
-	/* *************
-	 * Collections *
-	 ************* */
-
-	/**
-	* Creates an array of elements from the specified indexes, or keys, of the collection. 
-	* Indexes may be specified as individual arguments or as arrays of indexes.
-	* @param collection The collection to iterate over.
-	* @param indexes The indexes of collection to retrieve, specified as individual indexes or 
-	* arrays of indexes.
-	* @return A new array of elements corresponding to the provided indexes.
-	**/
-	export function at<T>(
-		collection: Collection<T>,
-		indexes: number[]): T[];
-
-	/**
-	* @see _.at
-	**/
-	export function at<T>(
-		collection: Collection<T>,
-		...indexes: number[]): T[];
-
-	/**
-	* Checks if a given value is present in a collection using strict equality for comparisons, 
-	* i.e. ===. If fromIndex is negative, it is used as the offset from the end of the collection.
-	* @param collection The collection to iterate over.
-	* @param target The value to check for.
-	* @param fromIndex The index to search from.
-	* @return True if the target element is found, else false.
-	**/
-	export function contains<T>(
-		collection: Collection<T>,
-		target: T,
-		fromIndex?: number): boolean;
-
-	/**
-	* @see _.contains
-	* @param dictionary The dictionary to iterate over.
-	* @param key The key in the dictionary to search for.
-	**/
-	export function contains<T>(
-		dictionary: Dictionary<T>,
-		key: string,
-		fromIndex?: number): boolean;
-
-	/**
-	* @see _.contains
-	* @param searchString the string to search
-	* @param targetString the string to search for
-	**/
-	export function contains(
-		searchString: string,
-		targetString: string,
-		fromIndex?: number): boolean;
-
-		/**
-		* @see _.contains
-		**/
-		export function include<T>(
-			collection: Collection<T>,
-			target: T,
-			fromIndex?: number): boolean;
-
-		/**
-		* @see _.contains
-		**/
-		export function include<T>(
-			dictionary: Dictionary<T>,
-			key: string,
-			fromIndex?: number): boolean;
-
-		/**
-		* @see _.contains
-		**/
-		export function include(
-			searchString: string,
-			targetString: string,
-			fromIndex?: number): boolean;
-	
-	/**
-	* Creates an object composed of keys generated from the results of running each element 
-	* of collection through the callback. The corresponding value of each key is the number 
-	* of times the key was returned by the callback. The callback is bound to thisArg and 
-	* invoked with three arguments; (value, index|key, collection).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return Returns the composed aggregate object.
-	**/
-	export function countBy<T>(
-		collection: Collection<T>,
-		callback?: ListIterator<T, any>,
-		thisArg?: any): Dictionary<number>;
-
-	/**
-	* @see _.countBy
-	* @param callback Function name
-	**/
-	export function countBy<T>(
-		collection: Collection<T>,
-		callback: string,
-		thisArg?: any): Dictionary<number>;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.countBy
-			**/
-			countBy<T>(
-				callback?: ListIterator<T, any>,
-				thisArg?: any): LoDashWrapper<Dictionary<number>>;
-
-			/**
-			* @see _.countBy
-			* @param callback Function name
-			**/
-			countBy<T>(
-				callback: string,
-				thisArg?: any): LoDashWrapper<Dictionary<number>>;
-		}
-
-	/**
-	* Checks if the given callback returns truey value for all elements of a collection. 
-	* The callback is bound to thisArg and invoked with three arguments; (value, index|key, 
-	* collection).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return True if all elements passed the callback check, else false.
-	**/
-	export function every<T>(
-		collection: Collection<T>,
-		callback?: ListIterator<T, boolean>,
-		thisArg?: any): boolean;
-
-	/**
-	* @see _.every
-	* @param pluckValue _.pluck style callback
-	**/
-	export function every<T>(
-		collection: Collection<T>,
-		pluckValue: string): boolean;
-
-	/**
-	* @see _.every
-	* @param whereValue _.where style callback
-	**/
-	export function every<T>(
-		collection: Collection<T>,
-		whereValue: Dictionary<any>): boolean;
-
-		/**
-		* @see _.every
-		**/
-		export function all<T>(
-			collection: Collection<T>,
-			callback?: ListIterator<T, boolean>,
-			thisArg?: any): boolean;
-
-		/**
-		* @see _.every
-		* @param pluckValue _.pluck style callback
-		**/
-		export function all<T>(
-			collection: Collection<T>,
-			pluckValue: string): boolean;
-
-		/**
-		* @see _.every
-		* @param whereValue _.where style callback
-		**/
-		export function all<T>(
-			collection: Collection<T>,
-			whereValue: Dictionary<any>): boolean;
-
-	/**
-	* Iterates over elements of a collection, returning an array of all elements the 
-	* callback returns truey for. The callback is bound to thisArg and invoked with three 
-	* arguments; (value, index|key, collection).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param context The this binding of callback.
-	* @return Returns a new array of elements that passed the callback check.
-	**/
-	export function filter<T>(
-		collection: Collection<T>,
-		callback: ListIterator<T, boolean>,
-		thisArg?: any): T[];
-
-	/**
-	* @see _.filter
-	* @param pluckValue _.pluck style callback
-	**/
-	export function filter<T>(
-		collection: Collection<T>,
-		pluckValue: string): T[];
-
-	/**
-	* @see _.filter
-	* @param pluckValue _.pluck style callback
-	**/
-	export function filter<T>(
-		collection: Collection<T>,
-		whereValue: Dictionary<any>): T[];
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.filter
-			**/
-			filter<T>(
-				callback: ListIterator<T, boolean>,
-				thisArg?: any): T[];
-
-			/**
-			* @see _.filter
-			* @param pluckValue _.pluck style callback
-			**/
-			filter<T>(
-				pluckValue: string): T[];
-
-			/**
-			* @see _.filter
-			* @param pluckValue _.pluck style callback
-			**/
-			filter<T>(
-				whereValue: Dictionary<any>): T[];
-		}
-
-		/**
-		* @see _.filter
-		**/
-		export function select<T>(
-		collection: Collection<T>,
-		callback: ListIterator<T, boolean>,
-		thisArg?: any): T[];
-
-		/**
-		* @see _.filter
-		* @param pluckValue _.pluck style callback
-		**/
-		export function select<T>(
-			collection: Collection<T>,
-			pluckValue: string): T[];
-
-		/**
-		* @see _.filter
-		* @param pluckValue _.pluck style callback
-		**/
-		export function select<T>(
-			collection: Collection<T>,
-			whereValue: Dictionary<any>): T[];
-
-			interface LoDashWrapper<T> {
-				/**
-				* @see _.filter
-				**/
-				select<T>(
-					callback: ListIterator<T, boolean>,
-					thisArg?: any): T[];
-
-				/**
-				* @see _.filter
-				* @param pluckValue _.pluck style callback
-				**/
-				select<T>(
-					pluckValue: string): T[];
-
-				/**
-				* @see _.filter
-				* @param pluckValue _.pluck style callback
-				**/
-				select<T>(
-					whereValue: Dictionary<any>): T[];
-			}
-
-	/**
-	* Iterates over elements of a collection, returning the first element that the callback 
-	* returns truey for. The callback is bound to thisArg and invoked with three arguments; 
-	* (value, index|key, collection).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false.
-	* @param collection Searches for a value in this list.
-	* @param callback The function called per iteration. 
-	* @param thisArg The this binding of callback.
-	* @return The found element, else undefined.
-	**/
-	export function find<T>(
-		collection: Collection<T>,
-		callback: ListIterator<T, boolean>,
-		thisArg?: any): T;
-
-	/**
-	* @see _.find
-	* @param _.pluck style callback
-	**/
-	export function find<T>(
-		collection: Collection<T>,
-		whereValue: Dictionary<any>): T;
-
-	/**
-	* @see _.find
-	* @param _.where style callback
-	**/
-	export function find<T>(
-		collection: Collection<T>,
-		pluckValue: string): T;
-
-		/**
-		* @see _.find
-		**/
-		export function detect<T>(
-			collection: Collection<T>,
-			callback: ListIterator<T, boolean>,
-			thisArg?: any): T;
-
-		/**
-		* @see _.find
-		* @param _.pluck style callback
-		**/
-		export function detect<T>(
-			collection: Collection<T>,
-			whereValue: Dictionary<any>): T;
-
-		/**
-		* @see _.find
-		* @param _.where style callback
-		**/
-		export function detect<T>(
-			collection: Collection<T>,
-			pluckValue: string): T;
-
-		/**
-		* @see _.find
-		**/
-		export function findWhere<T>(
-			collection: Collection<T>,
-			callback: ListIterator<T, boolean>,
-			thisArg?: any): T;
-
-		/**
-		* @see _.find
-		* @param _.pluck style callback
-		**/
-		export function findWhere<T>(
-			collection: Collection<T>,
-			whereValue: Dictionary<any>): T;
-
-		/**
-		* @see _.find
-		* @param _.where style callback
-		**/
-		export function findWhere<T>(
-			collection: Collection<T>,
-			pluckValue: string): T;
-
-	/**
-	* This method is like _.find except that it iterates over elements of a collection from 
-	* right to left.
-	* @param collection Searches for a value in this list.
-	* @param callback The function called per iteration. 
-	* @param thisArg The this binding of callback.
-	* @return The found element, else undefined.
-	**/
-	export function findLast<T>(
-		collection: Collection<T>,
-		callback: ListIterator<T, boolean>,
-		thisArg?: any): T;
-
-	/**
-	* @see _.find
-	* @param _.pluck style callback
-	**/
-	export function findLast<T>(
-		collection: Collection<T>,
-		whereValue: Dictionary<any>): T;
-
-	/**
-	* @see _.find
-	* @param _.where style callback
-	**/
-	export function findLast<T>(
-		collection: Collection<T>,
-		pluckValue: string): T;
-
-	/**
-	* Iterates over elements of a collection, executing the callback for each element. 
-	* The callback is bound to thisArg and invoked with three arguments; (value, index|key, 
-	* collection). Callbacks may exit iteration early by explicitly returning false.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	**/
-	export function forEach<T>(
-		collection: List<T>,
-		callback: ListIterator<T, void >,
-		thisArg?: any): List<T>;
-
-	/**
-	* @see _.each
-	**/
-	export function forEach<T extends {}>(
-		object: Dictionary<T>,
-		callback: ObjectIterator<T, void >,
-		thisArg?: any): Dictionary<T>;
-
-		/**
-		* @see _.each
-		**/
-		export function each<T>(
-			collection: List<T>,
-			callback: ListIterator<T, void>,
-			thisArg?: any): List<T>;
-
-		/**
-		* @see _.each
-		* @param object The object to iterate over
-		* @param callback The function called per iteration.
-		* @param thisArg The this binding of callback.
-		**/
-		export function each<T extends {}>(
-			object: Dictionary<T>,
-			callback: ObjectIterator<T, void>,
-			thisArg?: any): Dictionary<T>;
-
-	/**
-	* This method is like _.forEach except that it iterates over elements of a 
-	* collection from right to left.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	**/
-	export function forEachRight<T>(
-		collection: List<T>,
-		callback: ListIterator<T, void >,
-		thisArg?: any): List<T>;
-
-	/**
-	* @see _.each
-	**/
-	export function forEachRight<T extends {}>(
-		object: Dictionary<T>,
-		callback: ObjectIterator<T, void >,
-		thisArg?: any): Dictionary<T>;
-
-		/**
-		* @see _.each
-		**/
-		export function eachRight<T>(
-			collection: List<T>,
-			callback: ListIterator<T, void>,
-			thisArg?: any): List<T>;
-
-		/**
-		* @see _.each
-		* @param object The object to iterate over
-		* @param callback The function called per iteration.
-		* @param thisArg The this binding of callback.
-		**/
-		export function eachRight<T extends {}>(
-			object: Dictionary<T>,
-			callback: ObjectIterator<T, void>,
-			thisArg?: any): Dictionary<T>;
-
-	/**
-	* Creates an object composed of keys generated from the results of running each element 
-	* of a collection through the callback. The corresponding value of each key is an array 
-	* of the elements responsible for generating the key. The callback is bound to thisArg 
-	* and invoked with three arguments; (value, index|key, collection).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return Returns the composed aggregate object.
-	**/
-	export function groupBy<T>(
-		collection: List<T>,
-		callback?: ListIterator<T, any>,
-		thisArg?: any): Dictionary<T[]>;
-
-	/**
-	* @see _.groupBy
-	* @param pluckValue _.pluck style callback
-	**/
-	export function groupBy<T>(
-		collection: List<T>,
-		pluckValue: string): Dictionary<T[]>;
-
-	/**
-	* @see _.groupBy
-	* @param whereValue _.where style callback
-	**/
-	export function groupBy<T>(
-		collection: List<T>,
-		whereValue: Dictionary<any>): Dictionary<T[]>;
-
-	/**
-	* Creates an object composed of keys generated from the results of running each element 
-	* of the collection through the given callback. The corresponding value of each key is 
-	* the last element responsible for generating the key. The callback is bound to thisArg 
-	* and invoked with three arguments; (value, index|key, collection).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return Returns the composed aggregate object.
-	**/
-	export function indexBy<T>(
-		list: List<T>,
-		iterator: ListIterator<T, any>,
-		context?: any): Dictionary<T>;
-
-	/**
-	* @see _.indexBy
-	* @param pluckValue _.pluck style callback
-	**/
-	export function indexBy<T>(
-		collection: List<T>,
-		pluckValue: string): Dictionary<T>;
-
-	/**
-	* @see _.indexBy
-	* @param whereValue _.where style callback
-	**/
-	export function indexBy<T>(
-		collection: List<T>,
-		whereValue: Dictionary<any>): Dictionary<T>;
-
-	/**
-	* Invokes the method named by methodName on each element in the collection returning 
-	* an array of the results of each invoked method. Additional arguments will be provided 
-	* to each invoked method. If methodName is a function it will be invoked for, and this 
-	* bound to, each element in the collection.
-	* @param collection The collection to iterate over.
-	* @param methodName The name of the method to invoke.
-	* @param args Arguments to invoke the method with.
-	**/
-	export function invoke<T extends {}>(
-		collection: Collection<T>,
-		methodName: string,
-		...args: any[]): any;
-
-	/**
-	* @see _.invoke
-	**/
-	export function invoke<T extends {}>(
-		collection: Collection<T>,
-		method: Function,
-		...args: any[]): any;
-
-	/**
-	* Creates an array of values by running each element in the collection through the callback. 
-	* The callback is bound to thisArg and invoked with three arguments; (value, index|key, 
-	* collection).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will return 
-	* the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return true 
-	* for elements that have the properties of the given object, else false.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param theArg The this binding of callback.
-	* @return The mapped array result.
-	**/
-	export function map<T, TResult>(
-		collection: List<T>,
-		callback: ListIterator<T, TResult>,
-		thisArg?: any): TResult[];
-
-	/**
-	* @see _.map
-	* @param object The object to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg `this` object in `iterator`, optional.
-	* @return The mapped object result.
-	**/
-	export function map<T extends {}, TResult>(
-		object: Dictionary<T>,
-		callback: ObjectIterator<T, TResult>,
-		thisArg?: any): TResult[];
-
-	/**
-	* @see _.map
-	* @param pluckValue _.pluck style callback
-	**/
-	export function map<T, TResult>(
-		collection: List<T>,
-		pluckValue: string): TResult[];
-
-			/**
-			* @see _.map
-			**/
-			export function collect<T, TResult>(
-				collection: List<T>,
-				callback: ListIterator<T, TResult>,
-				thisArg?: any): TResult[];
-
-			/**
-			* @see _.map
-			**/
-			export function collect<T extends {}, TResult>(
-				object: Dictionary<T>,
-				callback: ObjectIterator<T, TResult>,
-				thisArg?: any): TResult[];
-
-			/**
-			* @see _.map
-			**/
-			export function collect<T, TResult>(
-				collection: List<T>,
-				pluckValue: string): TResult[];
-
-	/**
-	* Retrieves the maximum value of a collection. If the collection is empty or falsey -Infinity is 
-	* returned. If a callback is provided it will be executed for each value in the collection to 
-	* generate the criterion by which the value is ranked. The callback is bound to thisArg and invoked 
-	* with three arguments; (value, index, collection).
-	* 
-	* If a property name is provided for callback the created "_.pluck" style callback will return the 
-	* property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return true for 
-	* elements that have the properties of the given object, else false.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return Returns the maximum value.
-	**/
-	export function max<T>(
-		collection: Collection<T>,
-		callback?: ListIterator<T, any>,
-		thisArg?: any): T;
-
-	/**
-	* @see _.max
-	* @param pluckValue _.pluck style callback
-	**/
-	export function max<T>(
-		collection: Collection<T>,
-		pluckValue: string): T;
-
-	/**
-	* @see _.max
-	* @param whereValue _.where style callback
-	**/
-	export function max<T>(
-		collection: Collection<T>,
-		whereValue: Dictionary<any>): T;
-
-	/**
-	* Retrieves the minimum value of a collection. If the collection is empty or falsey 
-	* Infinity is returned. If a callback is provided it will be executed for each value 
-	* in the collection to generate the criterion by which the value is ranked. The callback 
-	* is bound to thisArg and invoked with three arguments; (value, index, collection).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback 
-	* will return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will 
-	* return true for elements that have the properties of the given object, else false.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return Returns the maximum value.
-	**/
-	export function min<T>(
-		collection: Collection<T>,
-		callback?: ListIterator<T, any>,
-		thisArg?: any): T;
-
-	/**
-	* @see _.min
-	* @param pluckValue _.pluck style callback
-	**/
-	export function min<T>(
-		collection: Collection<T>,
-		pluckValue: string): T;
-
-	/**
-	* @see _.min
-	* @param whereValue _.where style callback
-	**/
-	export function min<T>(
-		collection: Collection<T>,
-		whereValue: Dictionary<any>): T;
-
-	/**
-	* Retrieves the value of a specified property from all elements in the collection.
-	* @param collection The collection to iterate over.
-	* @param property The property to pluck.
-	* @return A new array of property values.
-	**/
-	export function pluck<T extends {}>(
-		collection: Collection<T>,
-		property: string): any[];
-
-	/**
-	* Reduces a collection to a value which is the accumulated result of running each 
-	* element in the collection through the callback, where each successive callback execution 
-	* consumes the return value of the previous execution. If accumulator is not provided the 
-	* first element of the collection will be used as the initial accumulator value. The callback 
-	* is bound to thisArg and invoked with four arguments; (accumulator, value, index|key, collection).
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param accumulator Initial value of the accumulator.
-	* @param thisArg The this binding of callback.
-	* @return Returns the accumulated value.
-	**/
-	export function reduce<T, TResult>(
-		collection: Collection<T>,
-		callback: MemoIterator<T, TResult>,
-		accumulator?: TResult,
-		thisArg?: any): TResult;
-
-		/**
-		* @see _.reduce
-		**/
-		export function inject<T, TResult>(
-			collection: Collection<T>,
-			callback: MemoIterator<T, TResult>,
-			accumulator?: TResult,
-			thisArg?: any): TResult;
-
-		/**
-		* @see _.reduce
-		**/
-		export function foldl<T, TResult>(
-			collection: Collection<T>,
-			callback: MemoIterator<T, TResult>,
-			accumulator?: TResult,
-			thisArg?: any): TResult;
-
-	/**
-	* This method is like _.reduce except that it iterates over elements of a collection from 
-	* right to left.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param accumulator Initial value of the accumulator.
-	* @param thisArg The this binding of callback.
-	* @return The accumulated value.
-	**/
-	export function reduceRight<T, TResult>(
-		collection: Collection<T>,
-		callback: MemoIterator<T, TResult>,
-		accumulator?: TResult,
-		thisArg?: any): TResult;
-
-		/**
-		* @see _.reduceRight
-		**/
-		export function foldr<T, TResult>(
-			collection: Collection<T>,
-			callback: MemoIterator<T, TResult>,
-			accumulator?: TResult,
-			thisArg?: any): TResult;
-
-	/**
-	* The opposite of _.filter this method returns the elements of a collection that 
-	* the callback does not return truey for.
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback 
-	* will return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will 
-	* return true for elements that have the properties of the given object, else false.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return A new array of elements that failed the callback check.
-	**/
-	export function reject<T>(
-		collection: Collection<T>,
-		callback: ListIterator<T, boolean>,
-		thisArg?: any): T[];
-
-	/**
-	* @see _.reject
-	* @param pluckValue _.pluck style callback
-	**/
-	export function reject<T>(
-		collection: Collection<T>,
-		pluckValue: string): T[];
-
-	/**
-	* @see _.reject
-	* @param whereValue _.where style callback
-	**/
-	export function reject<T>(
-		collection: Collection<T>,
-		whereValue: Dictionary<any>): T[];
-
-	/**
-	* Retrieves a random element or n random elements from a collection.
-	* @param collection The collection to sample.
-	* @return Returns the random sample(s) of collection.
-	**/
-	export function sample<T>(collection: Collection<T>): T;
-
-	/**
-	* @see _.sample
-	* @param n The number of elements to sample.
-	**/
-	export function sample<T>(collection: Collection<T>, n: number): T[];
-
-	/**
-	* Creates an array of shuffled values, using a version of the Fisher-Yates shuffle. 
-	* See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.
-	* @param collection The collection to shuffle.
-	* @return Returns a new shuffled collection.
-	**/
-	export function shuffle<T>(collection: Collection<T>): T[];
-
-	/**
-	* Gets the size of the collection by returning collection.length for arrays and array-like 
-	* objects or the number of own enumerable properties for objects.
-	* @param collection The collection to inspect.
-	* @return collection.length
-	**/
-	export function size<T>(collection: List<T>): number;
-
-	/**
-	* @see _.size
-	* @param object The object to inspect
-	* @return The number of own enumerable properties.
-	**/
-	export function size<T extends {}>(object: T): number;
-
-	/**
-	* @see _.size
-	* @param aString The string to inspect
-	* @return The length of aString
-	**/
-	export function size(aString: string): number;
-
-	/**
-	* Checks if the callback returns a truey value for any element of a collection. The function 
-	* returns as soon as it finds a passing value and does not iterate over the entire collection. 
-	* The callback is bound to thisArg and invoked with three arguments; (value, index|key, collection).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will return 
-	* the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return true for 
-	* elements that have the properties of the given object, else false.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return True if any element passed the callback check, else false.
-	**/
-	export function some<T>(
-		collection: Collection<T>,
-		callback?: ListIterator<T, boolean>,
-		thisArg?: any): boolean;
-
-	/**
-	* @see _.some
-	* @param pluckValue _.pluck style callback
-	**/
-	export function some<T>(
-		collection: Collection<T>,
-		pluckValue: string): boolean;
-
-	/**
-	* @see _.some
-	* @param whereValue _.where style callback
-	**/
-	export function some<T>(
-		collection: Collection<T>,
-		whereValue: Dictionary<any>): boolean;
-
-		/**
-		* @see _.some
-		**/
-		export function any<T>(
-			collection: Collection<T>,
-			callback?: ListIterator<T, boolean>,
-			thisArg?: any): boolean;
-
-		/**
-		* @see _.some
-		* @param pluckValue _.pluck style callback
-		**/
-		export function any<T>(
-			collection: Collection<T>,
-			pluckValue: string): boolean;
-
-		/**
-		* @see _.some
-		* @param whereValue _.where style callback
-		**/
-		export function any<T>(
-			collection: Collection<T>,
-			whereValue: Dictionary<any>): boolean;
-	
-	/**
-	* Creates an array of elements, sorted in ascending order by the results of running each 
-	* element in a collection through the callback. This method performs a stable sort, that 
-	* is, it will preserve the original sort order of equal elements. The callback is bound 
-	* to thisArg and invoked with three arguments; (value, index|key, collection).
-	*
-	* If a property name is provided for callback the created "_.pluck" style callback will 
-	* return the property value of the given element.
-	*
-	* If an object is provided for callback the created "_.where" style callback will return 
-	* true for elements that have the properties of the given object, else false.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return A new array of sorted elements.
-	**/
-	export function sortBy<T, TSort>(
-		collection: List<T>,
-		callback?: ListIterator<T, TSort>,
-		thisArg?: any): T[];
-
-	/**
-	* @see _.sortBy
-	* @param pluckValue _.pluck style callback
-	**/
-	export function sortBy<T>(
-		collection: List<T>,
-		pluckValue: string): T[];
-
-	/**
-	* @see _.sortBy
-	* @param whereValue _.where style callback
-	**/
-	export function sortBy<T>(
-		collection: List<T>,
-		whereValue: Dictionary<any>): T[];
-
-	/**
-	* Converts the collection to an array.
-	* @param collection The collection to convert.
-	* @return The new converted array.
-	**/
-	export function toArray<T>(collection: Collection<T>): T[];
-
-	/**
-	* Performs a deep comparison of each element in a collection to the given properties 
-	* object, returning an array of all elements that have equivalent property values.
-	* @param collection The collection to iterate over.
-	* @param properties The object of property values to filter by.
-	* @return A new array of elements that have the given properties.
-	**/
-	export function where<T, U extends {}>(
-		list: Collection<T>,
-		properties: U): T[];
-
-	/*************
-	 * Functions *
-	 *************/
-
-	 /**
-	* Creates a function that executes func, with the this binding and arguments of the 
-	* created function, only after being called n times.
-	* @param n The number of times the function must be called before func is executed.
-	* @param func The function to restrict.
-	* @return The new restricted function.
-	**/
-	export function after(
-		n: number,
-		func: Function): Function;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.after
-			**/
-			after(func: Function): LoDashWrapper<Function>;
-		}
-
-	/**
-	* Creates a function that, when called, invokes func with the this binding of thisArg 
-	* and prepends any additional bind arguments to those provided to the bound function.
-	* @param func The function to bind.
-	* @param thisArg The this binding of func.
-	* @param args Arguments to be partially applied.
-	* @return The new bound function.
-	**/
-	export function bind(
-		func: Function,
-		thisArg: any,
-		...args: any[]): () => any;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.bind
-			**/
-			bind(
-				thisArg: any,
-				...args: any[]): LoDashWrapper<() => any>;
-		}
-
-	/**
-	* Binds methods of an object to the object itself, overwriting the existing method. Method 
-	* names may be specified as individual arguments or as arrays of method names. If no method 
-	* names are provided all the function properties of object will be bound.
-	* @param object The object to bind and assign the bound methods to.
-	* @param methodNames The object method names to bind, specified as individual method names 
-	* or arrays of method names.
-	* @return object
-	**/
-	export function bindAll(
-		object: any,
-		...methodNames: string[]): any;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.bindAll
-			**/
-			bindAll(...methodNames: string[]): LoDashWrapper<any>;
-		}
-
-	/**
-	* Creates a function that, when called, invokes the method at object[key] and prepends any 
-	* additional bindKey arguments to those provided to the bound function. This method differs 
-	* from _.bind by allowing bound functions to reference methods that will be redefined or don't 
-	* yet exist. See http://michaux.ca/articles/lazy-function-definition-pattern.
-	* @param object The object the method belongs to.
-	* @param key The key of the method.
-	* @param args Arguments to be partially applied.
-	* @return The new bound function.
-	**/
-	export function bindKey(
-		object: any,
-		key: string,
-		...args: any[]): Function;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.bindKey
-			**/
-			bindKey(
-				key: string,
-				...args: any[]): LoDashWrapper<Function>;
-		}
-
-	/**
-	* Creates a function that is the composition of the provided functions, where each function 
-	* consumes the return value of the function that follows. For example, composing the functions 
-	* f(), g(), and h() produces f(g(h())). Each function is executed with the this binding of the 
-	* composed function.
-	* @param funcs Functions to compose.
-	* @return The new composed function.
-	**/
-	export function compose(...funcs: Function[]): Function;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.compose
-			**/
-			compose(...funcs: Function[]): LoDashWrapper<Function>;
-		}
-
-	/**
-	* Produces a callback bound to an optional thisArg. If func is a property name the created 
-	* callback will return the property value for a given element. If func is an object the created 
-	* callback will return true for elements that contain the equivalent object properties, 
-	* otherwise it will return false.
-	* @param func The value to convert to a callback.
-	* @param thisArg The this binding of the created callback.
-	* @param argCount The number of arguments the callback accepts.
-	* @return A callback function.
-	**/
-	export function createCallback(
-		func: string,
-		thisArg?: any,
-		argCount?: number): () => any;
-
-	/**
-	* @see _.createCallback
-	**/
-	export function createCallback(
-		func: Dictionary<any>,
-		thisArg?: any,
-		argCount?: number): () => boolean;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.createCallback
-			**/
-			createCallback(
-				thisArg?: any,
-				argCount?: number): LoDashWrapper<() => any>;
-		}
-
-	/**
-	* Creates a function which accepts one or more arguments of func that when invoked either 
-	* executes func returning its result, if all func arguments have been provided, or returns 
-	* a function that accepts one or more of the remaining func arguments, and so on. The arity 
-	* of func can be specified if func.length is not sufficient.
-	* @param func The function to curry.
-	* @param arity The arity of func.
-	* @return The new curried function.
-	**/
-	export function curry(
-		func: Function,
-		arity?: number): Function;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.curry
-			**/
-			curry(arity?: number): LoDashWrapper<Function>;
-		}
-
-	/**
-	* Creates a function that will delay the execution of func until after wait milliseconds have 
-	* elapsed since the last time it was invoked. Provide an options object to indicate that func 
-	* should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent calls 
-	* to the debounced function will return the result of the last func call.
-	*
-	* Note: If leading and trailing options are true func will be called on the trailing edge of 
-	* the timeout only if the the debounced function is invoked more than once during the wait 
-	* timeout.
-	* @param func The function to debounce.
-	* @param wait The number of milliseconds to delay.
-	* @param options The options object.
-	* @param options.leading Specify execution on the leading edge of the timeout.
-	* @param options.maxWait The maximum time func is allowed to be delayed before it’s called.
-	* @param options.trailing Specify execution on the trailing edge of the timeout.
-	* @return The new debounced function.
-	**/
-	export function debounce(
-		func: Function,
-		wait: number,
-		options?: DebounceSettings): Function;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.debounce
-			**/
-			debounce(
-				wait: number,
-				options?: DebounceSettings): LoDashWrapper<Function>;
-		}
-
-	/**
-	* Defers executing the func function until the current call stack has cleared. Additional 
-	* arguments will be provided to func when it is invoked.
-	* @param func The function to defer.
-	* @param args Arguments to invoke the function with.
-	* @return The timer id.
-	**/
-	export function defer(
-		func: Function,
-		...args: any[]): number;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see 
-			**/
-			defer(...args: any[]): LoDashWrapper<number>;
-		}
-
-	/**
-	* Executes the func function after wait milliseconds. Additional arguments will be provided 
-	* to func when it is invoked.
-	* @param func The function to delay.
-	* @param wait The number of milliseconds to delay execution.
-	* @param args Arguments to invoke the function with.
-	* @return The timer id.
-	**/
-	export function delay(
-		func: Function,
-		wait: number,
-		...args: any[]): number;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.delay
-			**/
-			delay(
-				wait: number,
-				...args: any[]): LoDashWrapper<number>;
-		}
-
-	/**
-	* Creates a function that memoizes the result of func. If resolver is provided it will be 
-	* used to determine the cache key for storing the result based on the arguments provided to 
-	* the memoized function. By default, the first argument provided to the memoized function is 
-	* used as the cache key. The func is executed with the this binding of the memoized function. 
-	* The result cache is exposed as the cache property on the memoized function.
-	* @param func Computationally expensive function that will now memoized results.
-	* @param resolver Hash function for storing the result of `fn`.
-	* @return Returns the new memoizing function.
-	**/
-	export function memoize(
-		func: Function,
-		resolver?: (n: any) => string): Function;
-
-	/**
-	* Creates a function that is restricted to execute func once. Repeat calls to the function 
-	* will return the value of the first call. The func is executed with the this binding of the 
-	* created function.
-	* @param func Function to only execute once.
-	* @return The new restricted function.
-	**/
-	export function once(func: Function): Function;
-
-	/**
-	* Creates a function that, when called, invokes func with any additional partial arguments 
-	* prepended to those provided to the new function. This method is similar to _.bind except 
-	* it does not alter the this binding.
-	* @param func The function to partially apply arguments to.
-	* @param args Arguments to be partially applied.
-	* @return The new partially applied function.
-	**/
-	export function partial(
-		func: Function,
-		...args: any[]): Function;
-
-	/**
-	* This method is like _.partial except that partial arguments are appended to those provided 
-	* to the new function.
-	* @param func The function to partially apply arguments to.
-	* @param args Arguments to be partially applied.
-	* @return The new partially applied function.
-	**/
-	export function partialRight(
-		func: Function,
-		...args: any[]): Function;
-
-	/**
-	* Creates a function that, when executed, will only call the func function at most once per 
-	* every wait milliseconds. Provide an options object to indicate that func should be invoked 
-	* on the leading and/or trailing edge of the wait timeout. Subsequent calls to the throttled 
-	* function will return the result of the last func call.
-	*
-	* Note: If leading and trailing options are true func will be called on the trailing edge of 
-	* the timeout only if the the throttled function is invoked more than once during the wait timeout.
-	* @param func The function to throttle.
-	* @param wait The number of milliseconds to throttle executions to.
-	* @param options The options object.
-	* @param options.leading Specify execution on the leading edge of the timeout.
-	* @param options.trailing Specify execution on the trailing edge of the timeout.
-	* @return The new throttled function.
-	**/
-	export function throttle(
-		func: any,
-		wait: number,
-		options?: ThrottleSettings): Function;
-
-	/**
-	* Creates a function that provides value to the wrapper function as its first argument. 
-	* Additional arguments provided to the function are appended to those provided to the 
-	* wrapper function. The wrapper is executed with the this binding of the created function.
-	* @param value The value to wrap.
-	* @param wrapper The wrapper function.
-	* @return The new function.
-	**/
-	export function wrap(
-		value: any,
-		wrapper: (func: Function, ...args: any[]) => any): Function;
-
-	
-
-	
-
-	
-
-	
-
-	
-
-	/**********
-	* Objects *
-	***********/
-	/**
-	* Assigns own enumerable properties of source object(s) to the destination object. Subsequent 
-	* sources will overwrite property assignments of previous sources. If a callback is provided 
-	* it will be executed to produce the assigned values. The callback is bound to thisArg and 
-	* invoked with two arguments; (objectValue, sourceValue).
-	* @param object The destination object.
-	* @param s1-8 The source object(s)
-	* @param callback The function to customize merging properties.
-	* @param thisArg The this binding of callback.
-	* @return The destination object.
-	**/
-	export function assign(
-		object: any,
-		s1: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.assign
-	**/
-	export function assign(
-		object: any,
-		s1: any,
-		s2: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.assign
-	**/		
-	export function assign(
-		object: any,
-		s1: any,
-		s2: any,
-		s3: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.assign
-	**/
-	export function assign(
-		object: any,
-		s1: any,
-		s2: any,
-		s3: any,
-		s4: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.assign
-	**/
-	export function assign(
-		object: any,
-		s1: any,
-		s2: any,
-		s3: any,
-		s4: any,
-		s5: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.assign
-	**/
-	export function assign(
-		object: any,
-		s1: any,
-		s2: any,
-		s3: any,
-		s4: any,
-		s5: any,
-		s6: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.assign
-	**/
-	export function assign(
-		object: any,
-		s1: any,
-		s2: any,
-		s3: any,
-		s4: any,
-		s5: any,
-		s6: any,
-		s7: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.assign
-	**/
-	export function assign(
-		object: any,
-		s1: any,
-		s2: any,
-		s3: any,
-		s4: any,
-		s5: any,
-		s6: any,
-		s7: any,
-		s8: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	interface LoDashWrapper<T> {
-		/**
-		* @see _.assign
-		**/
-		assign(
-			s1: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.assign
-		**/
-		assign(
-			s1: any,
-			s2: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.assign
-		**/		
-		assign(
-			s1: any,
-			s2: any,
-			s3: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.assign
-		**/
-		assign(
-			s1: any,
-			s2: any,
-			s3: any,
-			s4: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.assign
-		**/
-		assign(
-			s1: any,
-			s2: any,
-			s3: any,
-			s4: any,
-			s5: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.assign
-		**/
-		assign(
-			s1: any,
-			s2: any,
-			s3: any,
-			s4: any,
-			s5: any,
-			s6: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.assign
-		**/
-		assign(
-			s1: any,
-			s2: any,
-			s3: any,
-			s4: any,
-			s5: any,
-			s6: any,
-			s7: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.assign
-		**/
-		assign(
-			s1: any,
-			s2: any,
-			s3: any,
-			s4: any,
-			s5: any,
-			s6: any,
-			s7: any,
-			s8: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-	}
-
-		/**
-		* @see _.extend
-		**/
-		export function extend(
-			object: any,
-			s1: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.extend
-		**/
-		export function extend(
-			object: any,
-			s1: any,
-			s2: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.extend
-		**/				
-		export function extend(
-			object: any,
-			s1: any,
-			s2: any,
-			s3: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.extend
-		**/
-		export function extend(
-			object: any,
-			s1: any,
-			s2: any,
-			s3: any,
-			s4: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.extend
-		**/
-		export function extend(
-			object: any,
-			s1: any,
-			s2: any,
-			s3: any,
-			s4: any,
-			s5: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.extend
-		**/
-		export function extend(
-			object: any,
-			s1: any,
-			s2: any,
-			s3: any,
-			s4: any,
-			s5: any,
-			s6: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.extend
-		**/
-		export function extend(
-			object: any,
-			s1: any,
-			s2: any,
-			s3: any,
-			s4: any,
-			s5: any,
-			s6: any,
-			s7: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-		/**
-		* @see _.extend
-		**/
-		export function extend(
-			object: any,
-			s1: any,
-			s2: any,
-			s3: any,
-			s4: any,
-			s5: any,
-			s6: any,
-			s7: any,
-			s8: any,
-			callback?: (objectValue: any, sourceValue: any) => any,
-			thisArg?: any): any;
-
-			interface LoDashWrapper<T> {
-				/**
-				* @see _.assign
-				**/
-				extend(
-					s1: any,
-					callback?: (objectValue: any, sourceValue: any) => any,
-					thisArg?: any): any;
-
-				/**
-				* @see _.assign
-				**/
-				extend(
-					s1: any,
-					s2: any,
-					callback?: (objectValue: any, sourceValue: any) => any,
-					thisArg?: any): any;
-
-				/**
-				* @see _.assign
-				**/		
-				extend(
-					s1: any,
-					s2: any,
-					s3: any,
-					callback?: (objectValue: any, sourceValue: any) => any,
-					thisArg?: any): any;
-
-				/**
-				* @see _.assign
-				**/
-				extend(
-					s1: any,
-					s2: any,
-					s3: any,
-					s4: any,
-					callback?: (objectValue: any, sourceValue: any) => any,
-					thisArg?: any): any;
-
-				/**
-				* @see _.assign
-				**/
-				extend(
-					s1: any,
-					s2: any,
-					s3: any,
-					s4: any,
-					s5: any,
-					callback?: (objectValue: any, sourceValue: any) => any,
-					thisArg?: any): any;
-
-				/**
-				* @see _.assign
-				**/
-				extend(
-					s1: any,
-					s2: any,
-					s3: any,
-					s4: any,
-					s5: any,
-					s6: any,
-					callback?: (objectValue: any, sourceValue: any) => any,
-					thisArg?: any): any;
-
-				/**
-				* @see _.assign
-				**/
-				extend(
-					s1: any,
-					s2: any,
-					s3: any,
-					s4: any,
-					s5: any,
-					s6: any,
-					s7: any,
-					callback?: (objectValue: any, sourceValue: any) => any,
-					thisArg?: any): any;
-
-				/**
-				* @see _.assign
-				**/
-				extend(
-					s1: any,
-					s2: any,
-					s3: any,
-					s4: any,
-					s5: any,
-					s6: any,
-					s7: any,
-					s8: any,
-					callback?: (objectValue: any, sourceValue: any) => any,
-					thisArg?: any): any;
-			}
-
-	/**
-	* Creates a clone of value. If deep is true nested objects will also be cloned, otherwise 
-	* they will be assigned by reference. If a callback is provided it will be executed to produce 
-	* the cloned values. If the callback returns undefined cloning will be handled by the method 
-	* instead. The callback is bound to thisArg and invoked with one argument; (value).
-	* @param value The value to clone.
-	* @param deep Specify a deep clone.
-	* @param callback The function to customize cloning values.
-	* @param thisArg The this binding of callback.
-	* @return The cloned value.
-	**/
-	export function clone<T>(
-		value: T,
-		deep?: boolean,
-		callback?: (value: any) => any,
-		thisArg?: any): T;
-
-	/**
-	* Creates a deep clone of value. If a callback is provided it will be executed to produce the 
-	* cloned values. If the callback returns undefined cloning will be handled by the method instead. 
-	* The callback is bound to thisArg and invoked with one argument; (value).
-	*
-	* Note: This method is loosely based on the structured clone algorithm. Functions and DOM nodes 
-	* are not cloned. The enumerable properties of arguments objects and objects created by constructors 
-	* other than Object are cloned to plain Object objects. 
-	* See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.
-	* @param value The value to clone.
-	* @param callback The function to customize cloning values.
-	* @param thisArg The this binding of callback.
-	* @return The cloned value.
-	**/
-	export function cloneDeep<T>(
-		value: T,
-		callback?: (value: any) => any,
-		thisArg?: any): T;
-
-	/**
-	* Assigns own enumerable properties of source object(s) to the destination object for all 
-	* destination properties that resolve to undefined. Once a property is set, additional defaults 
-	* of the same property will be ignored.
-	* @param object The destination object.
-	* @param sources The source objects.
-	* @return The destination object.
-	**/
-	export function defaults(
-		object: any,
-		...sources: any[]): any;
-
-		interface LoDashWrapper<T> {
-			/**
-			* @see _.defaults
-			**/
-			defaults(...sources: any[]): LoDashWrapper<any>
-		}
-
-	/**
-	* This method is like _.findIndex except that it returns the key of the first element that 
-	* passes the callback check, instead of the element itself.
-	* @param object The object to search.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return The key of the found element, else undefined.
-	**/
-	export function findKey(
-		object: any,
-		callback: (value: any) => boolean,
-		thisArg?: any): string;
-
-	/**
-	* @see _.findKey
-	* @param pluckValue _.pluck style callback
-	**/
-	export function findKey(
-		object: any,
-		pluckValue: string): string;
-
-	/**
-	* @see _.findKey
-	* @param whereValue _.where style callback
-	**/
-	export function findKey(
-		object: any,
-		whereValue: Dictionary<any>): string;
-
-	/**
-	* This method is like _.findKey except that it iterates over elements of a collection in the opposite order.
-	* @param object The object to search.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return The key of the found element, else undefined.
-	**/
-	export function findLastKey(
-		object: any,
-		callback: (value: any) => boolean,
-		thisArg?: any): string;
-
-	/**
-	* @see _.findLastKey
-	* @param pluckValue _.pluck style callback
-	**/
-	export function findLastKey(
-		object: any,
-		pluckValue: string): string;
-
-	/**
-	* @see _.findLastKey
-	* @param whereValue _.where style callback
-	**/
-	export function findLastKey(
-		object: any,
-		whereValue: Dictionary<any>): string;
-
-	/**
-	* Iterates over own and inherited enumerable properties of an object, executing the callback for 
-	* each property. The callback is bound to thisArg and invoked with three arguments; (value, key, 
-	* object). Callbacks may exit iteration early by explicitly returning false.
-	* @param object The object to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return object
-	**/
-	export function forIn<T extends {}>(
-		object: Dictionary<T>,
-		callback?: ObjectIterator<T, void>,
-		thisArg?: any): Dictionary<T>;
-
-	/**
-	* This method is like _.forIn except that it iterates over elements of a collection in the 
-	* opposite order.
-	* @param object The object to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return object
-	**/
-	export function forInRight<T extends {}>(
-		object: Dictionary<T>,
-		callback?: ObjectIterator<T, void>,
-		thisArg?: any): Dictionary<T>;
-
-	/**
-	* Iterates over own enumerable properties of an object, executing the callback for each 
-	* property. The callback is bound to thisArg and invoked with three arguments; (value, key, 
-	* object). Callbacks may exit iteration early by explicitly returning false.
-	* @param object The object to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return object
-	**/
-	export function forOwn<T extends {}>(
-		object: Dictionary<T>,
-		callback?: ObjectIterator<T, void>,
-		thisArg?: any): Dictionary<T>;
-
-	/**
-	* This method is like _.forOwn except that it iterates over elements of a collection in the 
-	* opposite order.
-	* @param object The object to iterate over.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	* @return object
-	**/
-	export function forOwnRight<T extends {}>(
-		object: Dictionary<T>,
-		callback?: ObjectIterator<T, void>,
-		thisArg?: any): Dictionary<T>;
-
-	/**
-	* Creates a sorted array of property names of all enumerable properties, own and inherited, of 
-	* object that have function values.
-	* @param object The object to inspect.
-	* @return An array of property names that have function values.
-	**/
-	export function functions(object: any): string[];
-
-		/**
-		* @see _functions
-		**/
-		export function methods(object: any): string[];
-
-	/**
-	* Checks if the specified object property exists and is a direct property, instead of an 
-	* inherited property.
-	* @param object The object to check.
-	* @param property The property to check for.
-	* @return True if key is a direct property, else false.
-	**/
-	export function has(object: any, property: string): boolean;
-
-	/**
-	* Creates an object composed of the inverted keys and values of the given object.
-	* @param object The object to invert.
-	* @return The created inverted object.
-	**/
-	export function invert(object: any): any;
-
-	/**
-	* Checks if value is an arguments object.
-	* @param value The value to check.
-	* @return True if the value is an arguments object, else false.
-	**/
-	export function isArguments(value: any): boolean;
-
-	/**
-	* Checks if value is an array.
-	* @param value The value to check.
-	* @return True if the value is an array, else false.
-	**/
-	export function isArray(value: any): boolean;
-
-	/**
-	* Checks if value is a boolean value.
-	* @param value The value to check.
-	* @return True if the value is a boolean value, else false.
-	**/
-	export function isBoolean(value: any): boolean;
-
-	/**
-	* Checks if value is a date.
-	* @param value The value to check.
-	* @return True if the value is a date, else false.
-	**/
-	export function isDate(value: any): boolean;
-
-	/**
-	* Checks if value is a DOM element.
-	* @param value The value to check.
-	* @return True if the value is a DOM element, else false.
-	**/
-	export function isElement(value: any): boolean;
-
-	/**
-	* Checks if value is empty. Arrays, strings, or arguments objects with a length of 0 and objects 
-	* with no own enumerable properties are considered "empty".
-	* @param value The value to inspect.
-	* @return True if the value is empty, else false.
-	**/
-	export function isEmpty(value: any[]): boolean;
-
-	/**
-	* @see _.isEmpty
-	**/
-	export function isEmpty(value: Dictionary<any>): boolean;
-
-	/**
-	* @see _.isEmpty
-	**/
-	export function isEmpty(value: string): boolean;
-
-	/**
-	* Performs a deep comparison between two values to determine if they are equivalent to each 
-	* other. If a callback is provided it will be executed to compare values. If the callback 
-	* returns undefined comparisons will be handled by the method instead. The callback is bound to 
-	* thisArg and invoked with two arguments; (a, b).
-	* @param a The value to compare.
-	* @param b The other value to compare.
-	* @param callback The function to customize comparing values.
-	* @param thisArg The this binding of callback.
-	* @return True if the values are equivalent, else false.
-	**/
-	export function isEqual(
-		a: any,
-		b: any,
-		callback?: (a, b) => boolean,
-		thisArg?: any): boolean;
-
-	/**
-	* Checks if value is, or can be coerced to, a finite number.
-	*
-	* Note: This is not the same as native isFinite which will return true for booleans and empty 
-	* strings. See http://es5.github.io/#x15.1.2.5.
-	* @param value The value to check.
-	* @return True if the value is finite, else false.
-	**/
-	export function isFinite(value: any): boolean;
-
-	/**
-	* Checks if value is a function.
-	* @param value The value to check.
-	* @return True if the value is a function, else false.
-	**/
-	export function isFunction(value: any): boolean;
-
-	/**
-	* Checks if value is NaN.
-	*
-	* Note: This is not the same as native isNaN which will return true for undefined and other 
-	* non-numeric values. See http://es5.github.io/#x15.1.2.4.
-	* @param value The value to check.
-	* @return True if the value is NaN, else false.
-	**/
-	export function isNaN(value: any): boolean;
-
-	/**
-	* Checks if value is null.
-	* @param value The value to check.
-	* @return True if the value is null, else false.
-	**/
-	export function isNull(value: any): boolean;
-
-	/**
-	* Checks if value is a number.
-	*
-	* Note: NaN is considered a number. See http://es5.github.io/#x8.5.
-	* @param value The value to check.
-	* @return True if the value is a number, else false.
-	**/
-	export function isNumber(value: any): boolean;
-
-	/**
-	* Checks if value is the language type of Object. (e.g. arrays, functions, objects, regexes, 
-	* new Number(0), and new String(''))
-	* @param value The value to check.
-	* @return True if the value is an object, else false.
-	**/
-	export function isObject(value: any): boolean;
-
-	/**
-	* Checks if value is an object created by the Object constructor.
-	* @param value The value to check.
-	* @return True if value is a plain object, else false.
-	**/
-	export function isPlainObject(value: any): boolean;
-
-	/**
-	* Checks if value is a regular expression.
-	* @param value The value to check.
-	* @return True if the value is a regular expression, else false.
-	**/
-	export function isRegExp(value: any): boolean;
-
-	/**
-	* Checks if value is a string.
-	* @param value The value to check.
-	* @return True if the value is a string, else false.
-	**/
-	export function isString(value: any): boolean;
-
-	/**
-	* Checks if value is undefined.
-	* @param value The value to check.
-	* @return True if the value is undefined, else false.
-	**/
-	export function isUndefined(value: any): boolean;
-
-	/**
-	* Creates an array composed of the own enumerable property names of an object.
-	* @param object The object to inspect.
-	* @return An array of property names.
-	**/
-	export function keys(object: any): string[];
-
-	/**
-	* Recursively merges own enumerable properties of the source object(s), that don't resolve 
-	* to undefined into the destination object. Subsequent sources will overwrite property 
-	* assignments of previous sources. If a callback is provided it will be executed to produce 
-	* the merged values of the destination and source properties. If the callback returns undefined 
-	* merging will be handled by the method instead. The callback is bound to thisArg and invoked 
-	* with two arguments; (objectValue, sourceValue).
-	* @param object The destination object.
-	* @param s1-8 The source object(s)
-	* @param callback The function to customize merging properties.
-	* @param thisArg The this binding of callback.
-	* @return The destination object.
-	**/
-	export function merge(
-		object: any,
-		s1: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.merge
-	**/
-	export function merge(
-		object: any,
-		s1: any,
-		s2: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.merge
-	**/
-	export function merge(
-		object: any,
-		s1: any,
-		s2: any,
-		s3: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.merge
-	**/
-	export function merge(
-		object: any,
-		s1: any,
-		s2: any,
-		s3: any,
-		s4: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.merge
-	**/
-	export function merge(
-		object: any,
-		s1: any,
-		s2: any,
-		s3: any,
-		s4: any,
-		s5: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.merge
-	**/
-	export function merge(
-		object: any,
-		s1: any,
-		s2: any,
-		s3: any,
-		s4: any,
-		s5: any,
-		s6: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.merge
-	**/
-	export function merge(
-		object: any,
-		s1: any,
-		s2: any,
-		s3: any,
-		s4: any,
-		s5: any,
-		s6: any,
-		s7: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* @see _.merge
-	**/
-	export function merge(
-		object: any,
-		s1: any,
-		s2: any,
-		s3: any,
-		s4: any,
-		s5: any,
-		s6: any,
-		s7: any,
-		s8: any,
-		callback?: (objectValue: any, sourceValue: any) => any,
-		thisArg?: any): any;
-
-	/**
-	* Creates a shallow clone of object excluding the specified properties. Property names may be 
-	* specified as individual arguments or as arrays of property names. If a callback is provided 
-	* it will be executed for each property of object omitting the properties the callback returns 
-	* truey for. The callback is bound to thisArg and invoked with three arguments; (value, key, 
-	* object).
-	* @param object The source object.
-	* @param keys The properties to omit.
-	* @return An object without the omitted properties.
-	**/
-	export function omit(
-		object: any,
-		...keys: string[]): any;
-
-	/**
-	* @see _.omit
-	**/
-	export function omit(
-		object: any,
-		keys: string[]): any;	
-
-	/**
-	* @see _.omit
-	**/
-	export function omit<T>(
-		object: any,
-		callback: ObjectIterator<T, boolean>,
-		thisArg?: any): any;
-
-	/**
-	* Creates a two dimensional array of an object’s key-value pairs, 
-	* i.e. [[key1, value1], [key2, value2]].
-	* @param object The object to inspect.
-	* @return Aew array of key-value pairs.
-	**/
-	export function pairs(object: any): any[][];
-
-	/**
-	* Creates a shallow clone of object composed of the specified properties. Property names may be 
-	* specified as individual arguments or as arrays of property names. If a callback is provided 
-	* it will be executed for each property of object picking the properties the callback returns 
-	* truey for. The callback is bound to thisArg and invoked with three arguments; (value, key, 
-	* object).
-	* @param object Object to strip unwanted key/value pairs.
-	* @param keys Property names to pick
-	* @return An object composed of the picked properties.
-	**/
-	export function pick(
-		object: any,
-		...keys: string[]): any;
-
-	/**
-	* @see _.pick
-	**/
-	export function pick(
-		object: any,
-		keys: string[]): any;
-
-	/**
-	* @see _.pick
-	**/
-	export function pick(
-		object: any,
-		callback: ObjectIterator<any, boolean>,
-		thisArg?: any): any;
-	
-	/**
-	* An alternative to _.reduce this method transforms object to a new accumulator object which is 
-	* the result of running each of its elements through a callback, with each callback execution 
-	* potentially mutating the accumulator object. The callback is bound to thisArg and invoked with 
-	* four arguments; (accumulator, value, key, object). Callbacks may exit iteration early by 
-	* explicitly returning false.
-	* @param collection The collection to iterate over.
-	* @param callback The function called per iteration.
-	* @param accumulator The custom accumulator value.
-	* @param thisArg The this binding of callback.
-	* @return The accumulated value.
-	**/
-	export function transform<T>(
-		collection: Collection<T>,
-		callback?: MemoIterator<T, any>,
-		accumulator?: any,
-		thisArg?: any): any;
-
-	/**
-	* Creates an array composed of the own enumerable property values of object.
-	* @param object The object to inspect.
-	* @return Returns an array of property values.
-	**/
-	export function values(object: any): any[];
-
-	/* *********
-	 * Utilities *
-	********** */
-
-	/**
-	* Converts the characters &, <, >, ", and ' in string to their corresponding HTML entities.
-	* @param string The string to escape.
-	* @return The escaped string.
-	**/
-	export function escape(str: string): string;
-
-	/**
-	* This method returns the first argument provided to it.
-	* @param value Any value.
-	* @return value.
-	**/
-	export function identity<T>(value: T): T;
-
-	/**
-	* Adds function properties of a source object to the lodash function and chainable wrapper.
-	* @param object The object of function properties to add to lodash.
-	**/
-	export function mixin(object: Dictionary<(value: any) => any>): void;
-
-	/**
-	* Reverts the '_' variable to its previous value and returns a reference to the lodash function.
-	* @return The lodash function.
-	**/
-	export function noConflict(): typeof _;
-
-	/**
-	* Converts the given value into an integer of the specified radix. If radix is undefined or 0 a 
-	* radix of 10 is used unless the value is a hexadecimal, in which case a radix of 16 is used.
-	*
-	* Note: This method avoids differences in native ES3 and ES5 parseInt implementations. See 
-	* http://es5.github.io/#E.
-	* @param value The value to parse.
-	* @param radix The radix used to interpret the value to parse.
-	* @return The new integer value.
-	**/
-	export function parseInt(value: string): number;
-
-	/**
-	* Produces a random number between min and max (inclusive). If only one argument is provided a 
-	* number between 0 and the given number will be returned. If floating is truey or either min or 
-	* max are floats a floating-point number will be returned instead of an integer.
-	* @param max The maximum possible value.
-	* @param floating Specify returning a floating-point number.
-	* @return A random number.
-	**/
-	export function random(max: number, floating?: boolean): number;
-
-	/**
-	* @see _.random
-	* @param min The minimum possible value.
-	* @return A random number between `min` and `max`.
-	**/
-	export function random(min: number, max: number, floating?: boolean): number;
-
-	/**
-	* Resolves the value of property on object. If property is a function it will be invoked with 
-	* the this binding of object and its result returned, else the property value is returned. If 
-	* object is falsey then undefined is returned.
-	* @param object The object to inspect.
-	* @param property The property to get the value of.
-	* @return The resolved value.
-	**/
-	export function result(object: any, property: string): any;
-
-	/**
-	* Create a new lodash function using the given context object.
-	* @param context The context object
-	* @returns The lodash function.
-	**/
-	export function runInContext(context: any): typeof _;
-
-	/**
-	* A micro-templating method that handles arbitrary delimiters, preserves whitespace, and 
-	* correctly escapes quotes within interpolated code.
-	*
-	* Note: In the development build, _.template utilizes sourceURLs for easier debugging. See 
-	* http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
-	*
-	* For more information on precompiling templates see:
-	* http://lodash.com/#custom-builds
-	*
-	* For more information on Chrome extension sandboxes see:
-	* http://developer.chrome.com/stable/extensions/sandboxingEval.html
-	* @param text The template text.
-	* @param data The data object used to populate the text.
-	* @param options The options object.
-	* @param options.escape The "escape" delimiter.
-	* @param options.evaluate The "evaluate" delimiter.
-	* @param options.import An object to import into the template as local variables.
-	* @param options.interpolate The "interpolate" delimiter.
-	* @param sourceURL The sourceURL of the template’s compiled source.
-	* @param variable The data object variable name.
-	* @return Returns the compiled Lo-Dash HTML template or a TemplateExecutor if no data is passed.
-	**/
-	export function template(
-		text: string): TemplateExecutor;
-
-	/**
-	* @see _.template
-	**/
-	export function template(
-		text: string,
-		data: any, 
-		options?: TemplateSettings,
-		sourceURL?: string,
-		variable?: string): any /* string or TemplateExecutor*/;
-	
-	/**
-	* Executes the callback n times, returning an array of the results of each callback execution. 
-	* The callback is bound to thisArg and invoked with one argument; (index).
-	* @param n The number of times to execute the callback.
-	* @param callback The function called per iteration.
-	* @param thisArg The this binding of callback.
-	**/
-	export function times<TResult>(
-		n: number, 
-		callback: Function, 
-		context?: any): TResult[];
-
-	/**
-	* The inverse of _.escape this method converts the HTML entities &amp;, <, &gt;, &quot;, and 
-	* &#39; in string to their corresponding characters.
-	* @param string The string to unescape.
-	* @return The unescaped string.
-	**/
-	export function unescape(
-		string: string): string;	
-
-	/**
-	* Generates a unique ID. If prefix is provided the ID will be appended to it.
-	* @param prefix The value to prefix the ID with.
-	* @return Returns the unique ID.
-	**/
-	export function uniqueId(prefix?: string): string;
-
-	/**
-	* The semantic version number.
-	**/
-	export var VERSION: string;
-
-	/**
-	* An object used to flag environments features.
-	**/
-	export var support: Support;
-
-	/**
-	* By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby 
-	* (ERB). Change the following template settings to use alternative delimiters.
-	**/
-	export var templateSettings: TemplateSettings;
-}
-
-declare module "lodash" {
-	export = _;
-}
+}
\ No newline at end of file