diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index 974d0b966..c083edd4c 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -104,46 +104,43 @@ result = <(key: string) => any>testMapCache.get;
 result = <(key: string) => boolean>testMapCache.has;
 result = <(key: string, value: any) => _.Dictionary<any>>testMapCache.set;
 
-/*************
- * Chaining *
- *************/
-result = <_.LoDashWrapper<string>>_('test');
-result = <_.LoDashWrapper<number>>_(1);
-result = <_.LoDashWrapper<boolean>>_(true);
-result = <_.LoDashArrayWrapper<string>>_(['test1', 'test2']);
-// Appears to be a change in the compiler, if the type explicity implements the object indexer.
-// Looking at: https://typescript.codeplex.com/wikipage?title=Known%20breaking%20changes%20between%200.8%20and%200.9&referringTitle=Documentation
-// "The ‘noimplicitany’ option now warns on the use of the hidden default indexer"
-result = <_.LoDashObjectWrapper<_.Dictionary<string>>>_(<{ [index: string]: string; }>{ 'key1': 'test1', 'key2': 'test2' });
+// _
+module TestWrapper {
+    {
+        let result: _.LoDashImplicitWrapper<string>;
+        result = _('');
+    }
 
-result = <_.LoDashWrapper<string>>_.chain('test');
-result = <_.LoDashWrapper<string>>_('test').chain();
-result = <_.LoDashWrapper<number>>_.chain(1);
-result = <_.LoDashWrapper<number>>_(1).chain();
-result = <_.LoDashWrapper<boolean>>_.chain(true);
-result = <_.LoDashWrapper<boolean>>_(true).chain();
-result = <_.LoDashArrayWrapper<string>>_.chain(['test1', 'test2']);
-result = <_.LoDashArrayWrapper<string>>_(['test1', 'test2']).chain();
-result = <_.LoDashObjectWrapper<_.Dictionary<string>>>_.chain(<{ [index: string]: string; }>{ 'key1': 'test1', 'key2': 'test2' });
-result = <_.LoDashObjectWrapper<_.Dictionary<string>>>_(<{ [index: string]: string; }>{ 'key1': 'test1', 'key2': 'test2' }).chain();
+    {
+        let result: _.LoDashImplicitWrapper<number>;
+        result = _(42);
+    }
+
+    {
+        let result: _.LoDashImplicitWrapper<boolean>;
+        result = _(true);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+        result = _<string>(['']);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: string}>;
+        result = _<{a: string}>({a: ''});
+    }
+}
 
 //Wrapped array shortcut methods
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).concat(5, 6);
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).concat([5, 6]);
 result = <string>_([1, 2, 3, 4]).join(',');
 result = <number>_([1, 2, 3, 4]).pop();
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).push(5, 6, 7);
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).reverse();
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3, 4]).push(5, 6, 7);
 result = <number>_([1, 2, 3, 4]).shift();
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).sort((a, b) => 1);
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).splice(1);
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).splice(1, 2, 5, 6);
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).unshift(5, 6);
-
-result = <number[]>_.tap([1, 2, 3, 4], function (array) { console.log(array); });
-result = <_.LoDashWrapper<string>>_('test').tap(function (value) { console.log(value); });
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).tap(function (array) { console.log(array); });
-result = <_.LoDashObjectWrapper<_.Dictionary<string>>>_(<{ [index: string]: string; }>{ 'key1': 'test1', 'key2': 'test2' }).tap(function (array) { console.log(array); });
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3, 4]).sort((a, b) => 1);
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3, 4]).splice(1);
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3, 4]).splice(1, 2, 5, 6);
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3, 4]).unshift(5, 6);
 
 result = <string>_('test').toString();
 result = <string>_([1, 2, 3]).toString();
@@ -412,10 +409,10 @@ result = <Array<number>>_.flatten([1, [2], [[3]]], true);
 result = <Array<number>>_.flatten<number>([1, [2], [3, [[4]]]], true);
 result = <Array<number|boolean>>_.flatten<number|boolean>([1, [2], [3, [[false]]]], true);
 
-result = <_.LoDashArrayWrapper<number>>_([[1, 2], [3, 4], 5, 6]).flatten();
-result = <_.LoDashArrayWrapper<number|Array<Array<number>>>>_([1, [2], [3, [[4]]]]).flatten();
+result = <_.LoDashImplicitArrayWrapper<number>>_([[1, 2], [3, 4], 5, 6]).flatten();
+result = <_.LoDashImplicitArrayWrapper<number|Array<Array<number>>>>_([1, [2], [3, [[4]]]]).flatten();
 
