From 879e47cbe22a3df952ae802a7c5531aed546c72c Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Sat, 31 May 2014 00:27:00 -0400
Subject: [PATCH 01/13] Add lodash omit chainable defs

---
 lodash/lodash-tests.ts |  5 +++++
 lodash/lodash.d.ts     | 21 +++++++++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index 953d32d37..da60a435d 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -877,6 +877,11 @@ result = <HasName>_.omit({ 'name': 'moe', 'age': 40 }, ['age']);
 result = <HasName>_.omit({ 'name': 'moe', 'age': 40 }, function (value) {
     return typeof value == 'number';
 });
+result = <HasName>_({ 'name': 'moe', 'age': 40 }).omit('age');
+result = <HasName>_({ 'name': 'moe', 'age': 40 }).omit(['age']);
+result = <HasName>_({ 'name': 'moe', 'age': 40 }).omit(function (value) {
+    return typeof value == 'number';
+});
 
 result = <any[][]>_.pairs({ 'moe': 30, 'larry': 40 });
 
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index cf227c25e..c363d6806 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -5391,6 +5391,27 @@ declare module _ {
             thisArg?: any): Omitted;
     }
 
+    interface LoDashObjectWrapper<T> {
+        /**
+        * @see _.omit
+        **/
+        omit<Omitted>(
+            ...keys: string[]): Omitted;
+
+        /**
+        * @see _.omit
+        **/
+        omit<Omitted>(
+            keys: string[]): Omitted;
+
+        /**
+        * @see _.omit
+        **/
+        omit<Omitted>(
+            callback: ObjectIterator<any, boolean>,
+            thisArg?: any): Omitted;
+    }
+
     //_.pairs
     interface LoDashStatic {
         /**

From fee014e7b6321ec508855da114e57d0eaec1f04e Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Sat, 31 May 2014 00:36:32 -0400
Subject: [PATCH 02/13] Fix issue with omit chainable definition not returning
 LoDashObjectWrapper

---
 lodash/lodash-tests.ts | 6 +++---
 lodash/lodash.d.ts     | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index da60a435d..8a1170c02 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -877,11 +877,11 @@ result = <HasName>_.omit({ 'name': 'moe', 'age': 40 }, ['age']);
 result = <HasName>_.omit({ 'name': 'moe', 'age': 40 }, function (value) {
     return typeof value == 'number';
 });
-result = <HasName>_({ 'name': 'moe', 'age': 40 }).omit('age');
-result = <HasName>_({ 'name': 'moe', 'age': 40 }).omit(['age']);
+result = <HasName>_({ 'name': 'moe', 'age': 40 }).omit('age').value();
+result = <HasName>_({ 'name': 'moe', 'age': 40 }).omit(['age']).value();
 result = <HasName>_({ 'name': 'moe', 'age': 40 }).omit(function (value) {
     return typeof value == 'number';
-});
+}).value();
 
 result = <any[][]>_.pairs({ 'moe': 30, 'larry': 40 });
 
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index c363d6806..ab579457a 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -5396,20 +5396,20 @@ declare module _ {
         * @see _.omit
         **/
         omit<Omitted>(
-            ...keys: string[]): Omitted;
+            ...keys: string[]): LoDashObjectWrapper<Omitted>;
 
         /**
         * @see _.omit
         **/
         omit<Omitted>(
-            keys: string[]): Omitted;
+            keys: string[]): LoDashObjectWrapper<Omitted>;
 
         /**
         * @see _.omit
         **/
         omit<Omitted>(
             callback: ObjectIterator<any, boolean>,
-            thisArg?: any): Omitted;
+            thisArg?: any): LoDashObjectWrapper<Omitted>;
     }
 
     //_.pairs

From d5754766b6bebe5952ebb35bf8e11fb2ced1f7b8 Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Sun, 1 Jun 2014 21:16:30 -0400
Subject: [PATCH 03/13] Add chainable definitions for _(...).pairs