-result = <_.LoDashArrayWrapper<number>>_([1, [2], [3, [[4]]]]).flatten(true);
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, [2], [3, [[4]]]]).flatten(true);
 
 // _.flattenDeep
 module TestFlattenDeep {
@@ -1053,76 +1050,417 @@ result = <number[]>_([1, 2]).zipWith<number>([1, 2], [1, 2], [1, 2], [1, 2], [1,
  * Chain *
  *********/
 
+// _.chain
+module TestChain {
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _.chain('');
+        result = _('').chain();
+
+        result = _.chain('').chain();
+        result = _('').chain().chain();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _.chain(42);
+        result = _(42).chain();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _.chain(true);
+        result = _(true).chain();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _.chain(['']);
+        result = _(['']).chain();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: string}>;
+
+        result = _.chain<{a: string}>({a: ''});
+        result = _<{a: string}>({a: ''}).chain();
+    }
+}
+
+// _.tap
+module TestTap {
+    {
+        let interceptor: (value: string) => void;
+        let result: string;
+
+        _.tap('', interceptor);
+        _.tap('', interceptor, any);
+    }
+
+    {
+        let interceptor: (value: string[]) => void;
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        _.tap([''], interceptor);
+        _.tap([''], interceptor, any);
+    }
+
+    {
+        let interceptor: (value: {a: string}) => void;
+        let result: _.LoDashImplicitObjectWrapper<{a: string}>;
+
+        _.tap({a: ''}, interceptor);
+        _.tap({a: ''}, interceptor, any);
+    }
+
+    {
+        let interceptor: (value: string) => void;
+        let result: _.LoDashImplicitWrapper<string>;
+
+        _.chain('').tap(interceptor, any);
+        _.chain('').tap(interceptor, any);
+
+        _('').tap(interceptor);
+        _('').tap(interceptor, any);
+    }
+
+    {
+        let interceptor: (value: string[]) => void;
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        _.chain(['']).tap(interceptor);
+        _.chain(['']).tap(interceptor, any);
+
+        _(['']).tap(interceptor);
+        _(['']).tap(interceptor, any);
+    }
+
+    {
+        let interceptor: (value: {a: string}) => void;
+        let result: _.LoDashImplicitObjectWrapper<{a: string}>;
+
+        _.chain({a: ''}).tap(interceptor);
+        _.chain({a: ''}).tap(interceptor, any);
+
+        _({a: ''}).tap(interceptor);
+        _({a: ''}).tap(interceptor, any);
+    }
+
+    {
+        let interceptor: (value: string) => void;
+        let result: _.LoDashExplicitWrapper<string>;
+
+        _.chain('').tap(interceptor, any);
+        _.chain('').tap(interceptor, any);
+
+        _('').chain().tap(interceptor);
+        _('').chain().tap(interceptor, any);
+    }
+
+    {
+        let interceptor: (value: string[]) => void;
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        _.chain(['']).tap(interceptor);
+        _.chain(['']).tap(interceptor, any);
+
+        _(['']).chain().tap(interceptor);
+        _(['']).chain().tap(interceptor, any);
+    }
+
+    {
+        let interceptor: (value: {a: string}) => void;
+        let result: _.LoDashExplicitObjectWrapper<{a: string}>;
+
+        _.chain({a: ''}).tap(interceptor);
+        _.chain({a: ''}).tap(interceptor, any);
+
+        _({a: ''}).chain().tap(interceptor);
+        _({a: ''}).chain().tap(interceptor, any);
+    }
+}
+
 // _.thru
-{
-    let result: number;
-    result = _.thru<number, number>(1, (value: number) => value);
-    result = _.thru<number, number>(1, (value: number) => value, any);
-}
-{
-    let result: _.LoDashWrapper<number>;
-    result = _(1).thru<number>((value: number) => value);
-    result = _(1).thru<number>((value: number) => value, any);
-}
-{
-    let result: _.LoDashWrapper<string>;
-    result = _('').thru<string>((value: string) => value);
-    result = _('').thru<string>((value: string) => value, any);
-}
-{
-    let result: _.LoDashWrapper<boolean>;
-    result = _(true).thru<boolean>((value: boolean) => value);
-    result = _(true).thru<boolean>((value: boolean) => value, any);
-}
-{
-    let result: _.LoDashObjectWrapper<any>;
-    result = _({}).thru<Object>((value: Object) => value);
-    result = _({}).thru<Object>((value: Object) => value, any);
-}
-{
-    let result: _.LoDashArrayWrapper<number>;
-    result = _([1, 2, 3]).thru<number>((value: number[]) => value);
-    result = _([1, 2, 3]).thru<number>((value: number[]) => value, any);
+module TestThru {
+    interface Interceptor<T> {
+        (value: T): T;
+    }
+
+    {
+        let interceptor: Interceptor<number>;
+        let result: number;
+
+        result = _.thru<number, number>(1, interceptor);
+        result = _.thru<number, number>(1, interceptor, any);
+    }
+
+    {
+        let interceptor: Interceptor<number>;
+        let result: _.LoDashImplicitWrapper<number>;
+
+        result = _(1).thru<number>(interceptor);
+        result = _(1).thru<number>(interceptor, any);
+    }
+
+    {
+        let interceptor: Interceptor<string>;
+        let result: _.LoDashImplicitWrapper<string>;
+
+        result = _('').thru<string>(interceptor);
+        result = _('').thru<string>(interceptor, any);
+    }
+
+    {
+        let interceptor: Interceptor<boolean>;
+        let result: _.LoDashImplicitWrapper<boolean>;
+
+        result = _(true).thru<boolean>(interceptor);
+        result = _(true).thru<boolean>(interceptor, any);
+    }
+
+    {
+        let interceptor: Interceptor<{a: string}>;
+        let result: _.LoDashImplicitObjectWrapper<{a: string}>;
+
+        result = _({a: ''}).thru<{a: string}>(interceptor);
+        result = _({a: ''}).thru<{a: string}>(interceptor, any);
+    }
+
+    {
+        let interceptor: Interceptor<number[]>;
+        let result: _.LoDashImplicitArrayWrapper<number>;
+
+        result = _([1, 2, 3]).thru<number>(interceptor);
+        result = _([1, 2, 3]).thru<number>(interceptor, any);
+    }
+
+    {
+        let interceptor: Interceptor<number>;
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(1).chain().thru<number>(interceptor);
+        result = _(1).chain().thru<number>(interceptor, any);
+    }
+
+    {
+        let interceptor: Interceptor<string>;
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('').chain().thru<string>(interceptor);
+        result = _('').chain().thru<string>(interceptor, any);
+    }
+
+    {
+        let interceptor: Interceptor<boolean>;
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(true).chain().thru<boolean>(interceptor);
+        result = _(true).chain().thru<boolean>(interceptor, any);
+    }
+
+    {
+        let interceptor: Interceptor<{a: string}>;
+        let result: _.LoDashExplicitObjectWrapper<{a: string}>;
+
+        result = _({a: ''}).chain().thru<{a: string}>(interceptor);
+        result = _({a: ''}).chain().thru<{a: string}>(interceptor, any);
+    }
+
+    {
+        let interceptor: Interceptor<number[]>;
+        let result: _.LoDashExplicitArrayWrapper<number>;
+
+        result = _([1, 2, 3]).chain().thru<number>(interceptor);
+        result = _([1, 2, 3]).chain().thru<number>(interceptor, any);
+    }
 }
 
 // _.prototype.commit
-{
-    let result: _.LoDashWrapper<number>;
-    result = _(42).commit();
+module TestCommit {
+    {
+        let result: _.LoDashImplicitWrapper<number>;
+        result = _(42).commit();
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<any>;
+        result = _<any>([]).commit();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<any>;
+        result = _({}).commit();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+        result = _(42).chain().commit();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<any>;
+        result = _<any>([]).chain().commit();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<any>;
+        result = _({}).chain().commit();
+    }
 }
-{
-    let result: _.LoDashArrayWrapper<any>;
-    result = _<any>([]).commit();
-}
-{
-    let result: _.LoDashObjectWrapper<any>;
-    result = _({}).commit();
+
+// _.prototype.concat
+module TestConcat {
+    {
+        let result: _.LoDashImplicitArrayWrapper<number>;
+
+        result = _(1).concat<number>(2);
+        result = _(1).concat<number>(2, 3);
+        result = _(1).concat<number>(2, 3, 4);
+
+        result = _(1).concat(2);
+        result = _(1).concat(2, 3);
+        result = _(1).concat(2, 3, 4);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _<string>(['']).concat<string>(['']);
+        result = _<string>(['']).concat<string>([''], ['']);
+        result = _<string>(['']).concat<string>([''], [''], ['']);
+
+        result = _<string>(['']).concat(['']);
+        result = _<string>(['']).concat([''], ['']);
+        result = _<string>(['']).concat([''], [''], ['']);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<{a: string}>;
+
+        result = _({a: ''}).concat<{a: string}>({a: ''});
+        result = _({a: ''}).concat<{a: string}>({a: ''}, {a: ''});
+        result = _({a: ''}).concat<{a: string}>({a: ''}, {a: ''}, {a: ''});
+
+        result = _({a: ''}).concat({a: ''});
+        result = _({a: ''}).concat({a: ''}, {a: ''});
+        result = _({a: ''}).concat({a: ''}, {a: ''}, {a: ''});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<number>;
+
+        result = _(1).chain().concat<number>(2);
+        result = _(1).chain().concat<number>(2, 3);
+        result = _(1).chain().concat<number>(2, 3, 4);
+
+        result = _(1).chain().concat(2);
+        result = _(1).chain().concat(2, 3);
+        result = _(1).chain().concat(2, 3, 4);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _<string>(['']).chain().concat<string>(['']);
+        result = _<string>(['']).chain().concat<string>([''], ['']);
+        result = _<string>(['']).chain().concat<string>([''], [''], ['']);
+
+        result = _<string>(['']).chain().concat(['']);
+        result = _<string>(['']).chain().concat([''], ['']);
+        result = _<string>(['']).chain().concat([''], [''], ['']);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<{a: string}>;
+
+        result = _({a: ''}).chain().concat<{a: string}>({a: ''});
+        result = _({a: ''}).chain().concat<{a: string}>({a: ''}, {a: ''});
+        result = _({a: ''}).chain().concat<{a: string}>({a: ''}, {a: ''}, {a: ''});
+
+        result = _({a: ''}).chain().concat({a: ''});
+        result = _({a: ''}).chain().concat({a: ''}, {a: ''});
+        result = _({a: ''}).chain().concat({a: ''}, {a: ''}, {a: ''});
+    }
 }
 
 // _.prototype.plant
-{
-    let result: _.LoDashWrapper<number>;
-    result = _(any).plant(42);
+module TestPlant {
+    {
+        let result: _.LoDashImplicitWrapper<number>;
+        result = _(any).plant(42);
+    }
+
+    {
+        let result: _.LoDashImplicitStringWrapper;
+        result = _(any).plant('');
+    }
+
+    {
+        let result: _.LoDashImplicitWrapper<boolean>;
+        result = _(any).plant(true);
+    }
+
+    {
+        let result: _.LoDashImplicitNumberArrayWrapper;
+        result = _(any).plant([42]);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<any>;
+        result = _(any).plant<any>([]);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{}>;
+        result = _(any).plant<{}>({});
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+        result = _(any).chain().plant(42);
+    }
+
+    {
+        let result: _.LoDashExplicitStringWrapper;
+        result = _(any).chain().plant('');
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+        result = _(any).chain().plant(true);
+    }
+
+    {
+        let result: _.LoDashExplicitNumberArrayWrapper;
+        result = _(any).chain().plant([42]);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<any>;
+        result = _(any).chain().plant<any>([]);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{}>;
+        result = _(any).chain().plant<{}>({});
+    }
 }
-{
-    let result: _.LoDashStringWrapper;
-    result = _(any).plant('');
-}
-{
-    let result: _.LoDashWrapper<boolean>;
-    result = _(any).plant(true);
-}
-{
-    let result: _.LoDashNumberArrayWrapper;
-    result = _(any).plant([42]);
-}
-{
-    let result: _.LoDashArrayWrapper<any>;
-    result = _(any).plant<any>([]);
-}
-{
-    let result: _.LoDashObjectWrapper<{}>;
-    result = _(any).plant<{}>({});
+
+// _.prototype.reverse
+module TestReverse {
+    {
+        let result: _.LoDashImplicitArrayWrapper<number>;
+        result: _([42]).reverse();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<number>;
+        result: _([42]).chain().reverse();
+    }
 }
 
 /**************
@@ -1318,9 +1656,9 @@ result = <_.Dictionary<number>>_.countBy([4.3, 6.1, 6.4], function (num) { retur
 result = <_.Dictionary<number>>_.countBy([4.3, 6.1, 6.4], function (num) { return this.floor(num); }, Math);
 result = <_.Dictionary<number>>_.countBy(['one', 'two', 'three'], 'length');
 
-result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_([4.3, 6.1, 6.4]).countBy(function (num) { return Math.floor(num); });
-result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_([4.3, 6.1, 6.4]).countBy(function (num) { return this.floor(num); }, Math);
-result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_(['one', 'two', 'three']).countBy('length');
+result = <_.LoDashImplicitObjectWrapper<_.Dictionary<number>>>_([4.3, 6.1, 6.4]).countBy(function (num) { return Math.floor(num); });
+result = <_.LoDashImplicitObjectWrapper<_.Dictionary<number>>>_([4.3, 6.1, 6.4]).countBy(function (num) { return this.floor(num); }, Math);
+result = <_.LoDashImplicitObjectWrapper<_.Dictionary<number>>>_(['one', 'two', 'three']).countBy('length');
 
 // _.detect
 module TestDetect {
@@ -1509,11 +1847,11 @@ 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); });
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3]).forEach(function (num) { console.log(num); });
+result = <_.LoDashImplicitObjectWrapper<_.Dictionary<number>>>_(<{ [index: string]: number; }>{ 'one': 1, 'two': 2, 'three': 3 }).forEach(function (num) { console.log(num); });
 
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3]).each(function (num) { console.log(num); });
-result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_(<{ [index: string]: number; }>{ 'one': 1, 'two': 2, 'three': 3 }).each(function (num) { console.log(num); });
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3]).each(function (num) { console.log(num); });
+result = <_.LoDashImplicitObjectWrapper<_.Dictionary<number>>>_(<{ [index: string]: number; }>{ 'one': 1, 'two': 2, 'three': 3 }).each(function (num) { console.log(num); });
 
 result = <number[]>_.forEachRight([1, 2, 3], function (num) { console.log(num); });
 result = <_.Dictionary<number>>_.forEachRight({ 'one': 1, 'two': 2, 'three': 3 }, function (num) { console.log(num); });
@@ -1521,11 +1859,11 @@ result = <_.Dictionary<number>>_.forEachRight({ 'one': 1, 'two': 2, 'three': 3 }
 result = <number[]>_.eachRight([1, 2, 3], function (num) { console.log(num); });
 result = <_.Dictionary<number>>_.eachRight({ 'one': 1, 'two': 2, 'three': 3 }, function (num) { console.log(num); });
 
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3]).forEachRight(function (num) { console.log(num); });
-result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_(<{ [index: string]: number; }>{ 'one': 1, 'two': 2, 'three': 3 }).forEachRight(function (num) { console.log(num); });
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3]).forEachRight(function (num) { console.log(num); });
+result = <_.LoDashImplicitObjectWrapper<_.Dictionary<number>>>_(<{ [index: string]: number; }>{ 'one': 1, 'two': 2, 'three': 3 }).forEachRight(function (num) { console.log(num); });
 
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3]).eachRight(function (num) { console.log(num); });
-result = <_.LoDashObjectWrapper<_.Dictionary<number>>>_(<{ [index: string]: number; }>{ 'one': 1, 'two': 2, 'three': 3 }).eachRight(function (num) { console.log(num); });
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3]).eachRight(function (num) { console.log(num); });
+result = <_.LoDashImplicitObjectWrapper<_.Dictionary<number>>>_(<{ [index: string]: number; }>{ 'one': 1, 'two': 2, 'three': 3 }).eachRight(function (num) { console.log(num); });
 
 result = <_.Dictionary<number[]>>_.groupBy([4.2, 6.1, 6.4], function (num) { return Math.floor(num); });
 result = <_.Dictionary<number[]>>_.groupBy([4.2, 6.1, 6.4], function (num) { return this.floor(num); }, Math);
@@ -1764,14 +2102,14 @@ result = <IFoodCombined[]>_(foodsCombined).reject({ 'type': 'fruit' }).value();
 
 result = <number>_.sample([1, 2, 3, 4]);
 result = <number[]>_.sample([1, 2, 3, 4], 2);
-result = <_.LoDashWrapper<number>>_([1, 2, 3, 4]).sample();
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4]).sample(2);
+result = <_.LoDashImplicitWrapper<number>>_([1, 2, 3, 4]).sample();
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3, 4]).sample(2);
 result = <number>_([1, 2, 3, 4]).sample().value();
 result = <number[]>_([1, 2, 3, 4]).sample(2).value();
 
 result = <number[]>_.shuffle([1, 2, 3, 4, 5, 6]);
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3]).shuffle();
-result = <_.LoDashArrayWrapper<_.Dictionary<string>>>_(<{ [index: string]: string; }>{ 'key1': 'test1', 'key2': 'test2' }).shuffle();
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3]).shuffle();
+result = <_.LoDashImplicitArrayWrapper<_.Dictionary<string>>>_(<{ [index: string]: string; }>{ 'key1': 'test1', 'key2': 'test2' }).shuffle();
 
 result = <number>_.size([1, 2]);
 result = <number>_([1, 2]).size();
@@ -1860,7 +2198,24 @@ result = <IStoogesCombined[]>_(stoogesCombined).where({ 'quotes': ['Poifect!'] }
  * Date *
  ********/
 
-result = <number>_.now();
+module TestNow {
+    {
+        let result: number;
+
+        result = _.now();
+        result = _(42).now();
+        result = _<any>([]).now();
+        result = _({}).now();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(42).chain().now();
+        result = _<any>([]).chain().now();
+        result = _({}).chain().now();
+    }
+}
 
 /*************
  * Functions *
@@ -1963,8 +2318,8 @@ result = <number>_(testComposeSquareFn).compose<(n: number, m: number) => number
 var createCallbackObj: { [index: string]: string; } = { name: 'Joe' };
 result = <() => any>_.createCallback('name');
 result = <() => boolean>_.createCallback(createCallbackObj);
-result = <_.LoDashObjectWrapper<() => any>>_('name').createCallback();
-result = <_.LoDashObjectWrapper<() => boolean>>_(createCallbackObj).createCallback();
+result = <_.LoDashImplicitObjectWrapper<() => any>>_('name').createCallback();
+result = <_.LoDashImplicitObjectWrapper<() => boolean>>_(createCallbackObj).createCallback();
 
 // _.curry
 var testCurryFn = (a: number, b: number, c: number) => [a, b, c];
@@ -2028,14 +2383,14 @@ source.addEventListener('message', <Function>_.debounce(function () { }, 250, {
     'maxWait': 1000
 }), false);
 
-result = <_.LoDashObjectWrapper<Function>>_(function () { }).debounce(150);
+result = <_.LoDashImplicitObjectWrapper<Function>>_(function () { }).debounce(150);
 
-jQuery('#postbox').on('click', <_.LoDashObjectWrapper<Function>>_(function () { }).debounce(300, {
+jQuery('#postbox').on('click', <_.LoDashImplicitObjectWrapper<Function>>_(function () { }).debounce(300, {
     'leading': true,
     'trailing': false
 }));
 
-source.addEventListener('message', <_.LoDashObjectWrapper<Function>>_(function () { }).debounce(250, {
+source.addEventListener('message', <_.LoDashImplicitObjectWrapper<Function>>_(function () { }).debounce(250, {
     'maxWait': 1000
 }), false);
 
@@ -2043,11 +2398,11 @@ var returnedDebounce = _.throttle(function (a: any) { return a * 5; }, 5);
 returnedThrottled(4);
 
 result = <number>_.defer(function () { console.log('deferred'); });
-result = <_.LoDashWrapper<number>>_(function () { console.log('deferred'); }).defer();
+result = <_.LoDashImplicitWrapper<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 = <_.LoDashImplicitWrapper<number>>_(log).delay(1000, 'logged later');
 
 // _.flow
 var testFlowSquareFn = (n: number) => n * n;
@@ -2644,8 +2999,8 @@ result = <NameAge>_.assign({ 'name': 'moe' }, { 'age': 40 }, function (a, b) {
     return typeof a == 'undefined' ? b : a;
 });
 
-result = <_.LoDashObjectWrapper<NameAge>>_({ 'name': 'moe' }).assign({ 'age': 40 });
-result = <_.LoDashObjectWrapper<NameAge>>_({ 'name': 'moe' }).assign({ 'age': 40 }, function (a, b) {
+result = <_.LoDashImplicitObjectWrapper<NameAge>>_({ 'name': 'moe' }).assign({ 'age': 40 });
+result = <_.LoDashImplicitObjectWrapper<NameAge>>_({ 'name': 'moe' }).assign({ 'age': 40 }, function (a, b) {
     return typeof a == 'undefined' ? b : a;
 });
 
@@ -2654,8 +3009,8 @@ result = <NameAge>_.extend({ 'name': 'moe' }, { 'age': 40 }, function (a, b) {
     return typeof a == 'undefined' ? b : a;
 });
 
-result = <_.LoDashObjectWrapper<NameAge>>_({ 'name': 'moe' }).extend({ 'age': 40 });
-result = <_.LoDashObjectWrapper<NameAge>>_({ 'name': 'moe' }).extend({ 'age': 40 }, function (a, b) {
+result = <_.LoDashImplicitObjectWrapper<NameAge>>_({ 'name': 'moe' }).extend({ 'age': 40 });
+result = <_.LoDashImplicitObjectWrapper<NameAge>>_({ 'name': 'moe' }).extend({ 'age': 40 }, function (a, b) {
     return typeof a == 'undefined' ? b : a;
 });
 
@@ -2684,7 +3039,7 @@ interface Food {
 }
 var foodDefaults = { 'name': 'apple' };
 result = <Food>_.defaults(foodDefaults, { 'name': 'banana', 'type': 'fruit' });
-result = <_.LoDashObjectWrapper<Food>>_(foodDefaults).defaults({ 'name': 'banana', 'type': 'fruit' });
+result = <_.LoDashImplicitObjectWrapper<Food>>_(foodDefaults).defaults({ 'name': 'banana', 'type': 'fruit' });
 
 //_.defaultsDeep
 interface DefaultsDeepResult {
@@ -2784,7 +3139,7 @@ result = <Dog>_.forIn(new Dog('Dagny'), function (value, key) {
     console.log(key);
 });
 
-result = <_.LoDashObjectWrapper<Dog>>_(new Dog('Dagny')).forIn(function (value, key) {
+result = <_.LoDashImplicitObjectWrapper<Dog>>_(new Dog('Dagny')).forIn(function (value, key) {
     console.log(key);
 });
 
@@ -2792,7 +3147,7 @@ result = <Dog>_.forInRight(new Dog('Dagny'), function (value, key) {
     console.log(key);
 });
 
-result = <_.LoDashObjectWrapper<Dog>>_(new Dog('Dagny')).forInRight(function (value, key) {
+result = <_.LoDashImplicitObjectWrapper<Dog>>_(new Dog('Dagny')).forInRight(function (value, key) {
     console.log(key);
 });
 
@@ -2806,7 +3161,7 @@ result = <ZeroOne>_.forOwn(<ZeroOne>{ '0': 'zero', '1': 'one', 'one': '2' }, fun
     console.log(key);
 });
 
-result = <_.LoDashObjectWrapper<ZeroOne>>_({ '0': 'zero', '1': 'one', 'length': 2 }).forOwn(function (num, key) {
+result = <_.LoDashImplicitObjectWrapper<ZeroOne>>_({ '0': 'zero', '1': 'one', 'length': 2 }).forOwn(function (num, key) {
     console.log(key);
 });
 
@@ -2814,15 +3169,15 @@ result = <any>_.forOwnRight({ '0': 'zero', '1': 'one', 'length': 2 }, function (
     console.log(key);
 });
 
-result = <_.LoDashObjectWrapper<ZeroOne>>_({ '0': 'zero', '1': 'one', 'length': 2 }).forOwnRight(function (num, key) {
+result = <_.LoDashImplicitObjectWrapper<ZeroOne>>_({ '0': 'zero', '1': 'one', 'length': 2 }).forOwnRight(function (num, key) {
     console.log(key);
 });
 
 result = <string[]>_.functions(_);
 result = <string[]>_.methods(_);
 
-result = <_.LoDashArrayWrapper<string>>_(_).functions();
-result = <_.LoDashArrayWrapper<string>>_(_).methods();
+result = <_.LoDashImplicitArrayWrapper<string>>_(_).functions();
+result = <_.LoDashImplicitArrayWrapper<string>>_(_).methods();
 
 // _.get
 result = <number>_.get<number>({ 'a': [{ 'b': { 'c': 3 } }] }, 'a[0].b.c');
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index c07cfd0e3..881124328 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -38,13 +38,13 @@ declare module _ {
         *
         * Explicit chaining can be enabled by using the _.chain method.
         **/
-        (value: number): LoDashWrapper<number>;
-        (value: string): LoDashStringWrapper;
-        (value: boolean): LoDashWrapper<boolean>;
-        (value: Array<number>): LoDashNumberArrayWrapper;
-        <T>(value: Array<T>): LoDashArrayWrapper<T>;
-        <T extends {}>(value: T): LoDashObjectWrapper<T>;
-        (value: any): LoDashWrapper<any>;
+        (value: number): LoDashImplicitWrapper<number>;
+        (value: string): LoDashImplicitStringWrapper;
+        (value: boolean): LoDashImplicitWrapper<boolean>;
+        (value: Array<number>): LoDashImplicitNumberArrayWrapper;
+        <T>(value: Array<T>): LoDashImplicitArrayWrapper<T>;
+        <T extends {}>(value: T): LoDashImplicitObjectWrapper<T>;
+        (value: any): LoDashImplicitWrapper<any>;
 
         /**
         * The semantic version number.
@@ -211,101 +211,40 @@ declare module _ {
         unindexedChars: boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
-        /**
-        * Produces the toString result of the wrapped value.
-        * @return Returns the string result.
-        **/
-        toString(): string;
+    interface LoDashWrapperBase<T, TWrapper> { }
 
-        /**
-        * Executes the chained sequence to extract the unwrapped value.
-        * @return Returns the resolved unwrapped value.
-        **/
-        value(): T;
+    interface LoDashImplicitWrapperBase<T, TWrapper> extends LoDashWrapperBase<T, TWrapper> { }
 
-        /**
-        * @see _.value
-        **/
-        run(): T;
+    interface LoDashExplicitWrapperBase<T, TWrapper> extends LoDashWrapperBase<T, TWrapper> { }
 
-        /**
-        * @see _.value
-        **/
-        toJSON(): T;
+    interface LoDashImplicitWrapper<T> extends LoDashImplicitWrapperBase<T, LoDashImplicitWrapper<T>> { }
 
-        /**
-        * @see _.value
-        **/
-        valueOf(): T;
-    }
+    interface LoDashExplicitWrapper<T> extends LoDashExplicitWrapperBase<T, LoDashExplicitWrapper<T>> { }
 
-    interface LoDashWrapper<T> extends LoDashWrapperBase<T, LoDashWrapper<T>> { }
+    interface LoDashImplicitStringWrapper extends LoDashImplicitWrapper<string> { }
 
-    interface LoDashStringWrapper extends LoDashWrapper<string> { }
+    interface LoDashExplicitStringWrapper extends LoDashExplicitWrapper<string> { }
 
-    interface LoDashObjectWrapper<T> extends LoDashWrapperBase<T, LoDashObjectWrapper<T>> { }
+    interface LoDashImplicitObjectWrapper<T> extends LoDashImplicitWrapperBase<T, LoDashImplicitObjectWrapper<T>> { }
 
-    interface LoDashArrayWrapper<T> extends LoDashWrapperBase<T[], LoDashArrayWrapper<T>> {
-        concat(...items: Array<T|Array<T>>): LoDashArrayWrapper<T>;
+    interface LoDashExplicitObjectWrapper<T> extends LoDashExplicitWrapperBase<T, LoDashExplicitObjectWrapper<T>> { }
+
+    interface LoDashImplicitArrayWrapper<T> extends LoDashImplicitWrapperBase<T[], LoDashImplicitArrayWrapper<T>> {
         join(seperator?: string): string;
         pop(): T;
-        push(...items: T[]): LoDashArrayWrapper<T>;
-        reverse(): LoDashArrayWrapper<T>;
+        push(...items: T[]): LoDashImplicitArrayWrapper<T>;
         shift(): 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: T[]): LoDashArrayWrapper<T>;
+        sort(compareFn?: (a: T, b: T) => number): LoDashImplicitArrayWrapper<T>;
+        splice(start: number): LoDashImplicitArrayWrapper<T>;
+        splice(start: number, deleteCount: number, ...items: any[]): LoDashImplicitArrayWrapper<T>;
+        unshift(...items: T[]): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashNumberArrayWrapper extends LoDashArrayWrapper<number> { }
+    interface LoDashExplicitArrayWrapper<T> extends LoDashExplicitWrapperBase<T[], LoDashExplicitArrayWrapper<T>> { }
 
-    //_.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 LoDashImplicitNumberArrayWrapper extends LoDashImplicitArrayWrapper<number> { }
 
-    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;
-    }
+    interface LoDashExplicitNumberArrayWrapper extends LoDashExplicitArrayWrapper<number> { }
 
     /*********
      * Array *
@@ -327,18 +266,18 @@ declare module _ {
         ): T[][];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.chunk
          */
-        chunk(size?: number): LoDashArrayWrapper<T[]>;
+        chunk(size?: number): LoDashImplicitArrayWrapper<T[]>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.chunk
          */
-        chunk<TResult>(size?: number): LoDashArrayWrapper<TResult[]>;
+        chunk<TResult>(size?: number): LoDashImplicitArrayWrapper<TResult[]>;
     }
 
     //_.compact
@@ -353,18 +292,18 @@ declare module _ {
         compact<T>(array?: List<T>): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.compact
          */
-        compact(): LoDashArrayWrapper<T>;
+        compact(): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.compact
          */
-        compact<TResult>(): LoDashArrayWrapper<TResult>;
+        compact<TResult>(): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.difference
@@ -383,18 +322,18 @@ declare module _ {
         ): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.difference
          */
-        difference(...values: (T[]|List<T>)[]): LoDashArrayWrapper<T>;
+        difference(...values: (T[]|List<T>)[]): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.difference
          */
-        difference<TValue>(...values: (TValue[]|List<TValue>)[]): LoDashArrayWrapper<TValue>;
+        difference<TValue>(...values: (TValue[]|List<TValue>)[]): LoDashImplicitArrayWrapper<TValue>;
     }
 
     //_.drop
@@ -409,18 +348,18 @@ declare module _ {
         drop<T>(array: T[]|List<T>, n?: number): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.drop
          */
-        drop(n?: number): LoDashArrayWrapper<T>;
+        drop(n?: number): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.drop
          */
-        drop<TResult>(n?: number): LoDashArrayWrapper<TResult>;
+        drop<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.dropRight
@@ -438,18 +377,18 @@ declare module _ {
         ): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.dropRight
          */
-        dropRight(n?: number): LoDashArrayWrapper<T>;
+        dropRight(n?: number): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.dropRight
          */
-        dropRight<TResult>(n?: number): LoDashArrayWrapper<TResult>;
+        dropRight<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.dropRightWhile
@@ -496,14 +435,14 @@ declare module _ {
         ): TValue[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.dropRightWhile
          */
         dropRightWhile(
             predicate?: ListIterator<T, boolean>,
             thisArg?: any
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.dropRightWhile
@@ -511,24 +450,24 @@ declare module _ {
         dropRightWhile(
             predicate?: string,
             thisArg?: any
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.dropRightWhile
          */
         dropRightWhile<TWhere>(
             predicate?: TWhere
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.dropRightWhile
          */
         dropRightWhile<TValue>(
             predicate?: ListIterator<TValue, boolean>,
             thisArg?: any
-        ): LoDashArrayWrapper<TValue>;
+        ): LoDashImplicitArrayWrapper<TValue>;
 
         /**
          * @see _.dropRightWhile
@@ -536,14 +475,14 @@ declare module _ {
         dropRightWhile<TValue>(
             predicate?: string,
             thisArg?: any
-        ): LoDashArrayWrapper<TValue>;
+        ): LoDashImplicitArrayWrapper<TValue>;
 
         /**
          * @see _.dropRightWhile
          */
         dropRightWhile<TWhere, TValue>(
             predicate?: TWhere
-        ): LoDashArrayWrapper<TValue>;
+        ): LoDashImplicitArrayWrapper<TValue>;
     }
 
     //_.dropWhile
@@ -590,14 +529,14 @@ declare module _ {
         ): TValue[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.dropWhile
          */
         dropWhile(
             predicate?: ListIterator<T, boolean>,
             thisArg?: any
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.dropWhile
@@ -605,24 +544,24 @@ declare module _ {
         dropWhile(
             predicate?: string,
             thisArg?: any
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.dropWhile
          */
         dropWhile<TWhere>(
             predicate?: TWhere
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.dropWhile
          */
         dropWhile<TValue>(
             predicate?: ListIterator<TValue, boolean>,
             thisArg?: any
-        ): LoDashArrayWrapper<TValue>;
+        ): LoDashImplicitArrayWrapper<TValue>;
 
         /**
          * @see _.dropWhile
@@ -630,14 +569,14 @@ declare module _ {
         dropWhile<TValue>(
             predicate?: string,
             thisArg?: any
-        ): LoDashArrayWrapper<TValue>;
+        ): LoDashImplicitArrayWrapper<TValue>;
 
         /**
          * @see _.dropWhile
          */
         dropWhile<TWhere, TValue>(
             predicate?: TWhere
-        ): LoDashArrayWrapper<TValue>;
+        ): LoDashImplicitArrayWrapper<TValue>;
     }
 
     //_.findIndex
@@ -684,7 +623,7 @@ declare module _ {
         ): number;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.findIndex
          */
@@ -709,7 +648,7 @@ declare module _ {
         ): number;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.findIndex
          */
@@ -777,7 +716,7 @@ declare module _ {
         ): number;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.findLastIndex
          */
@@ -802,7 +741,7 @@ declare module _ {
         ): number;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.findLastIndex
          */
@@ -840,14 +779,14 @@ declare module _ {
         first<T>(array: List<T>): T;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.first
          */
         first(): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.first
          */
@@ -885,16 +824,16 @@ declare module _ {
         flatten<T>(array: RecursiveList<T>, isDeep: boolean): List<T> | RecursiveList<T>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.flatten
          **/
-        flatten<T>(): LoDashArrayWrapper<any>;
+        flatten<T>(): LoDashImplicitArrayWrapper<any>;
 
         /**
          * @see _.flatten
          **/
-        flatten<T>(isShallow: boolean): LoDashArrayWrapper<any>;
+        flatten<T>(isShallow: boolean): LoDashImplicitArrayWrapper<any>;
     }
 
     //_.flattenDeep
@@ -918,18 +857,18 @@ declare module _ {
         flattenDeep<T>(array: RecursiveList<T>): any[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.flattenDeep
          */
-        flattenDeep<TResult>(): LoDashArrayWrapper<TResult>;
+        flattenDeep<TResult>(): LoDashImplicitArrayWrapper<TResult>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.flattenDeep
          */
-        flattenDeep<TResult>(): LoDashArrayWrapper<TResult>;
+        flattenDeep<TResult>(): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.head
@@ -940,14 +879,14 @@ declare module _ {
         head<T>(array: List<T>): T;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.first
          */
         head(): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.first
          */
@@ -973,7 +912,7 @@ declare module _ {
         ): number;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.indexOf
          */
@@ -983,7 +922,7 @@ declare module _ {
         ): number;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.indexOf
          */
@@ -1004,18 +943,18 @@ declare module _ {
         initial<T>(array: T[]|List<T>): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.initial
          */
-        initial(): LoDashArrayWrapper<T>;
+        initial(): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.initial
          */
-        initial<TResult>(): LoDashArrayWrapper<TResult>;
+        initial<TResult>(): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.intersection
@@ -1030,18 +969,18 @@ declare module _ {
         intersection<T>(...arrays: (T[]|List<T>)[]): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.intersection
          */
-        intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashArrayWrapper<TResult>;
+        intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashImplicitArrayWrapper<TResult>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.intersection
          */
-        intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashArrayWrapper<TResult>;
+        intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.last
@@ -1055,14 +994,14 @@ declare module _ {
         last<T>(array: List<T>): T;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.last
          */
         last(): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.last
          */
@@ -1086,7 +1025,7 @@ declare module _ {
         ): number;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.lastIndexOf
          */
@@ -1096,7 +1035,7 @@ declare module _ {
         ): number;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.lastIndexOf
          */
@@ -1133,50 +1072,50 @@ declare module _ {
         ): _.Dictionary<any>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.zipObject
          */
         object<TValues, TResult extends {}>(
             values?: List<TValues>
-        ): _.LoDashObjectWrapper<TResult>;
+        ): _.LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.zipObject
          */
         object<TResult extends {}>(
             values?: List<any>
-        ): _.LoDashObjectWrapper<TResult>;
+        ): _.LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.zipObject
          */
         object(
             values?: List<any>
-        ): _.LoDashObjectWrapper<_.Dictionary<any>>;
+        ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.zipObject
          */
         object<TValues, TResult extends {}>(
             values?: List<TValues>
-        ): _.LoDashObjectWrapper<TResult>;
+        ): _.LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.zipObject
          */
         object<TResult extends {}>(
             values?: List<any>
-        ): _.LoDashObjectWrapper<TResult>;
+        ): _.LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.zipObject
          */
         object(
             values?: List<any>
-        ): _.LoDashObjectWrapper<_.Dictionary<any>>;
+        ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
     }
 
     //_.pull
@@ -1204,18 +1143,18 @@ declare module _ {
         ): List<T>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.pull
          */
-        pull(...values: T[]): LoDashArrayWrapper<T>;
+        pull(...values: T[]): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.pull
          */
-        pull<TValue>(...values: TValue[]): LoDashObjectWrapper<List<TValue>>;
+        pull<TValue>(...values: TValue[]): LoDashImplicitObjectWrapper<List<TValue>>;
     }
 
     //_.pullAt
@@ -1236,18 +1175,18 @@ declare module _ {
         ): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.pullAt
          */
-        pullAt(...indexes: (number|number[])[]): LoDashArrayWrapper<T>;
+        pullAt(...indexes: (number|number[])[]): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.pullAt
          */
-        pullAt<TValue>(...indexes: (number|number[])[]): LoDashArrayWrapper<TValue>;
+        pullAt<TValue>(...indexes: (number|number[])[]): LoDashImplicitArrayWrapper<TValue>;
     }
 
     //_.remove
@@ -1296,14 +1235,14 @@ declare module _ {
         ): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.remove
          */
         remove(
             predicate?: ListIterator<T, boolean>,
             thisArg?: any
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.remove
@@ -1311,24 +1250,24 @@ declare module _ {
         remove(
             predicate?: string,
             thisArg?: any
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.remove
          */
         remove<W>(
             predicate?: W
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.remove
          */
         remove<TResult>(
             predicate?: ListIterator<TResult, boolean>,
             thisArg?: any
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
 
         /**
          * @see _.remove
@@ -1336,14 +1275,14 @@ declare module _ {
         remove<TResult>(
             predicate?: string,
             thisArg?: any
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
 
         /**
          * @see _.remove
          */
         remove<W, TResult>(
             predicate?: W
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.rest
@@ -1359,18 +1298,18 @@ declare module _ {
         rest<T>(array: List<T>): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.rest
          */
-        rest(): LoDashArrayWrapper<T>;
+        rest(): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.rest
          */
-        rest<TResult>(): LoDashArrayWrapper<TResult>;
+        rest<TResult>(): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.slice
@@ -1390,14 +1329,14 @@ declare module _ {
         ): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.slice
          */
         slice(
             start?: number,
             end?: number
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
     }
 
     //_.sortedIndex
@@ -1478,18 +1417,18 @@ declare module _ {
         tail<T>(array: List<T>): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.rest
          */
-        tail(): LoDashArrayWrapper<T>;
+        tail(): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.rest
          */
-        tail<TResult>(): LoDashArrayWrapper<TResult>;
+        tail<TResult>(): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.take
@@ -1507,18 +1446,18 @@ declare module _ {
         ): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.take
          */
-        take(n?: number): LoDashArrayWrapper<T>;
+        take(n?: number): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.take
          */
-        take<TResult>(n?: number): LoDashArrayWrapper<TResult>;
+        take<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.takeRight
@@ -1536,18 +1475,18 @@ declare module _ {
         ): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.takeRight
          */
-        takeRight(n?: number): LoDashArrayWrapper<T>;
+        takeRight(n?: number): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.takeRight
          */
-        takeRight<TResult>(n?: number): LoDashArrayWrapper<TResult>;
+        takeRight<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.takeRightWhile
@@ -1594,14 +1533,14 @@ declare module _ {
         ): TValue[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.takeRightWhile
          */
         takeRightWhile(
             predicate?: ListIterator<T, boolean>,
             thisArg?: any
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.takeRightWhile
@@ -1609,24 +1548,24 @@ declare module _ {
         takeRightWhile(
             predicate?: string,
             thisArg?: any
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.takeRightWhile
          */
         takeRightWhile<TWhere>(
             predicate?: TWhere
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.takeRightWhile
          */
         takeRightWhile<TValue>(
             predicate?: ListIterator<TValue, boolean>,
             thisArg?: any
-        ): LoDashArrayWrapper<TValue>;
+        ): LoDashImplicitArrayWrapper<TValue>;
 
         /**
          * @see _.takeRightWhile
@@ -1634,14 +1573,14 @@ declare module _ {
         takeRightWhile<TValue>(
             predicate?: string,
             thisArg?: any
-        ): LoDashArrayWrapper<TValue>;
+        ): LoDashImplicitArrayWrapper<TValue>;
 
         /**
          * @see _.takeRightWhile
          */
         takeRightWhile<TWhere, TValue>(
             predicate?: TWhere
-        ): LoDashArrayWrapper<TValue>;
+        ): LoDashImplicitArrayWrapper<TValue>;
     }
 
     //_.takeWhile
@@ -1688,14 +1627,14 @@ declare module _ {
         ): TValue[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.takeWhile
          */
         takeWhile(
             predicate?: ListIterator<T, boolean>,
             thisArg?: any
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.takeWhile
@@ -1703,24 +1642,24 @@ declare module _ {
         takeWhile(
             predicate?: string,
             thisArg?: any
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.takeWhile
          */
         takeWhile<TWhere>(
             predicate?: TWhere
-        ): LoDashArrayWrapper<T>;
+        ): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.takeWhile
          */
         takeWhile<TValue>(
             predicate?: ListIterator<TValue, boolean>,
             thisArg?: any
-        ): LoDashArrayWrapper<TValue>;
+        ): LoDashImplicitArrayWrapper<TValue>;
 
         /**
          * @see _.takeWhile
@@ -1728,14 +1667,14 @@ declare module _ {
         takeWhile<TValue>(
             predicate?: string,
             thisArg?: any
-        ): LoDashArrayWrapper<TValue>;
+        ): LoDashImplicitArrayWrapper<TValue>;
 
         /**
          * @see _.takeWhile
          */
         takeWhile<TWhere, TValue>(
             predicate?: TWhere
-        ): LoDashArrayWrapper<TValue>;
+        ): LoDashImplicitArrayWrapper<TValue>;
     }
 
     //_.union
@@ -1750,23 +1689,23 @@ declare module _ {
         union<T>(...arrays: List<T>[]): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.union
          */
-        union(...arrays: List<T>[]): LoDashArrayWrapper<T>;
+        union(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.union
          */
-        union<T>(...arrays: List<T>[]): LoDashArrayWrapper<T>;
+        union<T>(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.union
          */
-        union<T>(...arrays: List<T>[]): LoDashArrayWrapper<T>;
+        union<T>(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
     }
 
     //_.uniq
@@ -2011,11 +1950,11 @@ declare module _ {
             whereValue?: W): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.uniq
         **/
-        uniq<TSort>(isSorted?: boolean): LoDashArrayWrapper<T>;
+        uniq<TSort>(isSorted?: boolean): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
@@ -2023,14 +1962,14 @@ declare module _ {
         uniq<TSort>(
             isSorted: boolean,
             callback: ListIterator<T, TSort>,
-            thisArg?: any): LoDashArrayWrapper<T>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
         **/
         uniq<TSort>(
             callback: ListIterator<T, TSort>,
-            thisArg?: any): LoDashArrayWrapper<T>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
@@ -2038,13 +1977,13 @@ declare module _ {
         **/
         uniq(
             isSorted: boolean,
-            pluckValue: string): LoDashArrayWrapper<T>;
+            pluckValue: string): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
         * @param pluckValue _.pluck style callback
         **/
-        uniq(pluckValue: string): LoDashArrayWrapper<T>;
+        uniq(pluckValue: string): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
@@ -2052,19 +1991,19 @@ declare module _ {
         **/
         uniq<W>(
             isSorted: boolean,
-            whereValue: W): LoDashArrayWrapper<T>;
+            whereValue: W): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
         * @param whereValue _.where style callback
         **/
         uniq<W>(
-            whereValue: W): LoDashArrayWrapper<T>;
+            whereValue: W): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
         **/
-        unique<TSort>(isSorted?: boolean): LoDashArrayWrapper<T>;
+        unique<TSort>(isSorted?: boolean): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
@@ -2072,14 +2011,14 @@ declare module _ {
         unique<TSort>(
             isSorted: boolean,
             callback: ListIterator<T, TSort>,
-            thisArg?: any): LoDashArrayWrapper<T>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
         **/
         unique<TSort>(
             callback: ListIterator<T, TSort>,
-            thisArg?: any): LoDashArrayWrapper<T>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
@@ -2087,13 +2026,13 @@ declare module _ {
         **/
         unique(
             isSorted: boolean,
-            pluckValue: string): LoDashArrayWrapper<T>;
+            pluckValue: string): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
         * @param pluckValue _.pluck style callback
         **/
-        unique(pluckValue: string): LoDashArrayWrapper<T>;
+        unique(pluckValue: string): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
@@ -2101,14 +2040,14 @@ declare module _ {
         **/
         unique<W>(
             isSorted: boolean,
-            whereValue: W): LoDashArrayWrapper<T>;
+            whereValue: W): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.uniq
         * @param whereValue _.where style callback
         **/
         unique<W>(
-            whereValue: W): LoDashArrayWrapper<T>;
+            whereValue: W): LoDashImplicitArrayWrapper<T>;
     }
 
     //_.unzipWith
@@ -2130,24 +2069,24 @@ declare module _ {
         ): TResult[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.unzipWith
          */
         unzipWith<TArr, TResult>(
             iteratee?: MemoIterator<TArr, TResult>,
             thisArg?: any
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.unzipWith
          */
         unzipWith<TArr, TResult>(
             iteratee?: MemoIterator<TArr, TResult>,
             thisArg?: any
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.without
@@ -2165,18 +2104,18 @@ declare module _ {
         ): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.without
          */
-        without(...values: T[]): LoDashArrayWrapper<T>;
+        without(...values: T[]): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.without
          */
-        without<TValue>(...values: TValue[]): LoDashArrayWrapper<TValue>;
+        without<TValue>(...values: TValue[]): LoDashImplicitArrayWrapper<TValue>;
     }
 
     //_.xor
@@ -2190,18 +2129,18 @@ declare module _ {
         xor<T>(...arrays: List<T>[]): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.xor
          */
-        xor(...arrays: List<T>[]): LoDashArrayWrapper<T>;
+        xor(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.xor
          */
-        xor<TValue>(...arrays: List<TValue>[]): LoDashArrayWrapper<TValue>;
+        xor<TValue>(...arrays: List<TValue>[]): LoDashImplicitArrayWrapper<TValue>;
     }
 
     //_.zip
@@ -2231,16 +2170,16 @@ declare module _ {
         unzip(...arrays: any[]): any[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.zip
         **/
-        zip(...arrays: any[][]): _.LoDashArrayWrapper<any[][]>;
+        zip(...arrays: any[][]): _.LoDashImplicitArrayWrapper<any[][]>;
 
         /**
         * @see _.zip
         **/
-        unzip(...arrays: any[]): _.LoDashArrayWrapper<any[][]>;
+        unzip(...arrays: any[]): _.LoDashImplicitArrayWrapper<any[][]>;
     }
 
     //_.zipObject
@@ -2278,50 +2217,50 @@ declare module _ {
         ): _.Dictionary<any>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.zipObject
          */
         zipObject<TValues, TResult extends {}>(
             values?: List<TValues>
-        ): _.LoDashObjectWrapper<TResult>;
+        ): _.LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.zipObject
          */
         zipObject<TResult extends {}>(
             values?: List<any>
-        ): _.LoDashObjectWrapper<TResult>;
+        ): _.LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.zipObject
          */
         zipObject(
             values?: List<any>
-        ): _.LoDashObjectWrapper<_.Dictionary<any>>;
+        ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.zipObject
          */
         zipObject<TValues, TResult extends {}>(
             values?: List<TValues>
-        ): _.LoDashObjectWrapper<TResult>;
+        ): _.LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.zipObject
          */
         zipObject<TResult extends {}>(
             values?: List<any>
-        ): _.LoDashObjectWrapper<TResult>;
+        ): _.LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.zipObject
          */
         zipObject(
             values?: List<any>
-        ): _.LoDashObjectWrapper<_.Dictionary<any>>;
+        ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
     }
 
     //_.zipWith
@@ -2338,21 +2277,105 @@ declare module _ {
         zipWith<TResult>(...args: any[]): TResult[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.zipWith
          */
-        zipWith<TResult>(...args: any[]): LoDashArrayWrapper<TResult>;
+        zipWith<TResult>(...args: any[]): LoDashImplicitArrayWrapper<TResult>;
     }
 
     /*********
      * Chain *
      *********/
 
+    //_.chain
+    interface LoDashStatic {
+        /**
+         * Creates a lodash object that wraps value with explicit method chaining enabled.
+         *
+         * @param value The value to wrap.
+         * @return Returns the new lodash wrapper instance.
+         */
+        chain(value: number): LoDashExplicitWrapper<number>;
+        chain(value: string): LoDashExplicitWrapper<string>;
+        chain(value: boolean): LoDashExplicitWrapper<boolean>;
+        chain<T>(value: T[]): LoDashExplicitArrayWrapper<T>;
+        chain<T extends {}>(value: T): LoDashExplicitObjectWrapper<T>;
+        chain(value: any): LoDashExplicitWrapper<any>;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.chain
+         */
+        chain(): LoDashExplicitWrapper<T>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.chain
+         */
+        chain(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.chain
+         */
+        chain(): LoDashExplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.chain
+         */
+        chain(): TWrapper;
+    }
+
+    //_.tap
+    interface LoDashStatic {
+        /**
+         * This method invokes interceptor and returns value. The interceptor is bound to thisArg and invoked with one
+         * argument; (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.
+         * @parem thisArg The this binding of interceptor.
+         * @return Returns value.
+         **/
+        tap<T>(
+            value: T,
+            interceptor: (value: T) => void,
+            thisArg?: any
+        ): T;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.tap
+         */
+        tap(
+            interceptor: (value: T) => void,
+            thisArg?: any
+        ): TWrapper;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.tap
+         */
+        tap(
+            interceptor: (value: T) => void,
+            thisArg?: any
+        ): TWrapper;
+    }
+
     //_.thru
     interface LoDashStatic {
         /**
          * This method is like _.tap except that it returns the result of interceptor.
+         *
          * @param value The value to provide to interceptor.
          * @param interceptor The function to invoke.
          * @param thisArg The this binding of interceptor.
@@ -2361,48 +2384,91 @@ declare module _ {
         thru<T, TResult>(
             value: T,
             interceptor: (value: T) => TResult,
-            thisArg?: any): TResult;
+            thisArg?: any
+        ): TResult;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.thru
          */
         thru<TResult extends number>(
             interceptor: (value: T) => TResult,
-            thisArg?: any): LoDashWrapper<TResult>;
+            thisArg?: any): LoDashImplicitWrapper<TResult>;
 
         /**
          * @see _.thru
          */
         thru<TResult extends string>(
             interceptor: (value: T) => TResult,
-            thisArg?: any): LoDashWrapper<TResult>;
+            thisArg?: any): LoDashImplicitWrapper<TResult>;
 
         /**
          * @see _.thru
          */
         thru<TResult extends boolean>(
             interceptor: (value: T) => TResult,
-            thisArg?: any): LoDashWrapper<TResult>;
+            thisArg?: any): LoDashImplicitWrapper<TResult>;
 
         /**
          * @see _.thru
          */
-        thru<TResult extends Object>(
+        thru<TResult extends {}>(
             interceptor: (value: T) => TResult,
-            thisArg?: any): LoDashObjectWrapper<TResult>;
+            thisArg?: any): LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.thru
          */
         thru<TResult>(
             interceptor: (value: T) => TResult[],
-            thisArg?: any): LoDashArrayWrapper<TResult>;
+            thisArg?: any): LoDashImplicitArrayWrapper<TResult>;
     }
 
-    // _.prototype.commit
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.thru
+         */
+        thru<TResult extends number>(
+            interceptor: (value: T) => TResult,
+            thisArg?: any
+        ): LoDashExplicitWrapper<TResult>;
+
+        /**
+         * @see _.thru
+         */
+        thru<TResult extends string>(
+            interceptor: (value: T) => TResult,
+            thisArg?: any
+        ): LoDashExplicitWrapper<TResult>;
+
+        /**
+         * @see _.thru
+         */
+        thru<TResult extends boolean>(
+            interceptor: (value: T) => TResult,
+            thisArg?: any
+        ): LoDashExplicitWrapper<TResult>;
+
+        /**
+         * @see _.thru
+         */
+        thru<TResult extends {}>(
+            interceptor: (value: T) => TResult,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.thru
+         */
+        thru<TResult>(
+            interceptor: (value: T) => TResult[],
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    //_.prototype.commit
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * Executes the chained sequence and returns the wrapped result.
          *
@@ -2411,44 +2477,181 @@ declare module _ {
         commit(): TWrapper;
     }
 
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.commit
+         */
+        commit(): TWrapper;
+    }
+
+    //_.prototype.concat
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * Creates a new array joining a wrapped array with any additional arrays and/or values.
+         *
+         * @param items
+         * @return Returns the new concatenated array.
+         */
+        concat<TItem>(...items: Array<TItem|Array<TItem>>): LoDashImplicitArrayWrapper<TItem>;
+
+        /**
+         * @see _.concat
+         */
+        concat(...items: Array<T|Array<T>>): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.concat
+         */
+        concat<TItem>(...items: Array<TItem|Array<TItem>>): LoDashExplicitArrayWrapper<TItem>;
+
+        /**
+         * @see _.concat
+         */
+        concat(...items: Array<T|Array<T>>): LoDashExplicitArrayWrapper<T>;
+    }
+
     //_.prototype.plant
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * Creates a clone of the chained sequence planting value as the wrapped value.
          * @param value The value to plant as the wrapped value.
          * @return Returns the new lodash wrapper instance.
          */
-        plant(value: number): LoDashWrapper<number>;
+        plant(value: number): LoDashImplicitWrapper<number>;
 
         /**
          * @see _.plant
          */
-        plant(value: string): LoDashStringWrapper;
+        plant(value: string): LoDashImplicitStringWrapper;
 
         /**
          * @see _.plant
          */
-        plant(value: boolean): LoDashWrapper<boolean>;
+        plant(value: boolean): LoDashImplicitWrapper<boolean>;
 
         /**
          * @see _.plant
          */
-        plant(value: number[]): LoDashNumberArrayWrapper;
+        plant(value: number[]): LoDashImplicitNumberArrayWrapper;
 
         /**
          * @see _.plant
          */
-        plant<T>(value: T[]): LoDashArrayWrapper<T>;
+        plant<T>(value: T[]): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.plant
          */
-        plant<T extends {}>(value: T): LoDashObjectWrapper<T>;
+        plant<T extends {}>(value: T): LoDashImplicitObjectWrapper<T>;
 
         /**
          * @see _.plant
          */
-        plant(value: any): LoDashWrapper<any>;
+        plant(value: any): LoDashImplicitWrapper<any>;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.plant
+         */
+        plant(value: number): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.plant
+         */
+        plant(value: string): LoDashExplicitStringWrapper;
+
+        /**
+         * @see _.plant
+         */
+        plant(value: boolean): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.plant
+         */
+        plant(value: number[]): LoDashExplicitNumberArrayWrapper;
+
+        /**
+         * @see _.plant
+         */
+        plant<T>(value: T[]): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.plant
+         */
+        plant<T extends {}>(value: T): LoDashExplicitObjectWrapper<T>;
+
+        /**
+         * @see _.plant
+         */
+        plant(value: any): LoDashExplicitWrapper<any>;
+    }
+
+    //_.prototype.reverse
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * Reverses the wrapped array so the first element becomes the last, the second element becomes the second to
+         * last, and so on.
+         *
+         * Note: This method mutates the wrapped array.
+         *
+         * @return Returns the new reversed lodash wrapper instance.
+         */
+        reverse(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.reverse
+         */
+        reverse(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    // _.run
+    interface LoDashWrapperBase<T, TWrapper> {
+        /**
+         * @see _.value
+         */
+        run(): T;
+    }
+
+    // _.toJSON
+    interface LoDashWrapperBase<T, TWrapper> {
+        /**
+         * @see _.value
+         */
+        toJSON(): T;
+    }
+
+    interface LoDashWrapperBase<T, TWrapper> {
+        /**
+         * Produces the result of coercing the unwrapped value to a string.
+         *
+         * @return Returns the coerced string value.
+         */
+        toString(): string;
+    }
+
+    // _.value
+    interface LoDashWrapperBase<T, TWrapper> {
+        /**
+         * Executes the chained sequence to extract the unwrapped value.
+         *
+         * @alias _.run, _.toJSON, _.valueOf
+         *
+         * @return Returns the resolved unwrapped value.
+         */
+        value(): T;
+    }
+
+    // _.valueOf
+    interface LoDashWrapperBase<T, TWrapper> {
+        /**
+         * @see _.value
+         */
+        valueOf(): T;
     }
 
     /**************
@@ -2493,7 +2696,7 @@ declare module _ {
         ): boolean;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.every
          */
@@ -2518,7 +2721,7 @@ declare module _ {
         ): boolean;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.every
          */
@@ -2581,7 +2784,7 @@ declare module _ {
         ): boolean;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.some
          */
@@ -2606,7 +2809,7 @@ declare module _ {
         ): boolean;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.some
          */
@@ -2647,18 +2850,18 @@ declare module _ {
         ): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.at
          */
-        at(...props: Array<number|string|Array<number|string>>): LoDashArrayWrapper<T>;
+        at(...props: Array<number|string|Array<number|string>>): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.at
          */
-        at<TResult>(...props: Array<number|string|Array<number|string>>): LoDashArrayWrapper<TResult>;
+        at<TResult>(...props: Array<number|string|Array<number|string>>): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.collect
@@ -2714,52 +2917,52 @@ declare module _ {
         ): boolean[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.map
          */
         collect<TResult>(
             iteratee?: ListIterator<T, TResult>,
             thisArg?: any
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
 
         /**
          * @see _.map
          */
         collect<TResult>(
             iteratee?: string
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
 
         /**
          * @see _.map
          */
         collect<TObject extends {}>(
             iteratee?: TObject
-        ): LoDashArrayWrapper<boolean>;
+        ): LoDashImplicitArrayWrapper<boolean>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.map
          */
         collect<TValue, TResult>(
             iteratee?: ListIterator<TValue, TResult>|DictionaryIterator<TValue, TResult>,
             thisArg?: any
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
 
         /**
          * @see _.map
          */
         collect<TValue, TResult>(
             iteratee?: string
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
 
         /**
          * @see _.map
          */
         collect<TObject extends {}>(
             iteratee?: TObject
-        ): LoDashArrayWrapper<boolean>;
+        ): LoDashImplicitArrayWrapper<boolean>;
     }
 
     //_.contains
@@ -2870,7 +3073,7 @@ declare module _ {
             fromIndex?: number): boolean;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.contains
          **/
@@ -2887,7 +3090,7 @@ declare module _ {
         includes(target: T, fromIndex?: number): boolean;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.contains
          **/
@@ -2904,7 +3107,7 @@ declare module _ {
         includes<TValue>(target: TValue, fromIndex?: number): boolean;
     }
 
-    interface LoDashStringWrapper {
+    interface LoDashImplicitStringWrapper {
         /**
          * @see _.contains
          **/
@@ -2990,13 +3193,13 @@ declare module _ {
             thisArg?: any): Dictionary<number>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.countBy
         **/
         countBy(
             callback?: ListIterator<T, any>,
-            thisArg?: any): LoDashObjectWrapper<Dictionary<number>>;
+            thisArg?: any): LoDashImplicitObjectWrapper<Dictionary<number>>;
 
         /**
         * @see _.countBy
@@ -3004,7 +3207,7 @@ declare module _ {
         **/
         countBy(
             callback: string,
-            thisArg?: any): LoDashObjectWrapper<Dictionary<number>>;
+            thisArg?: any): LoDashImplicitObjectWrapper<Dictionary<number>>;
     }
 
     //_.detect
@@ -3045,7 +3248,7 @@ declare module _ {
         ): T;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.find
          */
@@ -3070,7 +3273,7 @@ declare module _ {
         ): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.find
          */
@@ -3150,7 +3353,7 @@ declare module _ {
         ): boolean;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.every
          */
@@ -3175,7 +3378,7 @@ declare module _ {
         ): boolean;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.every
          */
@@ -3229,24 +3432,24 @@ declare module _ {
             end?: number): List<TResult>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.fill
          */
         fill<TResult>(
             value: TResult,
             start?: number,
-            end?: number): LoDashArrayWrapper<TResult>;
+            end?: number): LoDashImplicitArrayWrapper<TResult>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.fill
          */
         fill<TResult>(
             value: TResult,
             start?: number,
-            end?: number): LoDashObjectWrapper<List<TResult>>;
+            end?: number): LoDashImplicitObjectWrapper<List<TResult>>;
     }
 
     //_.filter
@@ -3418,62 +3621,62 @@ declare module _ {
             whereValue: W): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.filter
         **/
-        filter(): LoDashArrayWrapper<T>;
+        filter(): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.filter
         **/
         filter(
             callback: ListIterator<T, boolean>,
-            thisArg?: any): LoDashArrayWrapper<T>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.filter
         * @param pluckValue _.pluck style callback
         **/
         filter(
-            pluckValue: string): LoDashArrayWrapper<T>;
+            pluckValue: string): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.filter
         * @param pluckValue _.pluck style callback
         **/
         filter<W>(
-            whereValue: W): LoDashArrayWrapper<T>;
+            whereValue: W): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.filter
         **/
         select(
             callback: ListIterator<T, boolean>,
-            thisArg?: any): LoDashArrayWrapper<T>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.filter
         * @param pluckValue _.pluck style callback
         **/
         select(
-            pluckValue: string): LoDashArrayWrapper<T>;
+            pluckValue: string): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.filter
         * @param pluckValue _.pluck style callback
         **/
         select<W>(
-            whereValue: W): LoDashArrayWrapper<T>;
+            whereValue: W): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.filter
         **/
         filter<T extends {}>(
             callback: ObjectIterator<T, boolean>,
-            thisArg?: any): LoDashObjectWrapper<T>;
+            thisArg?: any): LoDashImplicitObjectWrapper<T>;
     }
 
     //_.find
@@ -3531,7 +3734,7 @@ declare module _ {
         ): T;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.find
          */
@@ -3556,7 +3759,7 @@ declare module _ {
         ): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.find
          */
@@ -3736,7 +3939,7 @@ declare module _ {
             pluckValue: string): T;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.findLast
         */
@@ -3833,36 +4036,36 @@ declare module _ {
             thisArg?: any): T
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.forEach
         **/
         forEach(
             callback: ListIterator<T, void>,
-            thisArg?: any): LoDashArrayWrapper<T>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.forEach
         **/
         each(
             callback: ListIterator<T, void>,
-            thisArg?: any): LoDashArrayWrapper<T>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.forEach
         **/
         forEach<T extends {}>(
             callback: ObjectIterator<T, void>,
-            thisArg?: any): LoDashObjectWrapper<T>;
+            thisArg?: any): LoDashImplicitObjectWrapper<T>;
 
         /**
         * @see _.forEach
         **/
         each<T extends {}>(
             callback: ObjectIterator<T, void>,
-            thisArg?: any): LoDashObjectWrapper<T>;
+            thisArg?: any): LoDashImplicitObjectWrapper<T>;
     }
 
     //_.forEachRight
@@ -3923,29 +4126,29 @@ declare module _ {
             thisArg?: any): Dictionary<T>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.forEachRight
         **/
         forEachRight(
             callback: ListIterator<T, void>,
-            thisArg?: any): LoDashArrayWrapper<T>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.forEachRight
         **/
         eachRight(
             callback: ListIterator<T, void>,
-            thisArg?: any): LoDashArrayWrapper<T>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.forEachRight
         **/
         forEachRight<T extends {}>(
             callback: ObjectIterator<T, void>,
-            thisArg?: any): LoDashObjectWrapper<Dictionary<T>>;
+            thisArg?: any): LoDashImplicitObjectWrapper<Dictionary<T>>;
 
         /**
         * @see _.forEachRight
@@ -3955,7 +4158,7 @@ declare module _ {
         **/
         eachRight<T extends {}>(
             callback: ObjectIterator<T, void>,
-            thisArg?: any): LoDashObjectWrapper<Dictionary<T>>;
+            thisArg?: any): LoDashImplicitObjectWrapper<Dictionary<T>>;
     }
 
     //_.groupBy
@@ -4045,46 +4248,46 @@ declare module _ {
             whereValue: W): Dictionary<TValue[]>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.groupBy
         **/
         groupBy(
             callback: ListIterator<T, any>,
-            thisArg?: any): _.LoDashObjectWrapper<_.Dictionary<T[]>>;
+            thisArg?: any): _.LoDashImplicitObjectWrapper<_.Dictionary<T[]>>;
 
         /**
         * @see _.groupBy
         **/
         groupBy(
-            pluckValue: string): _.LoDashObjectWrapper<_.Dictionary<T[]>>;
+            pluckValue: string): _.LoDashImplicitObjectWrapper<_.Dictionary<T[]>>;
 
         /**
         * @see _.groupBy
         **/
         groupBy<W>(
-            whereValue: W): _.LoDashObjectWrapper<_.Dictionary<T[]>>;
+            whereValue: W): _.LoDashImplicitObjectWrapper<_.Dictionary<T[]>>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.groupBy
         **/
         groupBy<TValue>(
             callback: ListIterator<TValue, any>,
-            thisArg?: any): _.LoDashObjectWrapper<_.Dictionary<TValue[]>>;
+            thisArg?: any): _.LoDashImplicitObjectWrapper<_.Dictionary<TValue[]>>;
 
         /**
         * @see _.groupBy
         **/
         groupBy<TValue>(
-            pluckValue: string): _.LoDashObjectWrapper<_.Dictionary<TValue[]>>;
+            pluckValue: string): _.LoDashImplicitObjectWrapper<_.Dictionary<TValue[]>>;
 
         /**
         * @see _.groupBy
         **/
         groupBy<W, TValue>(
-            whereValue: W): _.LoDashObjectWrapper<_.Dictionary<TValue[]>>;
+            whereValue: W): _.LoDashImplicitObjectWrapper<_.Dictionary<TValue[]>>;
     }
 
     //_.indexBy
@@ -4286,52 +4489,52 @@ declare module _ {
         ): boolean[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.map
          */
         map<TResult>(
             iteratee?: ListIterator<T, TResult>,
             thisArg?: any
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
 
         /**
          * @see _.map
          */
         map<TResult>(
             iteratee?: string
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
 
         /**
          * @see _.map
          */
         map<TObject extends {}>(
             iteratee?: TObject
-        ): LoDashArrayWrapper<boolean>;
+        ): LoDashImplicitArrayWrapper<boolean>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.map
          */
         map<TValue, TResult>(
             iteratee?: ListIterator<TValue, TResult>|DictionaryIterator<TValue, TResult>,
             thisArg?: any
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
 
         /**
          * @see _.map
          */
         map<TValue, TResult>(
             iteratee?: string
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
 
         /**
          * @see _.map
          */
         map<TObject extends {}>(
             iteratee?: TObject
-        ): LoDashArrayWrapper<boolean>;
+        ): LoDashImplicitArrayWrapper<boolean>;
     }
 
     //_.ceil
@@ -4345,7 +4548,7 @@ declare module _ {
         ceil(n: number, precision?: number): number;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.ceil
          */
@@ -4363,7 +4566,7 @@ declare module _ {
         floor(n: number, precision?: number): number;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.floor
          */
@@ -4381,7 +4584,7 @@ declare module _ {
         round(n: number, precision?: number): number;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.round
          */
@@ -4462,7 +4665,7 @@ declare module _ {
             property: string): number;
     }
 
-    interface LoDashNumberArrayWrapper {
+    interface LoDashImplicitNumberArrayWrapper {
         /**
         * @see _.sum
         **/
@@ -4476,7 +4679,7 @@ declare module _ {
             thisArg?: any): number;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.sum
         **/
@@ -4497,7 +4700,7 @@ declare module _ {
             property: string): number;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.sum
         **/
@@ -4545,20 +4748,20 @@ declare module _ {
             property: string|string[]): any[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.pluck
         **/
         pluck<TResult>(
-            property: string): LoDashArrayWrapper<TResult>;
+            property: string): LoDashImplicitArrayWrapper<TResult>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.pluck
         **/
         pluck<TResult>(
-            property: string): LoDashArrayWrapper<TResult>;
+            property: string): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.partition
@@ -4640,73 +4843,73 @@ declare module _ {
             pluckValue: string): T[][];
     }
 
-    interface LoDashStringWrapper {
+    interface LoDashImplicitStringWrapper {
         /**
          * @see _.partition
          */
         partition(
             callback: ListIterator<string, boolean>,
-            thisArg?: any): LoDashArrayWrapper<string[]>;
+            thisArg?: any): LoDashImplicitArrayWrapper<string[]>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.partition
          */
         partition(
             callback: ListIterator<T, boolean>,
-            thisArg?: any): LoDashArrayWrapper<T[]>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T[]>;
         /**
          * @see _.partition
          */
         partition<W>(
-            whereValue: W): LoDashArrayWrapper<T[]>;
+            whereValue: W): LoDashImplicitArrayWrapper<T[]>;
         /**
          * @see _.partition
          */
         partition(
             path: string,
-            srcValue: any): LoDashArrayWrapper<T[]>;
+            srcValue: any): LoDashImplicitArrayWrapper<T[]>;
         /**
          * @see _.partition
          */
         partition(
-            pluckValue: string): LoDashArrayWrapper<T[]>;
+            pluckValue: string): LoDashImplicitArrayWrapper<T[]>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.partition
          */
         partition<TResult>(
             callback: ListIterator<TResult, boolean>,
-            thisArg?: any): LoDashArrayWrapper<TResult[]>;
+            thisArg?: any): LoDashImplicitArrayWrapper<TResult[]>;
 
         /**
          * @see _.partition
          */
         partition<TResult>(
             callback: DictionaryIterator<TResult, boolean>,
-            thisArg?: any): LoDashArrayWrapper<TResult[]>;
+            thisArg?: any): LoDashImplicitArrayWrapper<TResult[]>;
 
         /**
          * @see _.partition
          */
         partition<W, TResult>(
-            whereValue: W): LoDashArrayWrapper<TResult[]>;
+            whereValue: W): LoDashImplicitArrayWrapper<TResult[]>;
 
         /**
          * @see _.partition
          */
         partition<TResult>(
             path: string,
-            srcValue: any): LoDashArrayWrapper<TResult[]>;
+            srcValue: any): LoDashImplicitArrayWrapper<TResult[]>;
 
         /**
          * @see _.partition
          */
         partition<TResult>(
-            pluckValue: string): LoDashArrayWrapper<TResult[]>;
+            pluckValue: string): LoDashImplicitArrayWrapper<TResult[]>;
     }
 
     //_.reduce