---
 lodash/lodash-tests.ts | 1 +
 lodash/lodash.d.ts     | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index 8a1170c02..8a5df5676 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -884,6 +884,7 @@ result = <HasName>_({ 'name': 'moe', 'age': 40 }).omit(function (value) {
 }).value();
 
 result = <any[][]>_.pairs({ 'moe': 30, 'larry': 40 });
+result = <any[][]>_({ 'moe': 30, 'larry': 40 }).pairs().value();
 
 result = <HasName>_.pick({ 'name': 'moe', '_userid': 'moe1' }, 'name');
 result = <HasName>_.pick({ 'name': 'moe', '_userid': 'moe1' }, ['name']);
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index ab579457a..a05d1d68b 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -5423,6 +5423,13 @@ declare module _ {
         pairs(object: any): any[][];
     }
 
+    interface LoDashObjectWrapper<T> {
+        /**
+        * @see _.pairs
+        **/
+        pairs(): LoDashArrayWrapper<any[]>;
+    }
+
     //_.picks
     interface LoDashStatic {
         /**

From 6e70ecce98a5eff78dc0a5beca7857c4addbeaf0 Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Mon, 2 Jun 2014 10:08:26 -0400
Subject: [PATCH 04/13] Added chainable definition for _(...).reduce and
 aliases.

---
 lodash/lodash-tests.ts | 31 ++++++++++++--
 lodash/lodash.d.ts     | 94 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 122 insertions(+), 3 deletions(-)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index 8a5df5676..7fbbcf3c6 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -420,15 +420,16 @@ result = <IStoogesAge>_.min(stoogesAges, 'age');
 
 result = <string[]>_.pluck(stoogesAges, 'name');
 
-result = <number>_.reduce<number, number>([1, 2, 3], function (sum: number, num: number) {
-    return sum + num;
-});
 interface ABC {
     [index: string]: number;
     a: number;
     b: number;
     c: number;
 }
+
+result = <number>_.reduce<number, number>([1, 2, 3], function (sum: number, num: number) {
+    return sum + num;
+});
 result = <ABC>_.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function (r: ABC, num: number, key: string) {
     r[key] = num * 3;
     return r;
@@ -450,6 +451,30 @@ result = <ABC>_.inject({ 'a': 1, 'b': 2, 'c': 3 }, function (r: ABC, num: number
     return r;
 }, {});
 
+result = <number>_([1, 2, 3]).reduce<number>(function (sum: number, num: number) {
+    return sum + num;
+});
+result = <ABC>_({ 'a': 1, 'b': 2, 'c': 3 }).reduce<number, ABC>(function (r: ABC, num: number, key: string) {
+    r[key] = num * 3;
+    return r;
+}, {});
+
+result = <number>_([1, 2, 3]).foldl<number>(function (sum: number, num: number) {
+    return sum + num;
+});
+result = <ABC>_({ 'a': 1, 'b': 2, 'c': 3 }).foldl<number, ABC>(function (r: ABC, num: number, key: string) {
+    r[key] = num * 3;
+    return r;
+}, {});
+
+result = <number>_([1, 2, 3]).inject<number>(function (sum: number, num: number) {
+    return sum + num;
+});
+result = <ABC>_({ 'a': 1, 'b': 2, 'c': 3 }).inject<number, ABC>(function (r: ABC, num: number, key: string) {
+    r[key] = num * 3;
+    return r;
+}, {});
+
 result = <number[]>_.reduceRight([[0, 1], [2, 3], [4, 5]], function (a: number[], b: number[]) { return a.concat(b); }, <number[]>[]);
 result = <number[]>_.foldr([[0, 1], [2, 3], [4, 5]], function (a: number[], b: number[]) { return a.concat(b); }, <number[]>[]);
 
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index a05d1d68b..4cfeea09a 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -3609,6 +3609,100 @@ declare module _ {
             thisArg?: any): TResult;
     }
 
+    interface LoDashArrayWrapper<T> {
+         /**
+        * @see _.reduce
+        **/
+        reduce<TResult>(
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        reduce<TResult>(
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<TResult>(
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<TResult>(
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<TResult>(
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<TResult>(
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+    }
+
+    interface LoDashObjectWrapper<T> {
+         /**
+        * @see _.reduce
+        **/
+        reduce<TValue, TResult>(
+            callback: MemoIterator<TValue, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        reduce<TValue, TResult>(
+            callback: MemoIterator<TValue, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<TValue, TResult>(
+            callback: MemoIterator<TValue, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<TValue, TResult>(
+            callback: MemoIterator<TValue, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<TValue, TResult>(
+            callback: MemoIterator<TValue, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<TValue, TResult>(
+            callback: MemoIterator<TValue, TResult>,
+            thisArg?: any): TResult;
+    }
+
     //_.reduceRight
     interface LoDashStatic {
         /**

From 4a64d7cdf002adfa2d660d7d21f5a0ef3dc879b5 Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Mon, 2 Jun 2014 10:19:05 -0400
Subject: [PATCH 05/13] Added chainable definitions for _(...).pluck

---
 lodash/lodash-tests.ts |  1 +
 lodash/lodash.d.ts     | 16 ++++++++++++++++
 2 files changed, 17 insertions(+)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index 7fbbcf3c6..9438b18fc 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -419,6 +419,7 @@ result = <IStoogesAge>_.min(stoogesAges, function (stooge) { return stooge.age;
 result = <IStoogesAge>_.min(stoogesAges, 'age');
 
 result = <string[]>_.pluck(stoogesAges, 'name');
+result = <string[]>_(stoogesAges).pluck('name').value();
 
 interface ABC {
     [index: string]: number;
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 4cfeea09a..ab4fdd02a 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -3444,6 +3444,22 @@ declare module _ {
             property: string): any[];
     }
 
+    interface LoDashArrayWrapper<T> {
+        /**
+        * @see _.pluck
+        **/
+        pluck<T extends {}>(
+            property: string): LoDashArrayWrapper<any>;
+    }
+
+    interface LoDashObjectWrapper<T> {
+        /**
+        * @see _.pluck
+        **/
+        pluck<T extends {}>(
+            property: string): LoDashArrayWrapper<any>;
+    }
+
     //_.reduce
     interface LoDashStatic {
         /**

From 063c99482a5db0609a9a8349e112071561158b8e Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Mon, 2 Jun 2014 10:56:47 -0400
Subject: [PATCH 06/13] Added chainable definition for _(...).uniq and aliases

---
 lodash/lodash-tests.ts |  16 +++++++
 lodash/lodash.d.ts     | 100 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 116 insertions(+)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index 9438b18fc..a4b46fb6c 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -277,6 +277,22 @@ result = <string[]>_.unique(['A', 'b', 'C', 'a', 'B', 'c'], function (letter) {
 result = <number[]>_.unique([1, 2.5, 3, 1.5, 2, 3.5], function (num) { return this.floor(num); }, Math);
 result = <{ x: number; }[]>_.unique([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
 
+result = <number[]>_([1, 2, 1, 3, 1]).uniq().value();
+result = <number[]>_([1, 1, 2, 2, 3]).uniq(true).value();
+result = <string[]>_(['A', 'b', 'C', 'a', 'B', 'c']).uniq(function (letter) {
+    return letter.toLowerCase();
+}).value();
+result = <number[]>_([1, 2.5, 3, 1.5, 2, 3.5]).uniq(function (num) { return this.floor(num); }, Math).value();
+result = <{ x: number; }[]>_([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }]).uniq('x').value();
+
+result = <number[]>_([1, 2, 1, 3, 1]).unique().value();
+result = <number[]>_([1, 1, 2, 2, 3]).unique(true).value();
+result = <string[]>_(['A', 'b', 'C', 'a', 'B', 'c']).unique(function (letter) {
+    return letter.toLowerCase();
+}).value();
+result = <number[]>_([1, 2.5, 3, 1.5, 2, 3.5]).unique(function (num) { return this.floor(num); }, Math).value();
+result = <{ x: number; }[]>_([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }]).unique('x').value();
+
 result = <number[]>_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
 
 result = <any[][]>_.zip(['moe', 'larry'], [30, 40], [true, false]);
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index ab4fdd02a..1c3f88155 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -1750,6 +1750,106 @@ declare module _ {
             whereValue?: W): T[];
     }
 
+    interface LoDashArrayWrapper<T> {
+        /**
+        * @see _.uniq
+        **/
+        uniq<TSort>(isSorted?: boolean): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        **/
+        uniq<TSort>(
+            isSorted: boolean,
+            callback: ListIterator<T, TSort>,
+            thisArg?: any): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        **/
+        uniq<TSort>(
+            callback: ListIterator<T, TSort>,
+            thisArg?: any): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        * @param pluckValue _.pluck style callback
+        **/
+        uniq(
+            isSorted: boolean,
+            pluckValue: string): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        * @param pluckValue _.pluck style callback
+        **/
+        uniq(pluckValue: string): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        * @param whereValue _.where style callback
+        **/
+        uniq<W>(
+            isSorted: boolean,
+            whereValue: W): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        * @param whereValue _.where style callback
+        **/
+        uniq<W>(
+            whereValue: W): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        **/
+        unique<TSort>(isSorted?: boolean): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        **/
+        unique<TSort>(
+            isSorted: boolean,
+            callback: ListIterator<T, TSort>,
+            thisArg?: any): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        **/
+        unique<TSort>(
+            callback: ListIterator<T, TSort>,
+            thisArg?: any): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        * @param pluckValue _.pluck style callback
+        **/
+        unique(
+            isSorted: boolean,
+            pluckValue: string): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        * @param pluckValue _.pluck style callback
+        **/
+        unique(pluckValue: string): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        * @param whereValue _.where style callback
+        **/
+        unique<W>(
+            isSorted: boolean,
+            whereValue: W): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.uniq
+        * @param whereValue _.where style callback
+        **/
+        unique<W>(
+            whereValue: W): LoDashArrayWrapper<T>;        
+    }
+
     //_.without
     interface LoDashStatic {
         /**

From 0fad808e8d8d163ab22df42d6469f4e01ddd0c1e Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Mon, 2 Jun 2014 16:41:45 -0400
Subject: [PATCH 07/13] Added TResult generic to chainable _(...).pluck methods

This is needed because there is no way to cast the output in the middle of the chain.

This is not be done on _.pluck() methods because T cannot be inferred.  In other words, this:

    <number>_.pluck(objectArray, 'id');

or this:

    var id: number = _.pluck(objectArray, 'id');

is cleaner than this:

    _.pluck<IMyObjectInterface, number>(objectArray, 'id');
---
 lodash/lodash.d.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 1c3f88155..8d373d993 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -3548,16 +3548,16 @@ declare module _ {
         /**
         * @see _.pluck
         **/
-        pluck<T extends {}>(
-            property: string): LoDashArrayWrapper<any>;
+        pluck<TResult>(
+            property: string): LoDashArrayWrapper<TResult>;
     }
 
     interface LoDashObjectWrapper<T> {
         /**
         * @see _.pluck
         **/
-        pluck<T extends {}>(
-            property: string): LoDashArrayWrapper<any>;
+        pluck<TResult>(
+            property: string): LoDashArrayWrapper<TResult>;
     }
 
     //_.reduce

From be19adcd824538206792b6cb664d93e41f6b3d8f Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Mon, 2 Jun 2014 21:58:20 -0400
Subject: [PATCH 08/13] Added chainable definitions for _(...).reject

---
 lodash/lodash-tests.ts |  4 ++++
 lodash/lodash.d.ts     | 21 +++++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index a4b46fb6c..c36e211c2 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -499,6 +499,10 @@ result = <number[]>_.reject([1, 2, 3, 4, 5, 6], function (num) { return num % 2
 result = <IFoodCombined[]>_.reject(foodsCombined, 'organic');
 result = <IFoodCombined[]>_.reject(foodsCombined, { 'type': 'fruit' });
 
+result = <number[]>_([1, 2, 3, 4, 5, 6]).reject(function (num) { return num % 2 == 0; }).value();
+result = <IFoodCombined[]>_(foodsCombined).reject('organic').value();
+result = <IFoodCombined[]>_(foodsCombined).reject({ 'type': 'fruit' }).value();
+
 result = <number>_.sample([1, 2, 3, 4]);
 result = <number[]>_.sample([1, 2, 3, 4], 2);
 
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 8d373d993..c3089b06a 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -4016,6 +4016,27 @@ declare module _ {
             whereValue: W): T[];
     }
 
+    interface LoDashArrayWrapper<T> {
+        /**
+        * @see _.reject
+        **/
+        reject(
+            callback: ListIterator<T, boolean>,
+            thisArg?: any): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.reject
+        * @param pluckValue _.pluck style callback
+        **/
+        reject(pluckValue: string): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.reject
+        * @param whereValue _.where style callback
+        **/
+        reject<W>(whereValue: W): LoDashArrayWrapper<T>;
+    }
+
     //_.sample
     interface LoDashStatic {
         /**

From b599ab50cc762e76004fcfed82174dfea62cf927 Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Mon, 2 Jun 2014 22:06:58 -0400
Subject: [PATCH 09/13] Added chainable definitions for _(...).sortBy

---
 lodash/lodash-tests.ts |  4 ++++
 lodash/lodash.d.ts     | 21 +++++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index c36e211c2..c9c37c433 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -524,6 +524,10 @@ result = <number[]>_.sortBy([1, 2, 3], function (num) { return Math.sin(num); })
 result = <number[]>_.sortBy([1, 2, 3], function (num) { return this.sin(num); }, Math);
 result = <string[]>_.sortBy(['banana', 'strawberry', 'apple'], 'length');
 
+result = <number[]>_([1, 2, 3]).sortBy(function (num) { return Math.sin(num); }).value();
+result = <number[]>_([1, 2, 3]).sortBy(function (num) { return this.sin(num); }, Math).value();
+result = <string[]>_(['banana', 'strawberry', 'apple']).sortBy('length').value();
+
 (function (a: number, b: number, c: number, d: number) { return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
 
 result = <IStoogesCombined[]>_.where(stoogesCombined, { 'age': 40 });
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index c3089b06a..e355330a0 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -4349,6 +4349,27 @@ declare module _ {
             whereValue: W): T[];
     }
 
+    interface LoDashArrayWrapper<T> {
+        /**
+        * @see _.sortBy
+        **/
+        sortBy<TSort>(
+            callback?: ListIterator<T, TSort>,
+            thisArg?: any): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.sortBy
+        * @param pluckValue _.pluck style callback
+        **/
+        sortBy(pluckValue: string): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.sortBy
+        * @param whereValue _.where style callback
+        **/
+        sortBy<W>(whereValue: W): LoDashArrayWrapper<T>;
+    }
+
     //_.toArray
     interface LoDashStatic {
         /**

From f100b9e970120cac097ec5edb4c3646a3b318048 Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Mon, 2 Jun 2014 22:18:12 -0400
Subject: [PATCH 10/13] Added chainable definitions for _(...).where

---
 lodash/lodash-tests.ts | 3 +++
 lodash/lodash.d.ts     | 7 +++++++
 2 files changed, 10 insertions(+)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index c9c37c433..6ee7ad464 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -533,6 +533,9 @@ result = <string[]>_(['banana', 'strawberry', 'apple']).sortBy('length').value()
 result = <IStoogesCombined[]>_.where(stoogesCombined, { 'age': 40 });
 result = <IStoogesCombined[]>_.where(stoogesCombined, { 'quotes': ['Poifect!'] });
 
+result = <IStoogesCombined[]>_(stoogesCombined).where({ 'age': 40 }).value();
+result = <IStoogesCombined[]>_(stoogesCombined).where({ 'quotes': ['Poifect!'] }).value();
+
 /*************
  * Functions *
  *************/
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index e355330a0..053787bd8 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -4418,6 +4418,13 @@ declare module _ {
             properties: U): T[];
     }
 
+    interface LoDashArrayWrapper<T> {
+        /**
+        * @see _.where
+        **/
+        where<T, U extends {}>(properties: U): LoDashArrayWrapper<T>;
+    }
+
     /*************
      * Functions *
      *************/

From 5968a6823b92a16a778e62946bee3a4d9d73e503 Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Mon, 2 Jun 2014 22:40:45 -0400
Subject: [PATCH 11/13] Added chainable definitions for _(...).first and
 aliases

---
 lodash/lodash-tests.ts | 24 +++++++++++
 lodash/lodash.d.ts     | 98 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 122 insertions(+)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index 6ee7ad464..1836d459e 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -183,6 +183,14 @@ result = <number[]>_.first([1, 2, 3], function (num) {
 result = <IFoodOrganic[]>_.first(foodsOrganic, 'organic');
 result = <IFoodType[]>_.first(foodsType, { 'type': 'fruit' });
 
+result = <number>_([1, 2, 3]).first();
+result = <number[]>_([1, 2, 3]).first(2).value();
+result = <number[]>_([1, 2, 3]).first(function (num) {
+    return num < 3;
+}).value();
+result = <IFoodOrganic[]>_(foodsOrganic).first('organic').value();
+result = <IFoodType[]>_(foodsType).first({ 'type': 'fruit' }).value();
+
 result = <number>_.head([1, 2, 3]);
 result = <number[]>_.head([1, 2, 3], 2);
 result = <number[]>_.head([1, 2, 3], function (num) {
@@ -191,12 +199,28 @@ result = <number[]>_.head([1, 2, 3], function (num) {
 result = <IFoodOrganic[]>_.head(foodsOrganic, 'organic');
 result = <IFoodType[]>_.head(foodsType, { 'type': 'fruit' });
 
+result = <number>_([1, 2, 3]).head();
+result = <number[]>_([1, 2, 3]).head(2).value();
+result = <number[]>_([1, 2, 3]).head(function (num) {
+    return num < 3;
+}).value();
+result = <IFoodOrganic[]>_(foodsOrganic).head('organic').value();
+result = <IFoodType[]>_(foodsType).head({ 'type': 'fruit' }).value();
+
 result = <number>_.take([1, 2, 3]);
 result = <number[]>_.take([1, 2, 3], 2);
 result = <number[]>_.take([1, 2, 3], (num) => num < 3);
 result = <IFoodOrganic[]>_.take(foodsOrganic, 'organic');
 result = <IFoodType[]>_.take(foodsType, { 'type': 'fruit' });
 
+result = <number>_([1, 2, 3]).take();
+result = <number[]>_([1, 2, 3]).take(2).value();
+result = <number[]>_([1, 2, 3]).take(function (num) {
+    return num < 3;
+}).value();
+result = <IFoodOrganic[]>_(foodsOrganic).take('organic').value();
+result = <IFoodType[]>_(foodsType).take({ 'type': 'fruit' }).value();
+
 result = <number[]>_.flatten([1, [2], [3, [[4]]]]);
 result = <any[]>_.flatten([1, [2], [3, [[4]]]], true);
 var result: any
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 053787bd8..2a599cdf3 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -644,6 +644,104 @@ declare module _ {
             whereValue: W): T[];
     }
 
+    interface LoDashArrayWrapper<T> {
+        /**
+        * @see _.first
+        **/
+        first(): T;
+
+        /**
+        * @see _.first
+        * @param n The number of elements to return.
+        **/
+        first(n: number): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.first
+        * @param callback The function called per element.
+        * @param [thisArg] The this binding of callback.
+        **/
+        first(
+            callback: ListIterator<T, boolean>,
+            thisArg?: any): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.first
+        * @param pluckValue "_.pluck" style callback value
+        **/
+        first(pluckValue: string): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.first
+        * @param whereValue "_.where" style callback value
+        **/
+        first<W>(whereValue: W): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.first
+        **/
+        head(): T;
+
+        /**
+        * @see _.first
+        * @param n The number of elements to return.
+        **/
+        head(n: number): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.first
+        * @param callback The function called per element.
+        * @param [thisArg] The this binding of callback.
+        **/
+        head(
+            callback: ListIterator<T, boolean>,
+            thisArg?: any): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.first
+        * @param pluckValue "_.pluck" style callback value
+        **/
+        head(pluckValue: string): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.first
+        * @param whereValue "_.where" style callback value
+        **/
+        head<W>(whereValue: W): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.first
+        **/
+        take(): T;
+
+        /**
+        * @see _.first
+        * @param n The number of elements to return.
+        **/
+        take(n: number): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.first
+        * @param callback The function called per element.
+        * @param [thisArg] The this binding of callback.
+        **/
+        take(
+            callback: ListIterator<T, boolean>,
+            thisArg?: any): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.first
+        * @param pluckValue "_.pluck" style callback value
+        **/
+        take(pluckValue: string): LoDashArrayWrapper<T>;
+
+        /**
+        * @see _.first
+        * @param whereValue "_.where" style callback value
+        **/
+        take<W>(whereValue: W): LoDashArrayWrapper<T>;
+    }
+
     //_.flatten
     interface LoDashStatic {
         /**

From 1def2150e239b61e30ef391eb06f6761babde888 Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Tue, 3 Jun 2014 13:23:28 -0400
Subject: [PATCH 12/13] Add chainable definitions for _(...).keys

---
 lodash/lodash-tests.ts | 1 +
 lodash/lodash.d.ts     | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index 1836d459e..fb56a0b1e 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -909,6 +909,7 @@ result = <boolean>_.isString('moe');
 result = <boolean>_.isUndefined(void 0);
 
 result = <string[]>_.keys({ 'one': 1, 'two': 2, 'three': 3 });
+result = <string[]>_({ 'one': 1, 'two': 2, 'three': 3 }).keys().value();
 
 var mergeNames = {
     'stooges': [
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 2a599cdf3..482742bed 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -5637,6 +5637,13 @@ declare module _ {
         keys(object: any): string[];
     }
 
+    interface LoDashObjectWrapper<T> {
+        /**
+        * @see _.keys
+        **/
+        keys(): LoDashArrayWrapper<string>
+    }
+
     //_.mapValues
     interface LoDashStatic {
         /**

From 79e22825d5bb9d567405bd4d01611850e7aa6f79 Mon Sep 17 00:00:00 2001
From: Brian Zengel <bczengel@gmail.com>
Date: Tue, 3 Jun 2014 13:23:53 -0400
Subject: [PATCH 13/13] Add chainable definitions for _(...).forEach and
 aliases when passing an non-dictionary object.

---
 lodash/lodash-tests.ts |  2 ++
 lodash/lodash.d.ts     | 16 ++++++++++++++++
 2 files changed, 18 insertions(+)

diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index fb56a0b1e..e95658916 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -397,9 +397,11 @@ 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 = <IFoodType>_.forEach<IFoodType, string>({ name: 'apple', type: 'fruit' }, function (value, key) { console.log(value, key) });
 
 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 = <IFoodType>_.each<IFoodType, string>({ name: 'apple', type: 'fruit' }, function (value, key) { console.log(value, key) });
 
 result = <_.LoDashArrayWrapper<number>>_([1, 2, 3]).forEach(function (num) { console.log(num); });
 result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_(<{ [index: string]: number; }>{ 'one': 1, 'two': 2, 'three': 3 }).forEach(function (num) { console.log(num); });
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 482742bed..ff8502c16 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -2939,6 +2939,14 @@ declare module _ {
             callback: ObjectIterator<T, void>,
             thisArg?: any): Dictionary<T>;
 
+        /**
+        * @see _.each
+        **/
+        forEach<T extends {}, TValue>(
+            object: T,
+            callback: ObjectIterator<TValue, void>,
+            thisArg?: any): T
+
         /**
         * @see _.forEach
         **/
@@ -2965,6 +2973,14 @@ declare module _ {
             object: Dictionary<T>,
             callback: ObjectIterator<T, void>,
             thisArg?: any): Dictionary<T>;
+
+        /**
+        * @see _.each
+        **/
+        each<T extends {}, TValue>(
+            object: T,
+            callback: ObjectIterator<TValue, void>,
+            thisArg?: any): T
     }
 
     interface LoDashArrayWrapper<T> {