@@ -4874,7 +5077,7 @@ declare module _ {
             thisArg?: any): TResult;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
          /**
         * @see _.reduce
         **/
@@ -4921,7 +5124,7 @@ declare module _ {
             thisArg?: any): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
          /**
         * @see _.reduce
         **/
@@ -5165,25 +5368,25 @@ declare module _ {
             whereValue: W): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.reject
         **/
         reject(
             callback: ListIterator<T, boolean>,
-            thisArg?: any): LoDashArrayWrapper<T>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.reject
         * @param pluckValue _.pluck style callback
         **/
-        reject(pluckValue: string): LoDashArrayWrapper<T>;
+        reject(pluckValue: string): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.reject
         * @param whereValue _.where style callback
         **/
-        reject<W>(whereValue: W): LoDashArrayWrapper<T>;
+        reject<W>(whereValue: W): LoDashImplicitArrayWrapper<T>;
     }
 
     //_.sample
@@ -5224,16 +5427,16 @@ declare module _ {
         sample<T>(collection: Dictionary<T>, n: number): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.sample
          **/
-        sample(n: number): LoDashArrayWrapper<T>;
+        sample(n: number): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.sample
          **/
-        sample(): LoDashWrapper<T>;
+        sample(): LoDashImplicitWrapper<T>;
     }
 
     //_.shuffle
@@ -5257,18 +5460,18 @@ declare module _ {
         shuffle<T>(collection: Dictionary<T>): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.shuffle
          **/
-        shuffle(): LoDashArrayWrapper<T>;
+        shuffle(): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.shuffle
          **/
-        shuffle(): LoDashArrayWrapper<T>;
+        shuffle(): LoDashImplicitArrayWrapper<T>;
     }
 
     //_.size
@@ -5301,14 +5504,14 @@ declare module _ {
         size(aString: string): number;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.size
          **/
         size(): number;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.size
          **/
@@ -5371,7 +5574,7 @@ declare module _ {
         ): boolean;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.some
          */
@@ -5396,7 +5599,7 @@ declare module _ {
         ): boolean;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.some
          */
@@ -5497,31 +5700,31 @@ declare module _ {
         ): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.sortBy
         **/
         sortBy<TSort>(
             iteratee?: ListIterator<T, TSort>,
-            thisArg?: any): LoDashArrayWrapper<T>;
+            thisArg?: any): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.sortBy
         * @param pluckValue _.pluck style callback
         **/
-        sortBy(pluckValue: string): LoDashArrayWrapper<T>;
+        sortBy(pluckValue: string): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.sortBy
         * @param whereValue _.where style callback
         **/
-        sortBy<W>(whereValue: W): LoDashArrayWrapper<T>;
+        sortBy<W>(whereValue: W): LoDashImplicitArrayWrapper<T>;
 
         /**
          * Sorts by all the given arguments, using either ListIterator, pluckValue, or whereValue foramts
          * @param args The rules by which to sort
          */
-        sortByAll(...args: (ListIterator<T, boolean>|Object|string)[]): LoDashArrayWrapper<T>;
+        sortByAll(...args: (ListIterator<T, boolean>|Object|string)[]): LoDashImplicitArrayWrapper<T>;
     }
 
     //_.sortByAll
@@ -5570,18 +5773,18 @@ declare module _ {
             ...iteratees: (ListIterator<T, any>|string|Object)[]): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.sortByAll
         **/
         sortByAll(
-            iteratees: (ListIterator<T, any>|string|Object)[]): LoDashArrayWrapper<T>;
+            iteratees: (ListIterator<T, any>|string|Object)[]): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.sortByAll
         **/
         sortByAll(
-            ...iteratees: (ListIterator<T, any>|string|Object)[]): LoDashArrayWrapper<T>;
+            ...iteratees: (ListIterator<T, any>|string|Object)[]): LoDashImplicitArrayWrapper<T>;
     }
 
     //_.sortByOrder
@@ -5633,20 +5836,20 @@ declare module _ {
             orders?: string[]): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.sortByOrder
         **/
         sortByOrder(
             iteratees: (ListIterator<T, any>|string|Object)[],
-            orders?: boolean[]): LoDashArrayWrapper<T>;
+            orders?: boolean[]): LoDashImplicitArrayWrapper<T>;
 
         /**
         * @see _.sortByOrder
         **/
         sortByOrder(
             iteratees: (ListIterator<T, any>|string|Object)[],
-            orders?: string[]): LoDashArrayWrapper<T>;
+            orders?: string[]): LoDashImplicitArrayWrapper<T>;
     }
 
     //_.where
@@ -5677,11 +5880,11 @@ declare module _ {
             properties: U): T[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
         * @see _.where
         **/
-        where<U extends {}>(properties: U): LoDashArrayWrapper<T>;
+        where<U extends {}>(properties: U): LoDashImplicitArrayWrapper<T>;
     }
 
     /********
@@ -5691,13 +5894,27 @@ declare module _ {
     //_.now
     interface LoDashStatic {
         /**
-        * Gets the number of milliseconds that have elapsed since the Unix epoch
-        * (1 January 1970 00:00:00 UTC).
-        * @return The number of milliseconds.
-        **/
+         * Gets the number of milliseconds that have elapsed since the Unix epoch (1 January 1970 00:00:00 UTC).
+         *
+         * @return The number of milliseconds.
+         */
         now(): number;
     }
 
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.now
+         */
+        now(): number;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.now
+         */
+        now(): LoDashExplicitWrapper<number>;
+    }
+
     /*************
      * Functions *
      *************/
@@ -5716,11 +5933,11 @@ declare module _ {
             func: Function): Function;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
         * @see _.after
         **/
-        after(func: Function): LoDashObjectWrapper<Function>;
+        after(func: Function): LoDashImplicitObjectWrapper<Function>;
     }
 
     //_.ary
@@ -5735,11 +5952,11 @@ declare module _ {
         ary<TResult extends Function>(func: Function, n?: number, guard?: Object): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.ary
          */
-        ary<TResult extends Function>(n?: number, guard?: Object): LoDashObjectWrapper<TResult>;
+        ary<TResult extends Function>(n?: number, guard?: Object): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.backflow
@@ -5750,11 +5967,11 @@ declare module _ {
         backflow<TResult extends Function>(...funcs: Function[]): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.flowRight
          **/
-        backflow<TResult extends Function>(...funcs: Function[]): LoDashObjectWrapper<TResult>;
+        backflow<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.before
@@ -5770,7 +5987,7 @@ declare module _ {
         before<TFunc extends Function>(n: number, func: TFunc): TFunc;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @sed _.before
          */
@@ -5793,13 +6010,13 @@ declare module _ {
             ...args: any[]): (...args: any[]) => any;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.bind
         **/
         bind(
             thisArg: any,
-            ...args: any[]): LoDashObjectWrapper<(...args: any[]) => any>;
+            ...args: any[]): LoDashImplicitObjectWrapper<(...args: any[]) => any>;
     }
 
     //_.bindAll
@@ -5818,11 +6035,11 @@ declare module _ {
             ...methodNames: string[]): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.bindAll
         **/
-        bindAll(...methodNames: string[]): LoDashWrapper<T>;
+        bindAll(...methodNames: string[]): LoDashImplicitWrapper<T>;
     }
 
     //_.bindKey
@@ -5843,13 +6060,13 @@ declare module _ {
             ...args: any[]): Function;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.bindKey
         **/
         bindKey(
             key: string,
-            ...args: any[]): LoDashObjectWrapper<Function>;
+            ...args: any[]): LoDashImplicitObjectWrapper<Function>;
     }
 
     //_.compose
@@ -5860,11 +6077,11 @@ declare module _ {
         compose<TResult extends Function>(...funcs: Function[]): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.flowRight
          */
-        compose<TResult extends Function>(...funcs: Function[]): LoDashObjectWrapper<TResult>;
+        compose<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.createCallback
@@ -5893,22 +6110,22 @@ declare module _ {
             argCount?: number): () => boolean;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
         * @see _.createCallback
         **/
         createCallback(
             thisArg?: any,
-            argCount?: number): LoDashObjectWrapper<() => any>;
+            argCount?: number): LoDashImplicitObjectWrapper<() => any>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.createCallback
         **/
         createCallback(
             thisArg?: any,
-            argCount?: number): LoDashObjectWrapper<() => any>;
+            argCount?: number): LoDashImplicitObjectWrapper<() => any>;
     }
 
     //_.curry
@@ -6006,11 +6223,11 @@ declare module _ {
         (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.curry
         **/
-        curry<TResult extends Function>(arity?: number): LoDashObjectWrapper<TResult>;
+        curry<TResult extends Function>(arity?: number): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.curryRight
@@ -6067,11 +6284,11 @@ declare module _ {
           arity?: number): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.curryRight
          **/
-        curryRight<TResult extends Function>(arity?: number): LoDashObjectWrapper<TResult>;
+        curryRight<TResult extends Function>(arity?: number): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.debounce
@@ -6099,13 +6316,13 @@ declare module _ {
             options?: DebounceSettings): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.debounce
         **/
         debounce(
             wait: number,
-            options?: DebounceSettings): LoDashObjectWrapper<Function>;
+            options?: DebounceSettings): LoDashImplicitObjectWrapper<Function>;
     }
 
     interface DebounceSettings {
@@ -6139,11 +6356,11 @@ declare module _ {
             ...args: any[]): number;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.defer
         **/
-        defer(...args: any[]): LoDashWrapper<number>;
+        defer(...args: any[]): LoDashImplicitWrapper<number>;
     }
 
     //_.delay
@@ -6162,13 +6379,13 @@ declare module _ {
             ...args: any[]): number;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.delay
         **/
         delay(
             wait: number,
-            ...args: any[]): LoDashWrapper<number>;
+            ...args: any[]): LoDashImplicitWrapper<number>;
     }
 
     //_.flow
@@ -6182,11 +6399,11 @@ declare module _ {
         flow<TResult extends Function>(...funcs: Function[]): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.flow
          **/
-        flow<TResult extends Function>(...funcs: Function[]): LoDashObjectWrapper<TResult>;
+        flow<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.flowRight
@@ -6200,11 +6417,11 @@ declare module _ {
         flowRight<TResult extends Function>(...funcs: Function[]): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.flowRight
          **/
-        flowRight<TResult extends Function>(...funcs: Function[]): LoDashObjectWrapper<TResult>;
+        flowRight<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.memoize
@@ -6227,11 +6444,11 @@ declare module _ {
             resolver?: Function): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.memoize
          */
-        memoize<TResult extends MemoizedFunction>(resolver?: Function): LoDashObjectWrapper<TResult>;
+        memoize<TResult extends MemoizedFunction>(resolver?: Function): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.modArgs
@@ -6257,16 +6474,16 @@ declare module _ {
         ): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.modArgs
          */
-        modArgs<TResult extends Function>(...transforms: Function[]): LoDashObjectWrapper<TResult>;
+        modArgs<TResult extends Function>(...transforms: Function[]): LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.modArgs
          */
-        modArgs<TResult extends Function>(transforms: Function[]): LoDashObjectWrapper<TResult>;
+        modArgs<TResult extends Function>(transforms: Function[]): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.negate
@@ -6285,16 +6502,16 @@ declare module _ {
         negate<T extends Function, TResult extends Function>(predicate: T): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.negate
          */
-        negate(): LoDashObjectWrapper<(...args: any[]) => boolean>;
+        negate(): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>;
 
         /**
          * @see _.negate
          */
-        negate<TResult extends Function>(): LoDashObjectWrapper<TResult>;
+        negate<TResult extends Function>(): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.once
@@ -6309,11 +6526,11 @@ declare module _ {
         once<T extends Function>(func: T): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.once
          */
-        once(): LoDashObjectWrapper<T>;
+        once(): LoDashImplicitObjectWrapper<T>;
     }
 
     //_.partial
@@ -6363,16 +6580,16 @@ declare module _ {
         rearg<TResult extends Function>(func: Function, ...indexes: number[]): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.rearg
          */
-        rearg<TResult extends Function>(indexes: number[]): LoDashObjectWrapper<TResult>;
+        rearg<TResult extends Function>(indexes: number[]): LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.rearg
          */
-        rearg<TResult extends Function>(...indexes: number[]): LoDashObjectWrapper<TResult>;
+        rearg<TResult extends Function>(...indexes: number[]): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.restParam
@@ -6392,11 +6609,11 @@ declare module _ {
         restParam<TResult extends Function, TFunc extends Function>(func: TFunc, start?: number): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.restParam
          */
-        restParam<TResult extends Function>(start?: number): LoDashObjectWrapper<TResult>;
+        restParam<TResult extends Function>(start?: number): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.spread
@@ -6410,11 +6627,11 @@ declare module _ {
         spread<TResult extends Function>(func: Function): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.spread
          */
-        spread<TResult extends Function>(): LoDashObjectWrapper<TResult>;
+        spread<TResult extends Function>(): LoDashImplicitObjectWrapper<TResult>;
     }
 
 
@@ -6504,7 +6721,7 @@ declare module _ {
             thisArg?: any): T;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.clone
          */
@@ -6521,7 +6738,7 @@ declare module _ {
             thisArg?: any): T;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.clone
          */
@@ -6538,7 +6755,7 @@ declare module _ {
             thisArg?: any): T[];
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.clone
          */
@@ -6575,7 +6792,7 @@ declare module _ {
             thisArg?: any): T;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.cloneDeep
          */
@@ -6584,7 +6801,7 @@ declare module _ {
             thisArg?: any): T;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.cloneDeep
          */
@@ -6593,7 +6810,7 @@ declare module _ {
             thisArg?: any): T[];
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.cloneDeep
          */
@@ -6615,7 +6832,7 @@ declare module _ {
         ): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.isEqual
          */
@@ -6637,7 +6854,7 @@ declare module _ {
         gt(value: any, other: any): boolean;
     }
 
-    interface LoDashWrapperBase<T,TWrapper> {
+    interface LoDashImplicitWrapperBase<T,TWrapper> {
         /**
          * @see _.gt
          */
@@ -6655,7 +6872,7 @@ declare module _ {
         gte(value: any, other: any): boolean;
     }
 
-    interface LoDashWrapperBase<T,TWrapper> {
+    interface LoDashImplicitWrapperBase<T,TWrapper> {
         /**
          * @see _.gte
          */
@@ -6672,7 +6889,7 @@ declare module _ {
         isArguments(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.isArguments
          */
@@ -6689,7 +6906,7 @@ declare module _ {
         isArray(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T,TWrapper> {
+    interface LoDashImplicitWrapperBase<T,TWrapper> {
         /**
          * @see _.isArray
          */
@@ -6706,7 +6923,7 @@ declare module _ {
         isBoolean(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.isBoolean
          */
@@ -6723,7 +6940,7 @@ declare module _ {
         isDate(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.isDate
          */
@@ -6740,7 +6957,7 @@ declare module _ {
         isElement(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.isElement
          */
@@ -6758,7 +6975,7 @@ declare module _ {
         isEmpty(value?: any[]|Dictionary<any>|string|any): boolean;
     }
 
-    interface LoDashWrapperBase<T,TWrapper> {
+    interface LoDashImplicitWrapperBase<T,TWrapper> {
         /**
          * @see _.isEmpty
          */
@@ -6797,7 +7014,7 @@ declare module _ {
         ): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.isEqual
          */
@@ -6819,7 +7036,7 @@ declare module _ {
         isError(value: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.isError
          */
@@ -6837,7 +7054,7 @@ declare module _ {
         isFinite(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.isFinite
          */
@@ -6854,7 +7071,7 @@ declare module _ {
         isFunction(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.isFunction
          */
@@ -6881,7 +7098,7 @@ declare module _ {
         isMatch(object: Object, source: Object, customizer?: isMatchCustomizer, thisArg?: any): boolean;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.isMatch
          */
@@ -6899,7 +7116,7 @@ declare module _ {
         isNaN(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.isNaN
          */
@@ -6916,7 +7133,7 @@ declare module _ {
         isNative(value: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * see _.isNative
          */
@@ -6933,7 +7150,7 @@ declare module _ {
         isNull(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * see _.isNull
          */
@@ -6951,7 +7168,7 @@ declare module _ {
         isNumber(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * see _.isNumber
          */
@@ -6969,7 +7186,7 @@ declare module _ {
         isObject(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * see _.isObject
          */
@@ -6990,7 +7207,7 @@ declare module _ {
         isPlainObject(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * see _.isPlainObject
          */
@@ -7007,7 +7224,7 @@ declare module _ {
         isRegExp(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * see _.isRegExp
          */
@@ -7024,7 +7241,7 @@ declare module _ {
         isString(value?: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * see _.isString
          */
@@ -7041,7 +7258,7 @@ declare module _ {
         isTypedArray(value: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * see _.isTypedArray
          */
@@ -7058,7 +7275,7 @@ declare module _ {
         isUndefined(value: any): boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * see _.isUndefined
          */
@@ -7076,7 +7293,7 @@ declare module _ {
         lt(value: any, other: any): boolean;
     }
 
-    interface LoDashWrapperBase<T,TWrapper> {
+    interface LoDashImplicitWrapperBase<T,TWrapper> {
         /**
          * @see _.lt
          */
@@ -7094,7 +7311,7 @@ declare module _ {
         lte(value: any, other: any): boolean;
     }
 
-    interface LoDashWrapperBase<T,TWrapper> {
+    interface LoDashImplicitWrapperBase<T,TWrapper> {
         /**
          * @see _.lte
          */
@@ -7132,25 +7349,25 @@ declare module _ {
         toArray(value?: any): any[];
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.toArray
          */
-        toArray<TResult>(): LoDashArrayWrapper<TResult>;
+        toArray<TResult>(): LoDashImplicitArrayWrapper<TResult>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.toArray
          */
-        toArray(): LoDashArrayWrapper<T>;
+        toArray(): LoDashImplicitArrayWrapper<T>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.toArray
          */
-        toArray<TResult>(): LoDashArrayWrapper<TResult>;
+        toArray<TResult>(): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.toPlainObject
@@ -7165,11 +7382,11 @@ declare module _ {
         toPlainObject<TResult extends {}>(value?: any): TResult;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.toPlainObject
          */
-        toPlainObject<TResult extends {}>(): LoDashObjectWrapper<TResult>;
+        toPlainObject<TResult extends {}>(): LoDashImplicitObjectWrapper<TResult>;
     }
 
     /********
@@ -7187,7 +7404,7 @@ declare module _ {
         add(augend: number, addend: number): number;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.add
          */
@@ -7248,7 +7465,7 @@ declare module _ {
         ): T;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.max
          */
@@ -7273,7 +7490,7 @@ declare module _ {
         ): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.max
          */
@@ -7352,7 +7569,7 @@ declare module _ {
         ): T;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.min
          */
@@ -7377,7 +7594,7 @@ declare module _ {
         ): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.min
          */
@@ -7425,7 +7642,7 @@ declare module _ {
         inRange(n: number, end: number): boolean;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.inRange
          */
@@ -7469,7 +7686,7 @@ declare module _ {
         random(floating?: boolean): number;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.random
          */
@@ -7583,7 +7800,7 @@ declare module _ {
             thisArg?: any): Result;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.assign
         **/
@@ -7692,11 +7909,11 @@ declare module _ {
         create<TResult extends {}>(prototype: Object, properties?: Object): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.create
          */
-        create<TResult extends {}>(properties?: Object): LoDashObjectWrapper<TResult>;
+        create<TResult extends {}>(properties?: Object): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.defaults
@@ -7714,11 +7931,11 @@ declare module _ {
             ...sources: any[]): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.defaults
         **/
-        defaults<T, TResult>(...sources: any[]): LoDashObjectWrapper<TResult>
+        defaults<T, TResult>(...sources: any[]): LoDashImplicitObjectWrapper<TResult>
     }
 
     //_.defaultsDeep
@@ -7734,11 +7951,11 @@ declare module _ {
             ...sources: any[]): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.defaultsDeep
          **/
-        defaultsDeep<TResult>(...sources: any[]): LoDashObjectWrapper<TResult>
+        defaultsDeep<TResult>(...sources: any[]): LoDashImplicitObjectWrapper<TResult>
     }
 
     //_.findKey
@@ -7794,7 +8011,7 @@ declare module _ {
         ): string;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.findKey
          */
@@ -7879,7 +8096,7 @@ declare module _ {
         ): string;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.findLastKey
          */
@@ -7937,13 +8154,13 @@ declare module _ {
             thisArg?: any): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.forIn
         **/
         forIn<T extends {}>(
             callback: ObjectIterator<T, void>,
-            thisArg?: any): _.LoDashObjectWrapper<T>;
+            thisArg?: any): _.LoDashImplicitObjectWrapper<T>;
     }
 
     //_.forInRight
@@ -7970,13 +8187,13 @@ declare module _ {
             thisArg?: any): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.forInRight
         **/
         forInRight<T extends {}>(
             callback: ObjectIterator<T, void>,
-            thisArg?: any): _.LoDashObjectWrapper<T>;
+            thisArg?: any): _.LoDashImplicitObjectWrapper<T>;
     }
 
     //_.forOwn
@@ -8004,13 +8221,13 @@ declare module _ {
             thisArg?: any): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.forOwn
         **/
         forOwn<T extends {}>(
             callback: ObjectIterator<T, void>,
-            thisArg?: any): _.LoDashObjectWrapper<T>;
+            thisArg?: any): _.LoDashImplicitObjectWrapper<T>;
     }
 
     //_.forOwnRight
@@ -8036,13 +8253,13 @@ declare module _ {
             thisArg?: any): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.forOwnRight
         **/
         forOwnRight<T extends {}>(
             callback: ObjectIterator<T, void>,
-            thisArg?: any): _.LoDashObjectWrapper<T>;
+            thisArg?: any): _.LoDashImplicitObjectWrapper<T>;
     }
 
     //_.functions
@@ -8061,16 +8278,16 @@ declare module _ {
         methods(object: any): string[];
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.functions
         **/
-        functions(): _.LoDashArrayWrapper<string>;
+        functions(): _.LoDashImplicitArrayWrapper<string>;
 
         /**
         * @see _.functions
         **/
-        methods(): _.LoDashArrayWrapper<string>;
+        methods(): _.LoDashImplicitArrayWrapper<string>;
     }
 
     //_.get
@@ -8089,7 +8306,7 @@ declare module _ {
         ): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.get
          **/
@@ -8110,7 +8327,7 @@ declare module _ {
         has(object: any, path: string|number|boolean|Array<string|number|boolean>): boolean;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.has
          */
@@ -8130,11 +8347,11 @@ declare module _ {
         invert<T extends {}, TResult extends {}>(object: T, multiValue?: boolean): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.invert
          */
-        invert<TResult extends {}>(multiValue?: boolean): LoDashObjectWrapper<TResult>;
+        invert<TResult extends {}>(multiValue?: boolean): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.keys
@@ -8147,11 +8364,11 @@ declare module _ {
         keys(object?: any): string[];
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.keys
         **/
-        keys(): LoDashArrayWrapper<string>
+        keys(): LoDashImplicitArrayWrapper<string>
     }
 
     //_.keysIn
@@ -8164,11 +8381,11 @@ declare module _ {
         keysIn(object?: any): string[];
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.keysIn
          **/
-        keysIn(): LoDashArrayWrapper<string>
+        keysIn(): LoDashImplicitArrayWrapper<string>
     }
 
     //_.mapKeys
@@ -8214,52 +8431,52 @@ declare module _ {
         ): Dictionary<T>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.mapKeys
          */
         mapKeys<TKey>(
             iteratee?: ListIterator<T, TKey>,
             thisArg?: any
-        ): LoDashObjectWrapper<Dictionary<T>>;
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
 
         /**
          * @see _.mapKeys
          */
         mapKeys<TObject extends {}>(
             iteratee?: TObject
-        ): LoDashObjectWrapper<Dictionary<T>>;
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
 
         /**
          * @see _.mapKeys
          */
         mapKeys(
             iteratee?: string
-        ): LoDashObjectWrapper<Dictionary<T>>;
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.mapKeys
          */
         mapKeys<TResult, TKey>(
             iteratee?: ListIterator<TResult, TKey>|DictionaryIterator<TResult, TKey>,
             thisArg?: any
-        ): LoDashObjectWrapper<Dictionary<TResult>>;
+        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
 
         /**
          * @see _.mapKeys
          */
         mapKeys<TResult, TObject extends {}>(
             iteratee?: TObject
-        ): LoDashObjectWrapper<Dictionary<TResult>>;
+        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
 
         /**
          * @see _.mapKeys
          */
         mapKeys<TResult>(
             iteratee?: string
-        ): LoDashObjectWrapper<Dictionary<TResult>>;
+        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
     }
 
     //_.mapValues
@@ -8289,34 +8506,34 @@ declare module _ {
         mapValues<T>(obj: T, callback: ObjectIterator<any, any>, thisArg?: any): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.mapValues
          * TValue is the type of the property values of T.
          * TResult is the type output by the ObjectIterator function
          */
-        mapValues<TValue, TResult>(callback: ObjectIterator<TValue, TResult>, thisArg?: any): LoDashObjectWrapper<Dictionary<TResult>>;
+        mapValues<TValue, TResult>(callback: ObjectIterator<TValue, TResult>, thisArg?: any): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
 
         /**
          * @see _.mapValues
          * TResult is the type of the property specified by pluck.
          * T should be a Dictionary<Dictionary<TResult>>
          */
-        mapValues<TResult>(pluck: string): LoDashObjectWrapper<Dictionary<TResult>>;
+        mapValues<TResult>(pluck: string): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
 
         /**
          * @see _.mapValues
          * TResult is the type of the properties on the object specified by pluck.
          * T should be a Dictionary<Dictionary<Dictionary<TResult>>>
          */
-        mapValues<TResult>(pluck: string, where: Dictionary<TResult>): LoDashArrayWrapper<Dictionary<boolean>>;
+        mapValues<TResult>(pluck: string, where: Dictionary<TResult>): LoDashImplicitArrayWrapper<Dictionary<boolean>>;
 
         /**
          * @see _.mapValues
          * TResult is the type of the properties of each object in the values of T
          * T should be a Dictionary<Dictionary<TResult>>
          */
-        mapValues<TResult>(where: Dictionary<TResult>): LoDashArrayWrapper<boolean>;
+        mapValues<TResult>(where: Dictionary<TResult>): LoDashImplicitArrayWrapper<boolean>;
     }
 
     //_.merge
@@ -8390,7 +8607,7 @@ declare module _ {
         ): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.merge
          */
@@ -8398,7 +8615,7 @@ declare module _ {
             source: TSource,
             customizer?: MergeCustomizer,
             thisArg?: any
-        ): LoDashObjectWrapper<TResult>;
+        ): LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.merge
@@ -8408,7 +8625,7 @@ declare module _ {
             source2: TSource2,
             customizer?: MergeCustomizer,
             thisArg?: any
-        ): LoDashObjectWrapper<TResult>;
+        ): LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.merge
@@ -8419,7 +8636,7 @@ declare module _ {
             source3: TSource3,
             customizer?: MergeCustomizer,
             thisArg?: any
-        ): LoDashObjectWrapper<TResult>;
+        ): LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.merge
@@ -8431,14 +8648,14 @@ declare module _ {
             source4: TSource4,
             customizer?: MergeCustomizer,
             thisArg?: any
-        ): LoDashObjectWrapper<TResult>;
+        ): LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.merge
          */
         merge<TResult>(
             ...otherArgs: any[]
-        ): LoDashObjectWrapper<TResult>;
+        ): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.omit
@@ -8473,25 +8690,25 @@ declare module _ {
             thisArg?: any): Omitted;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.omit
         **/
         omit<Omitted>(
-            ...keys: string[]): LoDashObjectWrapper<Omitted>;
+            ...keys: string[]): LoDashImplicitObjectWrapper<Omitted>;
 
         /**
         * @see _.omit
         **/
         omit<Omitted>(
-            keys: string[]): LoDashObjectWrapper<Omitted>;
+            keys: string[]): LoDashImplicitObjectWrapper<Omitted>;
 
         /**
         * @see _.omit
         **/
         omit<Omitted>(
             callback: ObjectIterator<any, boolean>,
-            thisArg?: any): LoDashObjectWrapper<Omitted>;
+            thisArg?: any): LoDashImplicitObjectWrapper<Omitted>;
     }
 
     //_.pairs
@@ -8505,11 +8722,11 @@ declare module _ {
         pairs(object?: any): any[][];
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.pairs
         **/
-        pairs(): LoDashArrayWrapper<any[]>;
+        pairs(): LoDashImplicitArrayWrapper<any[]>;
     }
 
     //_.pick
@@ -8541,21 +8758,21 @@ declare module _ {
         ): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.pick
          */
         pick<TResult extends Object>(
             predicate: ObjectIterator<any, boolean>,
             thisArg?: any
-        ): LoDashObjectWrapper<TResult>;
+        ): LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.pick
          */
         pick<TResult extends Object>(
             ...predicate: Array<string|number|boolean|Array<string|number|boolean>>
-        ): LoDashObjectWrapper<TResult>;
+        ): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.result
@@ -8576,7 +8793,7 @@ declare module _ {
         ): TResult;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.result
          */
@@ -8603,14 +8820,14 @@ declare module _ {
         ): T;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.set
          */
         set(
             path: StringRepresentable|StringRepresentable[],
             value: any
-        ): LoDashObjectWrapper<T>;
+        ): LoDashImplicitObjectWrapper<T>;
     }
 
     //_.transform
@@ -8665,7 +8882,7 @@ declare module _ {
         ): TResult[];
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.transform
          */
@@ -8673,7 +8890,7 @@ declare module _ {
             iteratee?: MemoVoidArrayIterator<T, TResult[]>,
             accumulator?: TResult[],
             thisArg?: any
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
 
         /**
          * @see _.transform
@@ -8682,10 +8899,10 @@ declare module _ {
             iteratee?: MemoVoidArrayIterator<T, Dictionary<TResult>>,
             accumulator?: Dictionary<TResult>,
             thisArg?: any
-        ): LoDashObjectWrapper<Dictionary<TResult>>;
+        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.transform
          */
@@ -8693,7 +8910,7 @@ declare module _ {
             iteratee?: MemoVoidDictionaryIterator<T, Dictionary<TResult>>,
             accumulator?: Dictionary<TResult>,
             thisArg?: any
-        ): LoDashObjectWrapper<Dictionary<TResult>>;
+        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
 
         /**
          * @see _.transform
@@ -8702,7 +8919,7 @@ declare module _ {
             iteratee?: MemoVoidDictionaryIterator<T, TResult[]>,
             accumulator?: TResult[],
             thisArg?: any
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
     }
 
     //_.values
@@ -8715,11 +8932,11 @@ declare module _ {
         values<T>(object?: any): T[];
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.values
         **/
-        values<TResult>(): LoDashObjectWrapper<TResult[]>;
+        values<TResult>(): LoDashImplicitObjectWrapper<TResult[]>;
     }
 
     //_.valuesIn
@@ -8732,11 +8949,11 @@ declare module _ {
         valuesIn<T>(object?: any): T[];
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
         * @see _.valuesIn
         **/
-        valuesIn<TResult>(): LoDashObjectWrapper<TResult[]>;
+        valuesIn<TResult>(): LoDashImplicitObjectWrapper<TResult[]>;
     }
 
     /**********
@@ -8753,7 +8970,7 @@ declare module _ {
         camelCase(string?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.camelCase
          */
@@ -8765,7 +8982,7 @@ declare module _ {
         capitalize(string?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.capitalize
          */
@@ -8783,7 +9000,7 @@ declare module _ {
         deburr(string?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.deburr
          */
@@ -8802,7 +9019,7 @@ declare module _ {
         endsWith(string?: string, target?: string, position?: number): boolean;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.endsWith
          */
@@ -8819,7 +9036,7 @@ declare module _ {
         escape(string?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.escape
          */
@@ -8837,7 +9054,7 @@ declare module _ {
         escapeRegExp(string?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.escapeRegExp
          */
@@ -8854,7 +9071,7 @@ declare module _ {
         kebabCase(string?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.kebabCase
          */
@@ -8873,7 +9090,7 @@ declare module _ {
     }
 
     //_.pad
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.pad
          */
@@ -8894,7 +9111,7 @@ declare module _ {
     }
 
     //_.padLeft
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.padLeft
          */
@@ -8915,7 +9132,7 @@ declare module _ {
     }
 
     //_.padRight
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.padRight
          */
@@ -8935,7 +9152,7 @@ declare module _ {
         parseInt(string: string, radix?: number): number;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.parseInt
          */
@@ -8953,7 +9170,7 @@ declare module _ {
         repeat(string?: string, n?: number): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.repeat
          */
@@ -8970,7 +9187,7 @@ declare module _ {
         snakeCase(string?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.snakeCase
          */
@@ -8987,7 +9204,7 @@ declare module _ {
         startCase(string?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.startCase
          */
@@ -9006,7 +9223,7 @@ declare module _ {
         startsWith(string?: string, target?: string, position?: number): boolean;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.startsWith
          */
@@ -9050,7 +9267,7 @@ declare module _ {
             options?: TemplateSettings): TemplateExecutor;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.template
          */
@@ -9068,7 +9285,7 @@ declare module _ {
         trim(string?: string, chars?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.trim
          */
@@ -9086,7 +9303,7 @@ declare module _ {
         trimLeft(string?: string, chars?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.trimLeft
          */
@@ -9104,7 +9321,7 @@ declare module _ {
         trimRight(string?: string, chars?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.trimRight
          */
@@ -9132,7 +9349,7 @@ declare module _ {
         trunc(string?: string, options?: TruncOptions|number): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.trunc
          */
@@ -9150,7 +9367,7 @@ declare module _ {
         unescape(string?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.unescape
          */
@@ -9168,7 +9385,7 @@ declare module _ {
         words(string?: string, pattern?: string|RegExp): string[];
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.words
          */
@@ -9190,7 +9407,7 @@ declare module _ {
         attempt<TResult>(func: (...args: any[]) => TResult): TResult|Error;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.attempt
          */
@@ -9236,23 +9453,23 @@ declare module _ {
         callback<TResult>(): (value: TResult) => TResult;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.callback
          */
-        callback<TResult>(thisArg?: any): LoDashObjectWrapper<(object: any) => TResult>;
+        callback<TResult>(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => TResult>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.callback
          */
-        callback(thisArg?: any): LoDashObjectWrapper<(object: any) => boolean>;
+        callback(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => boolean>;
 
         /**
          * @see _.callback
          */
-        callback<TResult>(thisArg?: any): LoDashObjectWrapper<(...args: any[]) => TResult>;
+        callback<TResult>(thisArg?: any): LoDashImplicitObjectWrapper<(...args: any[]) => TResult>;
     }
 
     //_.identity
@@ -9265,21 +9482,21 @@ declare module _ {
         identity<T>(value?: T): T;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.identity
          */
         identity(): T;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.identity
          */
         identity(): T[];
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.identity
          */
@@ -9318,23 +9535,23 @@ declare module _ {
         iteratee<TResult>(): (value: TResult) => TResult;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.callback
          */
-        iteratee<TResult>(thisArg?: any): LoDashObjectWrapper<(object: any) => TResult>;
+        iteratee<TResult>(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => TResult>;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.callback
          */
-        iteratee(thisArg?: any): LoDashObjectWrapper<(object: any) => boolean>;
+        iteratee(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => boolean>;
 
         /**
          * @see _.callback
          */
-        iteratee<TResult>(thisArg?: any): LoDashObjectWrapper<(...args: any[]) => TResult>;
+        iteratee<TResult>(thisArg?: any): LoDashImplicitObjectWrapper<(...args: any[]) => TResult>;
     }
 
     //_.matches
@@ -9362,11 +9579,11 @@ declare module _ {
         ): (value: V) => boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.matches
          */
-        matches<V>(): LoDashObjectWrapper<(value: V) => boolean>;
+        matches<V>(): LoDashImplicitObjectWrapper<(value: V) => boolean>;
     }
 
     //_.matchesProperty
@@ -9395,20 +9612,20 @@ declare module _ {
         ): (value: V) => boolean;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.matchesProperty
          */
         matchesProperty<SrcValue>(
             srcValue: SrcValue
-        ): LoDashObjectWrapper<(value: any) => boolean>;
+        ): LoDashImplicitObjectWrapper<(value: any) => boolean>;
 
         /**
          * @see _.matchesProperty
          */
         matchesProperty<SrcValue, Value>(
             srcValue: SrcValue
-        ): LoDashObjectWrapper<(value: Value) => boolean>;
+        ): LoDashImplicitObjectWrapper<(value: Value) => boolean>;
     }
 
     //_.method
@@ -9428,28 +9645,28 @@ declare module _ {
         method<TResult>(path: any[], ...args: any[]): (object: any) => TResult;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.method
          */
-        method<TResult>(...args: any[]): LoDashWrapper<(object: any) => TResult>;
+        method<TResult>(...args: any[]): LoDashImplicitWrapper<(object: any) => TResult>;
 
         /**
          * @see _.method
          */
-        method<TResult>(...args: any[]): LoDashWrapper<(object: any) => TResult>;
+        method<TResult>(...args: any[]): LoDashImplicitWrapper<(object: any) => TResult>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.method
          */
-        method<TResult>(...args: any[]): LoDashWrapper<(object: any) => TResult>;
+        method<TResult>(...args: any[]): LoDashImplicitWrapper<(object: any) => TResult>;
 
         /**
          * @see _.method
          */
-        method<TResult>(...args: any[]): LoDashWrapper<(object: any) => TResult>;
+        method<TResult>(...args: any[]): LoDashImplicitWrapper<(object: any) => TResult>;
     }
 
     //_.methodOf
@@ -9464,11 +9681,11 @@ declare module _ {
         methodOf<TResult>(object: Object, ...args: any[]): (path: string | any[]) => TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.methodOf
          */
-        methodOf<TResult>(...args: any[]): LoDashObjectWrapper<(path: string | any[]) => TResult>;
+        methodOf<TResult>(...args: any[]): LoDashImplicitObjectWrapper<(path: string | any[]) => TResult>;
     }
 
     //_.mixin
@@ -9505,21 +9722,21 @@ declare module _ {
         ): TResult;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.mixin
          */
         mixin<TResult>(
             source: Dictionary<Function>,
             options?: MixinOptions
-        ): LoDashObjectWrapper<TResult>;
+        ): LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.mixin
          */
         mixin<TResult>(
             options?: MixinOptions
-        ): LoDashObjectWrapper<TResult>;
+        ): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.noConflict
@@ -9532,7 +9749,7 @@ declare module _ {
         noConflict(): typeof _;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.noConflict
          */
@@ -9548,7 +9765,7 @@ declare module _ {
         noop(...args: any[]): void;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.noop
          */
@@ -9565,18 +9782,18 @@ declare module _ {
         property<TObj, TResult>(path: string|string[]): (obj: TObj) => TResult;
     }
 
-    interface LoDashStringWrapper {
+    interface LoDashImplicitStringWrapper {
         /**
          * @see _.property
          */
-        property<TObj, TResult>(): LoDashObjectWrapper<(obj: TObj) => TResult>;
+        property<TObj, TResult>(): LoDashImplicitObjectWrapper<(obj: TObj) => TResult>;
     }
 
-    interface LoDashArrayWrapper<T> {
+    interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.property
          */
-        property<TObj, TResult>(): LoDashObjectWrapper<(obj: TObj) => TResult>;
+        property<TObj, TResult>(): LoDashImplicitObjectWrapper<(obj: TObj) => TResult>;
     }
 
     //_.propertyOf
@@ -9590,11 +9807,11 @@ declare module _ {
         propertyOf<T extends {}>(object: T): (path: string|string[]) => any;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.propertyOf
          */
-        propertyOf(): LoDashObjectWrapper<(path: string|string[]) => any>;
+        propertyOf(): LoDashImplicitObjectWrapper<(path: string|string[]) => any>;
     }
 
     //_.range
@@ -9621,13 +9838,13 @@ declare module _ {
             step?: number): number[];
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.range
          */
         range(
             end?: number,
-            step?: number): LoDashArrayWrapper<number>;
+            step?: number): LoDashImplicitArrayWrapper<number>;
     }
 
     //_.runInContext
@@ -9641,7 +9858,7 @@ declare module _ {
         runInContext(context?: Object): typeof _;
     }
 
-    interface LoDashObjectWrapper<T> {
+    interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.runInContext
          */
@@ -9671,19 +9888,19 @@ declare module _ {
         times(n: number): number[];
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.times
          */
         times<TResult>(
             iteratee: (num: number) => TResult,
             thisArgs?: any
-        ): LoDashArrayWrapper<TResult>;
+        ): LoDashImplicitArrayWrapper<TResult>;
 
         /**
          * @see _.times
          */
-        times(): LoDashArrayWrapper<number>;
+        times(): LoDashImplicitArrayWrapper<number>;
     }
 
     //_.uniqueId
@@ -9696,7 +9913,7 @@ declare module _ {
         uniqueId(prefix?: string): string;
     }
 
-    interface LoDashWrapper<T> {
+    interface LoDashImplicitWrapper<T> {
         /**
          * @see _.uniqueId
          */
@@ -9713,7 +9930,7 @@ declare module _ {
         constant<T>(value: T): () => T;
     }
 
-    interface LoDashWrapperBase<T, TWrapper> {
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
         /**
          * @see _.constant
          */