diff --git a/backbone/backbone-with-lodash-tests.ts b/backbone/backbone-with-lodash-tests.ts
index c4f5fdf4d..dc7ebd2de 100644
--- a/backbone/backbone-with-lodash-tests.ts
+++ b/backbone/backbone-with-lodash-tests.ts
@@ -1,5 +1,5 @@
 /// <reference path="../jquery/jquery.d.ts" />
-/// <reference path="../lodash/lodash.d.ts" />
+/// <reference path='../lodash/lodash-3.10.d.ts' />
 /// <reference path="./backbone-global.d.ts" />
 
 function test_events() {
diff --git a/bookshelf/bookshelf.d.ts b/bookshelf/bookshelf.d.ts
index 95aa38408..5d91927db 100644
--- a/bookshelf/bookshelf.d.ts
+++ b/bookshelf/bookshelf.d.ts
@@ -4,7 +4,7 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 /// <reference path="../bluebird/bluebird.d.ts" />
-/// <reference path="../lodash/lodash.d.ts" />
+/// <reference path='../lodash/lodash-3.10.d.ts' />
 /// <reference path="../knex/knex.d.ts" />
 
 declare module 'bookshelf' {
diff --git a/knex/knex-tests.ts b/knex/knex-tests.ts
index 1d468b260..83b476b16 100644
--- a/knex/knex-tests.ts
+++ b/knex/knex-tests.ts
@@ -1,5 +1,5 @@
 /// <reference path='knex.d.ts' />
-/// <reference path='../lodash/lodash.d.ts' />
+/// <reference path='../lodash/lodash-3.10.d.ts' />
 import Knex = require('knex');
 import _ = require('lodash');
 'use strict';
diff --git a/lodash-decorators/lodash-decorators-tests.ts b/lodash-decorators/lodash-decorators-tests.ts
index 60a659c8d..1ab2cad55 100644
--- a/lodash-decorators/lodash-decorators-tests.ts
+++ b/lodash-decorators/lodash-decorators-tests.ts
@@ -1,5 +1,5 @@
 /// <reference path="lodash-decorators.d.ts" />
-/// <reference path="../lodash/lodash.d.ts" />
+/// <reference path='../lodash/lodash-3.10.d.ts' />
 
 //
 // With Arguments
diff --git a/lodash-decorators/lodash-decorators.d.ts b/lodash-decorators/lodash-decorators.d.ts
index ac01c5cf6..586413899 100644
--- a/lodash-decorators/lodash-decorators.d.ts
+++ b/lodash-decorators/lodash-decorators.d.ts
@@ -3,7 +3,7 @@
 // Definitions by: Qubo <https://github.com/tkqubo>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-///<reference path="../lodash/lodash.d.ts"/>
+/// <reference path='../lodash/lodash-3.10.d.ts' />
 
 
 declare module "lodash-decorators" {
diff --git a/lodash/lodash-3.10.d.ts b/lodash/lodash-3.10.d.ts
new file mode 100644
index 000000000..c570cc11c
--- /dev/null
+++ b/lodash/lodash-3.10.d.ts
@@ -0,0 +1,14991 @@
+// Type definitions for Lo-Dash
+// Project: http://lodash.com/
+// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare var _: _.LoDashStatic;
+
+declare module _ {
+    interface LoDashStatic {
+        /**
+        * Creates a lodash object which wraps the given value to enable intuitive method chaining.
+        *
+        * In addition to Lo-Dash methods, wrappers also have the following Array methods:
+        * concat, join, pop, push, reverse, shift, slice, sort, splice, and unshift
+        *
+        * Chaining is supported in custom builds as long as the value method is implicitly or
+        * explicitly included in the build.
+        *
+        * The chainable wrapper functions are:
+        * after, assign, bind, bindAll, bindKey, chain, chunk, compact, compose, concat, countBy,
+        * createCallback, curry, debounce, defaults, defer, delay, difference, filter, flatten,
+        * forEach, forEachRight, forIn, forInRight, forOwn, forOwnRight, functions, groupBy,
+        * indexBy, initial, intersection, invert, invoke, keys, map, max, memoize, merge, min,
+        * object, omit, once, pairs, partial, partialRight, pick, pluck, pull, push, range, reject,
+        * remove, rest, reverse, sample, shuffle, slice, sort, sortBy, splice, tap, throttle, times,
+        * toArray, transform, union, uniq, unshift, unzip, values, where, without, wrap, and zip
+        *
+        * The non-chainable wrapper functions are:
+        * clone, cloneDeep, contains, escape, every, find, findIndex, findKey, findLast,
+        * findLastIndex, findLastKey, has, identity, indexOf, isArguments, isArray, isBoolean,
+        * isDate, isElement, isEmpty, isEqual, isFinite, isFunction, isNaN, isNull, isNumber,
+        * isObject, isPlainObject, isRegExp, isString, isUndefined, join, lastIndexOf, mixin,
+        * noConflict, parseInt, pop, random, reduce, reduceRight, result, shift, size, some,
+        * sortedIndex, runInContext, template, unescape, uniqueId, and value
+        *
+        * The wrapper functions first and last return wrapped values when n is provided, otherwise
+        * they return unwrapped values.
+        *
+        * Explicit chaining can be enabled by using the _.chain method.
+        **/
+        (value: number): 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.
+        **/
+        VERSION: string;
+
+        /**
+        * An object used to flag environments features.
+        **/
+        support: Support;
+
+        /**
+        * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby
+        * (ERB). Change the following template settings to use alternative delimiters.
+        **/
+        templateSettings: TemplateSettings;
+    }
+
+    /**
+    * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby
+    * (ERB). Change the following template settings to use alternative delimiters.
+    **/
+    interface TemplateSettings {
+        /**
+        * The "escape" delimiter.
+        **/
+        escape?: RegExp;
+
+        /**
+        * The "evaluate" delimiter.
+        **/
+        evaluate?: RegExp;
+
+        /**
+        * An object to import into the template as local variables.
+        **/
+        imports?: Dictionary<any>;
+
+        /**
+        * The "interpolate" delimiter.
+        **/
+        interpolate?: RegExp;
+
+        /**
+        * Used to reference the data object in the template text.
+        **/
+        variable?: string;
+    }
+
+    /**
+     * Creates a cache object to store key/value pairs.
+     */
+    interface MapCache {
+        /**
+         * Removes `key` and its value from the cache.
+         * @param key The key of the value to remove.
+         * @return Returns `true` if the entry was removed successfully, else `false`.
+         */
+        delete(key: string): boolean;
+
+        /**
+         * Gets the cached value for `key`.
+         * @param key The key of the value to get.
+         * @return Returns the cached value.
+         */
+        get(key: string): any;
+
+        /**
+         * Checks if a cached value for `key` exists.
+         * @param key The key of the entry to check.
+         * @return Returns `true` if an entry for `key` exists, else `false`.
+         */
+        has(key: string): boolean;
+
+        /**
+         * Sets `value` to `key` of the cache.
+         * @param key The key of the value to cache.
+         * @param value The value to cache.
+         * @return Returns the cache object.
+         */
+        set(key: string, value: any): _.Dictionary<any>;
+    }
+
+    /**
+    * An object used to flag environments features.
+    **/
+    interface Support {
+        /**
+        * Detect if an arguments object's [[Class]] is resolvable (all but Firefox < 4, IE < 9).
+        **/
+        argsClass: boolean;
+
+        /**
+        * Detect if arguments objects are Object objects (all but Narwhal and Opera < 10.5).
+        **/
+        argsObject: boolean;
+
+        /**
+        * Detect if name or message properties of Error.prototype are enumerable by default.
+        * (IE < 9, Safari < 5.1)
+        **/
+        enumErrorProps: boolean;
+
+        /**
+        * Detect if prototype properties are enumerable by default.
+        *
+        * Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1 (if the prototype or a property on the
+        * prototype has been set) incorrectly set the [[Enumerable]] value of a function’s prototype property to true.
+        **/
+        enumPrototypes: boolean;
+
+        /**
+        * Detect if Function#bind exists and is inferred to be fast (all but V8).
+        **/
+        fastBind: boolean;
+
+        /**
+        * Detect if functions can be decompiled by Function#toString (all but PS3 and older Opera
+        * mobile browsers & avoided in Windows 8 apps).
+        **/
+        funcDecomp: boolean;
+
+        /**
+        * Detect if Function#name is supported (all but IE).
+        **/
+        funcNames: boolean;
+
+        /**
+        * Detect if arguments object indexes are non-enumerable (Firefox < 4, IE < 9, PhantomJS,
+        * Safari < 5.1).
+        **/
+        nonEnumArgs: boolean;
+
+        /**
+        * Detect if properties shadowing those on Object.prototype are non-enumerable.
+        *
+        * In IE < 9 an objects own properties, shadowing non-enumerable ones, are made
+        * non-enumerable as well (a.k.a the JScript [[DontEnum]] bug).
+        **/
+        nonEnumShadows: boolean;
+
+        /**
+        * Detect if own properties are iterated after inherited properties (all but IE < 9).
+        **/
+        ownLast: boolean;
+
+        /**
+        * Detect if Array#shift and Array#splice augment array-like objects correctly.
+        *
+        * Firefox < 10, IE compatibility mode, and IE < 9 have buggy Array shift() and splice()
+        * functions that fail to remove the last element, value[0], of array-like objects even
+        * though the length property is set to 0. The shift() method is buggy in IE 8 compatibility
+        * mode, while splice() is buggy regardless of mode in IE < 9 and buggy in compatibility mode
+        * in IE 9.
+        **/
+        spliceObjects: boolean;
+
+        /**
+        * Detect lack of support for accessing string characters by index.
+        *
+        * IE < 8 can't access characters by index and IE 8 can only access characters by index on
+        * string literals.
+        **/
+        unindexedChars: boolean;
+    }
+
+    interface LoDashWrapperBase<T, TWrapper> { }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> extends LoDashWrapperBase<T, TWrapper> { }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> extends LoDashWrapperBase<T, TWrapper> { }
+
+    interface LoDashImplicitWrapper<T> extends LoDashImplicitWrapperBase<T, LoDashImplicitWrapper<T>> { }
+
+    interface LoDashExplicitWrapper<T> extends LoDashExplicitWrapperBase<T, LoDashExplicitWrapper<T>> { }
+
+    interface LoDashImplicitStringWrapper extends LoDashImplicitWrapper<string> { }
+
+    interface LoDashExplicitStringWrapper extends LoDashExplicitWrapper<string> { }
+
+    interface LoDashImplicitObjectWrapper<T> extends LoDashImplicitWrapperBase<T, LoDashImplicitObjectWrapper<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[]): LoDashImplicitArrayWrapper<T>;
+        shift(): 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 LoDashExplicitArrayWrapper<T> extends LoDashExplicitWrapperBase<T[], LoDashExplicitArrayWrapper<T>> { }
+
+    interface LoDashImplicitNumberArrayWrapper extends LoDashImplicitArrayWrapper<number> { }
+
+    interface LoDashExplicitNumberArrayWrapper extends LoDashExplicitArrayWrapper<number> { }
+
+    /*********
+     * Array *
+     *********/
+
+    //_.chunk
+    interface LoDashStatic {
+        /**
+         * Creates an array of elements split into groups the length of size. If collection can’t be split evenly, the
+         * final chunk will be the remaining elements.
+         *
+         * @param array The array to process.
+         * @param size The length of each chunk.
+         * @return Returns the new array containing chunks.
+         */
+        chunk<T>(
+            array: List<T>,
+            size?: number
+        ): T[][];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.chunk
+         */
+        chunk(size?: number): LoDashImplicitArrayWrapper<T[]>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.chunk
+         */
+        chunk<TResult>(size?: number): LoDashImplicitArrayWrapper<TResult[]>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.chunk
+         */
+        chunk(size?: number): LoDashExplicitArrayWrapper<T[]>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.chunk
+         */
+        chunk<TResult>(size?: number): LoDashExplicitArrayWrapper<TResult[]>;
+    }
+
+    //_.compact
+    interface LoDashStatic {
+        /**
+         * Creates an array with all falsey values removed. The values false, null, 0, "", undefined, and NaN are
+         * falsey.
+         *
+         * @param array The array to compact.
+         * @return (Array) Returns the new array of filtered values.
+         */
+        compact<T>(array?: List<T>): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.compact
+         */
+        compact(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.compact
+         */
+        compact<TResult>(): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.compact
+         */
+        compact(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.compact
+         */
+        compact<TResult>(): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    //_.difference
+    interface LoDashStatic {
+        /**
+         * Creates an array of unique array values not included in the other provided arrays using SameValueZero for
+         * equality comparisons.
+         *
+         * @param array The array to inspect.
+         * @param values The arrays of values to exclude.
+         * @return Returns the new array of filtered values.
+         */
+        difference<T>(
+            array: T[]|List<T>,
+            ...values: (T[]|List<T>)[]
+        ): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.difference
+         */
+        difference(...values: (T[]|List<T>)[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.difference
+         */
+        difference<TValue>(...values: (TValue[]|List<TValue>)[]): LoDashImplicitArrayWrapper<TValue>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.difference
+         */
+        difference(...values: (T[]|List<T>)[]): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.difference
+         */
+        difference<TValue>(...values: (TValue[]|List<TValue>)[]): LoDashExplicitArrayWrapper<TValue>;
+    }
+
+    //_.drop
+    interface LoDashStatic {
+        /**
+         * Creates a slice of array with n elements dropped from the beginning.
+         *
+         * @param array The array to query.
+         * @param n The number of elements to drop.
+         * @return Returns the slice of array.
+         */
+        drop<T>(array: T[]|List<T>, n?: number): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.drop
+         */
+        drop(n?: number): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.drop
+         */
+        drop<T>(n?: number): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.drop
+         */
+        drop(n?: number): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.drop
+         */
+        drop<T>(n?: number): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.dropRight
+    interface LoDashStatic {
+        /**
+         * Creates a slice of array with n elements dropped from the end.
+         *
+         * @param array The array to query.
+         * @param n The number of elements to drop.
+         * @return Returns the slice of array.
+         */
+        dropRight<T>(
+            array: List<T>,
+            n?: number
+        ): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.dropRight
+         */
+        dropRight(n?: number): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.dropRight
+         */
+        dropRight<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.dropRight
+         */
+        dropRight(n?: number): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.dropRight
+         */
+        dropRight<TResult>(n?: number): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    //_.dropRightWhile
+    interface LoDashStatic {
+        /**
+         * Creates a slice of array excluding elements dropped from the end. Elements are dropped until predicate
+         * returns falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array).
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * match the properties of the given object, else false.
+         *
+         * @param array The array to query.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the slice of array.
+         */
+        dropRightWhile<TValue>(
+            array: List<TValue>,
+            predicate?: ListIterator<TValue, boolean>,
+            thisArg?: any
+        ): TValue[];
+
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile<TValue>(
+            array: List<TValue>,
+            predicate?: string,
+            thisArg?: any
+        ): TValue[];
+
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile<TWhere, TValue>(
+            array: List<TValue>,
+            predicate?: TWhere
+        ): TValue[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile<TWhere>(
+            predicate?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile<TValue>(
+            predicate?: ListIterator<TValue, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile<TValue>(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile<TWhere, TValue>(
+            predicate?: TWhere
+        ): LoDashImplicitArrayWrapper<TValue>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile<TWhere>(
+            predicate?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile<TValue>(
+            predicate?: ListIterator<TValue, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile<TValue>(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.dropRightWhile
+         */
+        dropRightWhile<TWhere, TValue>(
+            predicate?: TWhere
+        ): LoDashExplicitArrayWrapper<TValue>;
+    }
+
+    //_.dropWhile
+    interface LoDashStatic {
+        /**
+         * Creates a slice of array excluding elements dropped from the beginning. Elements are dropped until predicate
+         * returns falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array).
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param array The array to query.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the slice of array.
+         */
+        dropWhile<TValue>(
+            array: List<TValue>,
+            predicate?: ListIterator<TValue, boolean>,
+            thisArg?: any
+        ): TValue[];
+
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile<TValue>(
+            array: List<TValue>,
+            predicate?: string,
+            thisArg?: any
+        ): TValue[];
+
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile<TWhere, TValue>(
+            array: List<TValue>,
+            predicate?: TWhere
+        ): TValue[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile<TWhere>(
+            predicate?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile<TValue>(
+            predicate?: ListIterator<TValue, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile<TValue>(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile<TWhere, TValue>(
+            predicate?: TWhere
+        ): LoDashImplicitArrayWrapper<TValue>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile<TWhere>(
+            predicate?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile<TValue>(
+            predicate?: ListIterator<TValue, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile<TValue>(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.dropWhile
+         */
+        dropWhile<TWhere, TValue>(
+            predicate?: TWhere
+        ): LoDashExplicitArrayWrapper<TValue>;
+    }
+
+    //_.fill
+    interface LoDashStatic {
+        /**
+         * Fills elements of array with value from start up to, but not including, end.
+         *
+         * Note: This method mutates array.
+         *
+         * @param array The array to fill.
+         * @param value The value to fill array with.
+         * @param start The start position.
+         * @param end The end position.
+         * @return Returns array.
+         */
+        fill<T>(
+            array: any[],
+            value: T,
+            start?: number,
+            end?: number
+        ): T[];
+
+        /**
+         * @see _.fill
+         */
+        fill<T>(
+            array: List<any>,
+            value: T,
+            start?: number,
+            end?: number
+        ): List<T>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.fill
+         */
+        fill<T>(
+            value: T,
+            start?: number,
+            end?: number
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.fill
+         */
+        fill<T>(
+            value: T,
+            start?: number,
+            end?: number
+        ): LoDashImplicitObjectWrapper<List<T>>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.fill
+         */
+        fill<T>(
+            value: T,
+            start?: number,
+            end?: number
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.fill
+         */
+        fill<T>(
+            value: T,
+            start?: number,
+            end?: number
+        ): LoDashExplicitObjectWrapper<List<T>>;
+    }
+
+    //_.findIndex
+    interface LoDashStatic {
+        /**
+         * This method is like _.find except that it returns the index of the first element predicate returns truthy
+         * for instead of the element itself.
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param array The array to search.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the index of the found element, else -1.
+         */
+        findIndex<T>(
+            array: List<T>,
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.findIndex
+         */
+        findIndex<T>(
+            array: List<T>,
+            predicate?: string,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.findIndex
+         */
+        findIndex<W, T>(
+            array: List<T>,
+            predicate?: W
+        ): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.findIndex
+         */
+        findIndex(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.findIndex
+         */
+        findIndex(
+            predicate?: string,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.findIndex
+         */
+        findIndex<W>(
+            predicate?: W
+        ): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.findIndex
+         */
+        findIndex<TResult>(
+            predicate?: ListIterator<TResult, boolean>,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.findIndex
+         */
+        findIndex(
+            predicate?: string,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.findIndex
+         */
+        findIndex<W>(
+            predicate?: W
+        ): number;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.findIndex
+         */
+        findIndex(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.findIndex
+         */
+        findIndex(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.findIndex
+         */
+        findIndex<W>(
+            predicate?: W
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.findIndex
+         */
+        findIndex<TResult>(
+            predicate?: ListIterator<TResult, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.findIndex
+         */
+        findIndex(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.findIndex
+         */
+        findIndex<W>(
+            predicate?: W
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    //_.findLastIndex
+    interface LoDashStatic {
+        /**
+         * This method is like _.findIndex except that it iterates over elements of collection from right to left.
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param array The array to search.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The function invoked per iteration.
+         * @return Returns the index of the found element, else -1.
+         */
+        findLastIndex<T>(
+            array: List<T>,
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex<T>(
+            array: List<T>,
+            predicate?: string,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex<W, T>(
+            array: List<T>,
+            predicate?: W
+        ): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex(
+            predicate?: string,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex<W>(
+            predicate?: W
+        ): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex<TResult>(
+            predicate?: ListIterator<TResult, boolean>,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex(
+            predicate?: string,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex<W>(
+            predicate?: W
+        ): number;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex<W>(
+            predicate?: W
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex<TResult>(
+            predicate?: ListIterator<TResult, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.findLastIndex
+         */
+        findLastIndex<W>(
+            predicate?: W
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    //_.first
+    interface LoDashStatic {
+        /**
+         * Gets the first element of array.
+         *
+         * @alias _.head
+         *
+         * @param array The array to query.
+         * @return Returns the first element of array.
+         */
+        first<T>(array: List<T>): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.first
+         */
+        first(): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.first
+         */
+        first<TResult>(): TResult;
+    }
+
+    interface RecursiveArray<T> extends Array<T|RecursiveArray<T>> {}
+    interface ListOfRecursiveArraysOrValues<T> extends List<T|RecursiveArray<T>> {}
+
+    //_.flatten
+    interface LoDashStatic {
+        /**
+         * Flattens a nested array. If isDeep is true the array is recursively flattened, otherwise it’s only
+         * flattened a single level.
+         *
+         * @param array The array to flatten.
+         * @param isDeep Specify a deep flatten.
+         * @return Returns the new flattened array.
+         */
+        flatten<T>(array: ListOfRecursiveArraysOrValues<T>, isDeep: boolean): T[];
+
+        /**
+         * @see _.flatten
+         */
+        flatten<T>(array: List<T|T[]>): T[];
+
+        /**
+         * @see _.flatten
+         */
+        flatten<T>(array: ListOfRecursiveArraysOrValues<T>): RecursiveArray<T>;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.flatten
+         */
+        flatten(): LoDashImplicitArrayWrapper<string>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.flatten
+         */
+        flatten<TResult>(isDeep?: boolean): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.flatten
+         */
+        flatten<TResult>(isDeep?: boolean): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.flatten
+         */
+        flatten(): LoDashExplicitArrayWrapper<string>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.flatten
+         */
+        flatten<TResult>(isDeep?: boolean): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.flatten
+         */
+        flatten<TResult>(isDeep?: boolean): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    //_.flattenDeep
+    interface LoDashStatic {
+        /**
+         * Recursively flattens a nested array.
+         *
+         * @param array The array to recursively flatten.
+         * @return Returns the new flattened array.
+         */
+        flattenDeep<T>(array: ListOfRecursiveArraysOrValues<T>): T[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.flattenDeep
+         */
+        flattenDeep(): LoDashImplicitArrayWrapper<string>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.flattenDeep
+         */
+        flattenDeep<T>(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.flattenDeep
+         */
+        flattenDeep<T>(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.flattenDeep
+         */
+        flattenDeep(): LoDashExplicitArrayWrapper<string>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.flattenDeep
+         */
+        flattenDeep<T>(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.flattenDeep
+         */
+        flattenDeep<T>(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.head
+    interface LoDashStatic {
+        /**
+         * @see _.first
+         */
+        head<T>(array: List<T>): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.first
+         */
+        head(): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.first
+         */
+        head<TResult>(): TResult;
+    }
+
+    //_.indexOf
+    interface LoDashStatic {
+        /**
+         * Gets the index at which the first occurrence of value is found in array using SameValueZero for equality
+         * comparisons. If fromIndex is negative, it’s used as the offset from the end of array. If array is sorted
+         * providing true for fromIndex performs a faster binary search.
+         *
+         * @param array The array to search.
+         * @param value The value to search for.
+         * @param fromIndex The index to search from or true to perform a binary search on a sorted array.
+         * @return The index to search from or true to perform a binary search on a sorted array.
+         */
+        indexOf<T>(
+            array: List<T>,
+            value: T,
+            fromIndex?: boolean|number
+        ): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.indexOf
+         */
+        indexOf(
+            value: T,
+            fromIndex?: boolean|number
+        ): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.indexOf
+         */
+        indexOf<TValue>(
+            value: TValue,
+            fromIndex?: boolean|number
+        ): number;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.indexOf
+         */
+        indexOf(
+            value: T,
+            fromIndex?: boolean|number
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.indexOf
+         */
+        indexOf<TValue>(
+            value: TValue,
+            fromIndex?: boolean|number
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    //_.initial
+    interface LoDashStatic {
+        /**
+         * Gets all but the last element of array.
+         *
+         * @param array The array to query.
+         * @return Returns the slice of array.
+         */
+        initial<T>(array: List<T>): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.initial
+         */
+        initial(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.initial
+         */
+        initial<T>(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.initial
+         */
+        initial(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.initial
+         */
+        initial<T>(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.intersection
+    interface LoDashStatic {
+        /**
+         * Creates an array of unique values that are included in all of the provided arrays using SameValueZero for
+         * equality comparisons.
+         *
+         * @param arrays The arrays to inspect.
+         * @return Returns the new array of shared values.
+         */
+        intersection<T>(...arrays: (T[]|List<T>)[]): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.intersection
+         */
+        intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.intersection
+         */
+        intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.intersection
+         */
+        intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.intersection
+         */
+        intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    //_.last
+    interface LoDashStatic {
+        /**
+         * Gets the last element of array.
+         *
+         * @param array The array to query.
+         * @return Returns the last element of array.
+         */
+        last<T>(array: List<T>): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.last
+         */
+        last(): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.last
+         */
+        last<T>(): T;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.last
+         */
+        last(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.last
+         */
+        last<T>(): LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.lastIndexOf
+    interface LoDashStatic {
+        /**
+         * This method is like _.indexOf except that it iterates over elements of array from right to left.
+         *
+         * @param array The array to search.
+         * @param value The value to search for.
+         * @param fromIndex The index to search from or true to perform a binary search on a sorted array.
+         * @return Returns the index of the matched value, else -1.
+         */
+        lastIndexOf<T>(
+            array: List<T>,
+            value: T,
+            fromIndex?: boolean|number
+        ): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.lastIndexOf
+         */
+        lastIndexOf(
+            value: T,
+            fromIndex?: boolean|number
+        ): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.lastIndexOf
+         */
+        lastIndexOf<TResult>(
+            value: TResult,
+            fromIndex?: boolean|number
+        ): number;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.lastIndexOf
+         */
+        lastIndexOf(
+            value: T,
+            fromIndex?: boolean|number
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.lastIndexOf
+         */
+        lastIndexOf<TResult>(
+            value: TResult,
+            fromIndex?: boolean|number
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    //_.object
+    interface LoDashStatic {
+        /**
+         * @see _.zipObject
+         */
+        object<TValues, TResult extends {}>(
+            props: List<StringRepresentable>|List<List<any>>,
+            values?: List<TValues>
+        ): TResult;
+
+        /**
+         * @see _.zipObject
+         */
+        object<TResult extends {}>(
+            props: List<StringRepresentable>|List<List<any>>,
+            values?: List<any>
+        ): TResult;
+
+        /**
+         * @see _.zipObject
+         */
+        object(
+            props: List<StringRepresentable>|List<List<any>>,
+            values?: List<any>
+        ): _.Dictionary<any>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.zipObject
+         */
+        object<TValues, TResult extends {}>(
+            values?: List<TValues>
+        ): _.LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        object<TResult extends {}>(
+            values?: List<any>
+        ): _.LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        object(
+            values?: List<any>
+        ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.zipObject
+         */
+        object<TValues, TResult extends {}>(
+            values?: List<TValues>
+        ): _.LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        object<TResult extends {}>(
+            values?: List<any>
+        ): _.LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        object(
+            values?: List<any>
+        ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.zipObject
+         */
+        object<TValues, TResult extends {}>(
+            values?: List<TValues>
+        ): _.LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        object<TResult extends {}>(
+            values?: List<any>
+        ): _.LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        object(
+            values?: List<any>
+        ): _.LoDashExplicitObjectWrapper<_.Dictionary<any>>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.zipObject
+         */
+        object<TValues, TResult extends {}>(
+            values?: List<TValues>
+        ): _.LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        object<TResult extends {}>(
+            values?: List<any>
+        ): _.LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        object(
+            values?: List<any>
+        ): _.LoDashExplicitObjectWrapper<_.Dictionary<any>>;
+    }
+
+    //_.pull
+    interface LoDashStatic {
+        /**
+         * Removes all provided values from array using SameValueZero for equality comparisons.
+         *
+         * Note: Unlike _.without, this method mutates array.
+         *
+         * @param array The array to modify.
+         * @param values The values to remove.
+         * @return Returns array.
+         */
+        pull<T>(
+            array: T[],
+            ...values: T[]
+        ): T[];
+
+        /**
+         * @see _.pull
+         */
+        pull<T>(
+            array: List<T>,
+            ...values: T[]
+        ): List<T>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.pull
+         */
+        pull(...values: T[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.pull
+         */
+        pull<TValue>(...values: TValue[]): LoDashImplicitObjectWrapper<List<TValue>>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.pull
+         */
+        pull(...values: T[]): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.pull
+         */
+        pull<TValue>(...values: TValue[]): LoDashExplicitObjectWrapper<List<TValue>>;
+    }
+
+    //_.pullAt
+    interface LoDashStatic {
+        /**
+         * Removes elements from array corresponding to the given indexes and returns an array of the removed elements.
+         * Indexes may be specified as an array of indexes or as individual arguments.
+         *
+         * Note: Unlike _.at, this method mutates array.
+         *
+         * @param array The array to modify.
+         * @param indexes The indexes of elements to remove, specified as individual indexes or arrays of indexes.
+         * @return Returns the new array of removed elements.
+         */
+        pullAt<T>(
+            array: List<T>,
+            ...indexes: (number|number[])[]
+        ): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.pullAt
+         */
+        pullAt(...indexes: (number|number[])[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.pullAt
+         */
+        pullAt<T>(...indexes: (number|number[])[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.pullAt
+         */
+        pullAt(...indexes: (number|number[])[]): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.pullAt
+         */
+        pullAt<T>(...indexes: (number|number[])[]): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.remove
+    interface LoDashStatic {
+        /**
+         * Removes all elements from array that predicate returns truthy for and returns an array of the removed
+         * elements. The predicate is bound to thisArg and invoked with three arguments: (value, index, array).
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * Note: Unlike _.filter, this method mutates array.
+         *
+         * @param array The array to modify.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the new array of removed elements.
+         */
+        remove<T>(
+            array: List<T>,
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.remove
+         */
+        remove<T>(
+            array: List<T>,
+            predicate?: string,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.remove
+         */
+        remove<W, T>(
+            array: List<T>,
+            predicate?: W
+        ): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.remove
+         */
+        remove(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.remove
+         */
+        remove(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.remove
+         */
+        remove<W>(
+            predicate?: W
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.remove
+         */
+        remove<TResult>(
+            predicate?: ListIterator<TResult, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.remove
+         */
+        remove<TResult>(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.remove
+         */
+        remove<W, TResult>(
+            predicate?: W
+        ): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.remove
+         */
+        remove(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.remove
+         */
+        remove(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.remove
+         */
+        remove<W>(
+            predicate?: W
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.remove
+         */
+        remove<TResult>(
+            predicate?: ListIterator<TResult, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.remove
+         */
+        remove<TResult>(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.remove
+         */
+        remove<W, TResult>(
+            predicate?: W
+        ): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    //_.rest
+    interface LoDashStatic {
+        /**
+         * Gets all but the first element of array.
+         *
+         * @alias _.tail
+         *
+         * @param array The array to query.
+         * @return Returns the slice of array.
+         */
+        rest<T>(array: List<T>): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.rest
+         */
+        rest(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.rest
+         */
+        rest<T>(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.rest
+         */
+        rest(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.rest
+         */
+        rest<T>(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.slice
+    interface LoDashStatic {
+        /**
+         * Creates a slice of array from start up to, but not including, end.
+         *
+         * @param array The array to slice.
+         * @param start The start position.
+         * @param end The end position.
+         * @return Returns the slice of array.
+         */
+        slice<T>(
+            array: T[],
+            start?: number,
+            end?: number
+        ): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.slice
+         */
+        slice(
+            start?: number,
+            end?: number
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.slice
+         */
+        slice(
+            start?: number,
+            end?: number
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.sortedIndex
+    interface LoDashStatic {
+        /**
+         * Uses a binary search to determine the lowest index at which value should be inserted into array in order to maintain its sort order. If an iteratee function is provided it’s invoked for value and each element of array to compute their sort ranking. The iteratee is bound to thisArg and invoked with one argument; (value).
+         *
+         * If a property name is provided for iteratee the created _.property style callback returns the property value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for elements that have a matching property value, else false.
+         *
+         * If an object is provided for iteratee the created _.matches style callback returns true for elements that have the properties of the given object, else false.
+         *
+         * @param array The sorted array to inspect.
+         * @param value The value to evaluate.
+         * @param iteratee The function invoked per iteration.
+         * @return The this binding of iteratee.
+         */
+        sortedIndex<T, TSort>(
+            array: List<T>,
+            value: T,
+            iteratee?: (x: T) => TSort,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<T>(
+            array: List<T>,
+            value: T,
+            iteratee?: (x: T) => any,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<T>(
+            array: List<T>,
+            value: T,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<W, T>(
+            array: List<T>,
+            value: T,
+            iteratee: W
+        ): number;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<T>(
+            array: List<T>,
+            value: T,
+            iteratee: Object
+        ): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<TSort>(
+            value: string,
+            iteratee?: (x: string) => TSort,
+            thisArg?: any
+        ): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<TSort>(
+            value: T,
+            iteratee?: (x: T) => TSort,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex(
+            value: T,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<W>(
+            value: T,
+            iteratee: W
+        ): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<T, TSort>(
+            value: T,
+            iteratee?: (x: T) => TSort,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<T>(
+            value: T,
+            iteratee?: (x: T) => any,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<T>(
+            value: T,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<W, T>(
+            value: T,
+            iteratee: W
+        ): number;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<T>(
+            value: T,
+            iteratee: Object
+        ): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<TSort>(
+            value: string,
+            iteratee?: (x: string) => TSort,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<TSort>(
+            value: T,
+            iteratee?: (x: T) => TSort,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex(
+            value: T,
+            iteratee: string
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<W>(
+            value: T,
+            iteratee: W
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<T, TSort>(
+            value: T,
+            iteratee?: (x: T) => TSort,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<T>(
+            value: T,
+            iteratee?: (x: T) => any,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<T>(
+            value: T,
+            iteratee: string
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<W, T>(
+            value: T,
+            iteratee: W
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedIndex
+         */
+        sortedIndex<T>(
+            value: T,
+            iteratee: Object
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    //_.sortedLastIndex
+    interface LoDashStatic {
+        /**
+         * This method is like _.sortedIndex except that it returns the highest index at which value should be
+         * inserted into array in order to maintain its sort order.
+         *
+         * @param array The sorted array to inspect.
+         * @param value The value to evaluate.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the index at which value should be inserted into array.
+         */
+        sortedLastIndex<T, TSort>(
+            array: List<T>,
+            value: T,
+            iteratee?: (x: T) => TSort,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<T>(
+            array: List<T>,
+            value: T,
+            iteratee?: (x: T) => any,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<T>(
+            array: List<T>,
+            value: T,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<W, T>(
+            array: List<T>,
+            value: T,
+            iteratee: W
+        ): number;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<T>(
+            array: List<T>,
+            value: T,
+            iteratee: Object
+        ): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<TSort>(
+            value: string,
+            iteratee?: (x: string) => TSort,
+            thisArg?: any
+        ): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<TSort>(
+            value: T,
+            iteratee?: (x: T) => TSort,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex(
+            value: T,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<W>(
+            value: T,
+            iteratee: W
+        ): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<T, TSort>(
+            value: T,
+            iteratee?: (x: T) => TSort,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<T>(
+            value: T,
+            iteratee?: (x: T) => any,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<T>(
+            value: T,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<W, T>(
+            value: T,
+            iteratee: W
+        ): number;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<T>(
+            value: T,
+            iteratee: Object
+        ): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<TSort>(
+            value: string,
+            iteratee?: (x: string) => TSort,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<TSort>(
+            value: T,
+            iteratee?: (x: T) => TSort,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex(
+            value: T,
+            iteratee: string
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<W>(
+            value: T,
+            iteratee: W
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<T, TSort>(
+            value: T,
+            iteratee?: (x: T) => TSort,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<T>(
+            value: T,
+            iteratee?: (x: T) => any,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<T>(
+            value: T,
+            iteratee: string
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<W, T>(
+            value: T,
+            iteratee: W
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedLastIndex
+         */
+        sortedLastIndex<T>(
+            value: T,
+            iteratee: Object
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    //_.tail
+    interface LoDashStatic {
+        /**
+         * @see _.rest
+         */
+        tail<T>(array: List<T>): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.rest
+         */
+        tail(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.rest
+         */
+        tail<T>(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.rest
+         */
+        tail(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.rest
+         */
+        tail<T>(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.take
+    interface LoDashStatic {
+        /**
+         * Creates a slice of array with n elements taken from the beginning.
+         *
+         * @param array The array to query.
+         * @param n The number of elements to take.
+         * @return Returns the slice of array.
+         */
+        take<T>(
+            array: List<T>,
+            n?: number
+        ): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.take
+         */
+        take(n?: number): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.take
+         */
+        take<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.take
+         */
+        take(n?: number): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.take
+         */
+        take<TResult>(n?: number): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    //_.takeRight
+    interface LoDashStatic {
+        /**
+         * Creates a slice of array with n elements taken from the end.
+         *
+         * @param array The array to query.
+         * @param n The number of elements to take.
+         * @return Returns the slice of array.
+         */
+        takeRight<T>(
+            array: List<T>,
+            n?: number
+        ): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.takeRight
+         */
+        takeRight(n?: number): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.takeRight
+         */
+        takeRight<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.takeRight
+         */
+        takeRight(n?: number): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.takeRight
+         */
+        takeRight<TResult>(n?: number): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    //_.takeRightWhile
+    interface LoDashStatic {
+        /**
+         * Creates a slice of array with elements taken from the end. Elements are taken until predicate returns
+         * falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array).
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param array The array to query.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the slice of array.
+         */
+        takeRightWhile<TValue>(
+            array: List<TValue>,
+            predicate?: ListIterator<TValue, boolean>,
+            thisArg?: any
+        ): TValue[];
+
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile<TValue>(
+            array: List<TValue>,
+            predicate?: string,
+            thisArg?: any
+        ): TValue[];
+
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile<TWhere, TValue>(
+            array: List<TValue>,
+            predicate?: TWhere
+        ): TValue[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile<TWhere>(
+            predicate?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile<TValue>(
+            predicate?: ListIterator<TValue, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile<TValue>(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile<TWhere, TValue>(
+            predicate?: TWhere
+        ): LoDashImplicitArrayWrapper<TValue>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile<TWhere>(
+            predicate?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile<TValue>(
+            predicate?: ListIterator<TValue, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile<TValue>(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.takeRightWhile
+         */
+        takeRightWhile<TWhere, TValue>(
+            predicate?: TWhere
+        ): LoDashExplicitArrayWrapper<TValue>;
+    }
+
+    //_.takeWhile
+    interface LoDashStatic {
+        /**
+         * Creates a slice of array with elements taken from the beginning. Elements are taken until predicate returns
+         * falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array).
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param array The array to query.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the slice of array.
+         */
+        takeWhile<TValue>(
+            array: List<TValue>,
+            predicate?: ListIterator<TValue, boolean>,
+            thisArg?: any
+        ): TValue[];
+
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile<TValue>(
+            array: List<TValue>,
+            predicate?: string,
+            thisArg?: any
+        ): TValue[];
+
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile<TWhere, TValue>(
+            array: List<TValue>,
+            predicate?: TWhere
+        ): TValue[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile<TWhere>(
+            predicate?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile<TValue>(
+            predicate?: ListIterator<TValue, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile<TValue>(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile<TWhere, TValue>(
+            predicate?: TWhere
+        ): LoDashImplicitArrayWrapper<TValue>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile<TWhere>(
+            predicate?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile<TValue>(
+            predicate?: ListIterator<TValue, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile<TValue>(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TValue>;
+
+        /**
+         * @see _.takeWhile
+         */
+        takeWhile<TWhere, TValue>(
+            predicate?: TWhere
+        ): LoDashExplicitArrayWrapper<TValue>;
+    }
+
+    //_.union
+    interface LoDashStatic {
+        /**
+         * Creates an array of unique values, in order, from all of the provided arrays using SameValueZero for
+         * equality comparisons.
+         *
+         * @param arrays The arrays to inspect.
+         * @return Returns the new array of combined values.
+         */
+        union<T>(...arrays: List<T>[]): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.union
+         */
+        union(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.union
+         */
+        union<T>(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.union
+         */
+        union<T>(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.union
+         */
+        union(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.union
+         */
+        union<T>(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.union
+         */
+        union<T>(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.uniq
+    interface LoDashStatic {
+        /**
+         * Creates a duplicate-free version of an array, using SameValueZero for equality comparisons, in which only
+         * the first occurrence of each element is kept. Providing true for isSorted performs a faster search
+         * algorithm for sorted arrays. If an iteratee function is provided it’s invoked for each element in the
+         * array to generate the criterion by which uniqueness is computed. The iteratee is bound to thisArg and
+         * invoked with three arguments: (value, index, array).
+         *
+         * If a property name is provided for iteratee the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for iteratee the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @alias _.unique
+         *
+         * @param array The array to inspect.
+         * @param isSorted Specify the array is sorted.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg iteratee
+         * @return Returns the new duplicate-value-free array.
+         */
+        uniq<T>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T, TSort>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            array: List<T>,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T, TSort>(
+            array: List<T>,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            array: List<T>,
+            iteratee?: string,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: Object
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}, T>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            array: List<T>,
+            iteratee?: Object
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}, T>(
+            array: List<T>,
+            iteratee?: TWhere
+        ): T[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}>(
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        uniq<T>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T, TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T, TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            isSorted?: boolean,
+            iteratee?: Object
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}, T>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            iteratee?: Object
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}, T>(
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}>(
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        uniq<T>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T, TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T, TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            isSorted?: boolean,
+            iteratee?: Object
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}, T>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            iteratee?: Object
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}, T>(
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.unique
+    interface LoDashStatic {
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T, TSort>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            array: List<T>,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T, TSort>(
+            array: List<T>,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            array: List<T>,
+            iteratee?: string,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: Object
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}, T>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            array: List<T>,
+            iteratee?: Object
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}, T>(
+            array: List<T>,
+            iteratee?: TWhere
+        ): T[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}>(
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        unique<T>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T, TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T, TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            isSorted?: boolean,
+            iteratee?: Object
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}, T>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            iteratee?: Object
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}, T>(
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}>(
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        unique<T>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T, TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T, TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            isSorted?: boolean,
+            iteratee?: Object
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}, T>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            iteratee?: Object
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}, T>(
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.unzip
+    interface LoDashStatic {
+        /**
+         * This method is like _.zip except that it accepts an array of grouped elements and creates an array
+         * regrouping the elements to their pre-zip configuration.
+         *
+         * @param array The array of grouped elements to process.
+         * @return Returns the new array of regrouped elements.
+         */
+        unzip<T>(array: List<List<T>>): T[][];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.unzip
+         */
+        unzip<T>(): LoDashImplicitArrayWrapper<T[]>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.unzip
+         */
+        unzip<T>(): LoDashImplicitArrayWrapper<T[]>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.unzip
+         */
+        unzip<T>(): LoDashExplicitArrayWrapper<T[]>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.unzip
+         */
+        unzip<T>(): LoDashExplicitArrayWrapper<T[]>;
+    }
+
+    //_.unzipWith
+    interface LoDashStatic {
+        /**
+         * This method is like _.unzip except that it accepts an iteratee to specify how regrouped values should be
+         * combined. The iteratee is bound to thisArg and invoked with four arguments: (accumulator, value, index,
+         * group).
+         *
+         * @param array The array of grouped elements to process.
+         * @param iteratee The function to combine regrouped values.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the new array of regrouped elements.
+         */
+        unzipWith<TArray, TResult>(
+            array: List<List<TArray>>,
+            iteratee?: MemoIterator<TArray, TResult>,
+            thisArg?: any
+        ): TResult[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.unzipWith
+         */
+        unzipWith<TArr, TResult>(
+            iteratee?: MemoIterator<TArr, TResult>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.unzipWith
+         */
+        unzipWith<TArr, TResult>(
+            iteratee?: MemoIterator<TArr, TResult>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    //_.without
+    interface LoDashStatic {
+        /**
+         * Creates an array excluding all provided values using SameValueZero for equality comparisons.
+         *
+         * @param array The array to filter.
+         * @param values The values to exclude.
+         * @return Returns the new array of filtered values.
+         */
+        without<T>(
+            array: List<T>,
+            ...values: T[]
+        ): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.without
+         */
+        without(...values: T[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.without
+         */
+        without<T>(...values: T[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.without
+         */
+        without(...values: T[]): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.without
+         */
+        without<T>(...values: T[]): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.xor
+    interface LoDashStatic {
+        /**
+         * Creates an array of unique values that is the symmetric difference of the provided arrays.
+         *
+         * @param arrays The arrays to inspect.
+         * @return Returns the new array of values.
+         */
+        xor<T>(...arrays: List<T>[]): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.xor
+         */
+        xor(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.xor
+         */
+        xor<T>(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.xor
+         */
+        xor(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.xor
+         */
+        xor<T>(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.zip
+    interface LoDashStatic {
+        /**
+         * Creates an array of grouped elements, the first of which contains the first elements of the given arrays,
+         * the second of which contains the second elements of the given arrays, and so on.
+         *
+         * @param arrays The arrays to process.
+         * @return Returns the new array of grouped elements.
+         */
+        zip<T>(...arrays: List<T>[]): T[][];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.zip
+         */
+        zip<T>(...arrays: List<T>[]): _.LoDashImplicitArrayWrapper<T[]>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.zip
+         */
+        zip<T>(...arrays: List<T>[]): _.LoDashImplicitArrayWrapper<T[]>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.zip
+         */
+        zip<T>(...arrays: List<T>[]): _.LoDashExplicitArrayWrapper<T[]>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.zip
+         */
+        zip<T>(...arrays: List<T>[]): _.LoDashExplicitArrayWrapper<T[]>;
+    }
+
+    //_.zipObject
+    interface LoDashStatic {
+        /**
+         * The inverse of _.pairs; this method returns an object composed from arrays of property names and values.
+         * Provide either a single two dimensional array, e.g. [[key1, value1], [key2, value2]] or two arrays, one of
+         * property names and one of corresponding values.
+         *
+         * @alias _.object
+         *
+         * @param props The property names.
+         * @param values The property values.
+         * @return Returns the new object.
+         */
+        zipObject<TValues, TResult extends {}>(
+            props: List<StringRepresentable>|List<List<any>>,
+            values?: List<TValues>
+        ): TResult;
+
+        /**
+         * @see _.zipObject
+         */
+        zipObject<TResult extends {}>(
+            props: List<StringRepresentable>|List<List<any>>,
+            values?: List<any>
+        ): TResult;
+
+        /**
+         * @see _.zipObject
+         */
+        zipObject(
+            props: List<StringRepresentable>|List<List<any>>,
+            values?: List<any>
+        ): _.Dictionary<any>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.zipObject
+         */
+        zipObject<TValues, TResult extends {}>(
+            values?: List<TValues>
+        ): _.LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        zipObject<TResult extends {}>(
+            values?: List<any>
+        ): _.LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        zipObject(
+            values?: List<any>
+        ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.zipObject
+         */
+        zipObject<TValues, TResult extends {}>(
+            values?: List<TValues>
+        ): _.LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        zipObject<TResult extends {}>(
+            values?: List<any>
+        ): _.LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        zipObject(
+            values?: List<any>
+        ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.zipObject
+         */
+        zipObject<TValues, TResult extends {}>(
+            values?: List<TValues>
+        ): _.LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        zipObject<TResult extends {}>(
+            values?: List<any>
+        ): _.LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        zipObject(
+            values?: List<any>
+        ): _.LoDashExplicitObjectWrapper<_.Dictionary<any>>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.zipObject
+         */
+        zipObject<TValues, TResult extends {}>(
+            values?: List<TValues>
+        ): _.LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        zipObject<TResult extends {}>(
+            values?: List<any>
+        ): _.LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.zipObject
+         */
+        zipObject(
+            values?: List<any>
+        ): _.LoDashExplicitObjectWrapper<_.Dictionary<any>>;
+    }
+
+    //_.zipWith
+    interface LoDashStatic {
+        /**
+         * This method is like _.zip except that it accepts an iteratee to specify how grouped values should be
+         * combined. The iteratee is bound to thisArg and invoked with four arguments: (accumulator, value, index,
+         * group).
+         * @param {...Array} [arrays] The arrays to process.
+         * @param {Function} [iteratee] The function to combine grouped values.
+         * @param {*} [thisArg] The `this` binding of `iteratee`.
+         * @return Returns the new array of grouped elements.
+         */
+        zipWith<TResult>(...args: any[]): TResult[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.zipWith
+         */
+        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.
+         * @return Returns the result of interceptor.
+         */
+        thru<T, TResult>(
+            value: T,
+            interceptor: (value: T) => TResult,
+            thisArg?: any
+        ): TResult;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.thru
+         */
+        thru<TResult extends number>(
+            interceptor: (value: T) => TResult,
+            thisArg?: any): LoDashImplicitWrapper<TResult>;
+
+        /**
+         * @see _.thru
+         */
+        thru<TResult extends string>(
+            interceptor: (value: T) => TResult,
+            thisArg?: any): LoDashImplicitWrapper<TResult>;
+
+        /**
+         * @see _.thru
+         */
+        thru<TResult extends boolean>(
+            interceptor: (value: T) => TResult,
+            thisArg?: any): LoDashImplicitWrapper<TResult>;
+
+        /**
+         * @see _.thru
+         */
+        thru<TResult extends {}>(
+            interceptor: (value: T) => TResult,
+            thisArg?: any): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.thru
+         */
+        thru<TResult>(
+            interceptor: (value: T) => TResult[],
+            thisArg?: any): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    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.
+         *
+         * @return Returns the new lodash wrapper instance.
+         */
+        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 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): LoDashImplicitWrapper<number>;
+
+        /**
+         * @see _.plant
+         */
+        plant(value: string): LoDashImplicitStringWrapper;
+
+        /**
+         * @see _.plant
+         */
+        plant(value: boolean): LoDashImplicitWrapper<boolean>;
+
+        /**
+         * @see _.plant
+         */
+        plant(value: number[]): LoDashImplicitNumberArrayWrapper;
+
+        /**
+         * @see _.plant
+         */
+        plant<T>(value: T[]): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.plant
+         */
+        plant<T extends {}>(value: T): LoDashImplicitObjectWrapper<T>;
+
+        /**
+         * @see _.plant
+         */
+        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>;
+    }
+
+    //_.prototype.run
+    interface LoDashWrapperBase<T, TWrapper> {
+        /**
+         * @see _.value
+         */
+        run(): T;
+    }
+
+    //_.prototype.toJSON
+    interface LoDashWrapperBase<T, TWrapper> {
+        /**
+         * @see _.value
+         */
+        toJSON(): T;
+    }
+
+    //_.prototype.toString
+    interface LoDashWrapperBase<T, TWrapper> {
+        /**
+         * Produces the result of coercing the unwrapped value to a string.
+         *
+         * @return Returns the coerced string value.
+         */
+        toString(): string;
+    }
+
+    //_.prototype.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;
+    }
+
+    /**************
+     * Collection *
+     **************/
+
+    //_.all
+    interface LoDashStatic {
+        /**
+         * @see _.every
+         */
+        all<T>(
+            collection: List<T>,
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        all<T>(
+            collection: Dictionary<T>,
+            predicate?: DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        all<T>(
+            collection: List<T>|Dictionary<T>,
+            predicate?: string,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        all<TObject extends {}, T>(
+            collection: List<T>|Dictionary<T>,
+            predicate?: TObject
+        ): boolean;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.every
+         */
+        all(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        all(
+            predicate?: string,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        all<TObject extends {}>(
+            predicate?: TObject
+        ): boolean;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.every
+         */
+        all<TResult>(
+            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        all(
+            predicate?: string,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        all<TObject extends {}>(
+            predicate?: TObject
+        ): boolean;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.every
+         */
+        all(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.every
+         */
+        all(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.every
+         */
+        all<TObject extends {}>(
+            predicate?: TObject
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.every
+         */
+        all<TResult>(
+            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.every
+         */
+        all(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.every
+         */
+        all<TObject extends {}>(
+            predicate?: TObject
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.any
+    interface LoDashStatic {
+        /**
+         * @see _.some
+         */
+        any<T>(
+            collection: List<T>,
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        any<T>(
+            collection: Dictionary<T>,
+            predicate?: DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        any<T>(
+            collection: NumericDictionary<T>,
+            predicate?: NumericDictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        any<T>(
+            collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+            predicate?: string,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        any<TObject extends {}, T>(
+            collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+            predicate?: TObject
+        ): boolean;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.some
+         */
+        any(
+            predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        any(
+            predicate?: string,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        any<TObject extends {}>(
+            predicate?: TObject
+        ): boolean;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.some
+         */
+        any<TResult>(
+            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        any(
+            predicate?: string,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        any<TObject extends {}>(
+            predicate?: TObject
+        ): boolean;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.some
+         */
+        any(
+            predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.some
+         */
+        any(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.some
+         */
+        any<TObject extends {}>(
+            predicate?: TObject
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.some
+         */
+        any<TResult>(
+            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.some
+         */
+        any(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.some
+         */
+        any<TObject extends {}>(
+            predicate?: TObject
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.at
+    interface LoDashStatic {
+        /**
+         * Creates an array of elements corresponding to the given keys, or indexes, of collection. Keys may be
+         * specified as individual arguments or as arrays of keys.
+         *
+         * @param collection The collection to iterate over.
+         * @param props The property names or indexes of elements to pick, specified individually or in arrays.
+         * @return Returns the new array of picked elements.
+         */
+        at<T>(
+            collection: List<T>|Dictionary<T>,
+            ...props: (number|string|(number|string)[])[]
+        ): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.at
+         */
+        at(...props: (number|string|(number|string)[])[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.at
+         */
+        at<T>(...props: (number|string|(number|string)[])[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.at
+         */
+        at(...props: (number|string|(number|string)[])[]): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.at
+         */
+        at<T>(...props: (number|string|(number|string)[])[]): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.collect
+    interface LoDashStatic {
+        /**
+         * @see _.map
+         */
+        collect<T, TResult>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, TResult>,
+            thisArg?: any
+        ): TResult[];
+
+        /**
+         * @see _.map
+         */
+        collect<T extends {}, TResult>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, TResult>,
+            thisArg?: any
+        ): TResult[];
+
+        /**
+         * @see _.map
+         */
+        collect<T, TResult>(
+            collection: List<T>|Dictionary<T>,
+            iteratee?: string
+        ): TResult[];
+
+        /**
+         * @see _.map
+         */
+        collect<T, TObject extends {}>(
+            collection: List<T>|Dictionary<T>,
+            iteratee?: TObject
+        ): boolean[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.map
+         */
+        collect<TResult>(
+            iteratee?: ListIterator<T, TResult>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        collect<TResult>(
+            iteratee?: string
+        ): LoDashImplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        collect<TObject extends {}>(
+            iteratee?: TObject
+        ): LoDashImplicitArrayWrapper<boolean>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.map
+         */
+        collect<TValue, TResult>(
+            iteratee?: ListIterator<TValue, TResult>|DictionaryIterator<TValue, TResult>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        collect<TValue, TResult>(
+            iteratee?: string
+        ): LoDashImplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        collect<TObject extends {}>(
+            iteratee?: TObject
+        ): LoDashImplicitArrayWrapper<boolean>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.map
+         */
+        collect<TResult>(
+            iteratee?: ListIterator<T, TResult>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        collect<TResult>(
+            iteratee?: string
+        ): LoDashExplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        collect<TObject extends {}>(
+            iteratee?: TObject
+        ): LoDashExplicitArrayWrapper<boolean>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.map
+         */
+        collect<TValue, TResult>(
+            iteratee?: ListIterator<TValue, TResult>|DictionaryIterator<TValue, TResult>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        collect<TValue, TResult>(
+            iteratee?: string
+        ): LoDashExplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        collect<TObject extends {}>(
+            iteratee?: TObject
+        ): LoDashExplicitArrayWrapper<boolean>;
+    }
+
+    //_.contains
+    interface LoDashStatic {
+        /**
+         * @see _.includes
+         */
+        contains<T>(
+            collection: List<T>|Dictionary<T>,
+            target: T,
+            fromIndex?: number
+        ): boolean;
+
+        /**
+         * @see _.includes
+         */
+        contains(
+            collection: string,
+            target: string,
+            fromIndex?: number
+        ): boolean;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        contains(
+            target: T,
+            fromIndex?: number
+        ): boolean;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        contains<TValue>(
+            target: TValue,
+            fromIndex?: number
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        contains(
+            target: string,
+            fromIndex?: number
+        ): boolean;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        contains(
+            target: T,
+            fromIndex?: number
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        contains<TValue>(
+            target: TValue,
+            fromIndex?: number
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        contains(
+            target: string,
+            fromIndex?: number
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.countBy
+    interface LoDashStatic {
+        /**
+         * Creates an object composed of keys generated from the results of running each element of collection through
+         * iteratee. The corresponding value of each key is the number of times the key was returned by iteratee. The
+         * iteratee is bound to thisArg and invoked with three arguments:
+         * (value, index|key, collection).
+         *
+         * If a property name is provided for iteratee the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for iteratee the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param collection The collection to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the composed aggregate object.
+         */
+        countBy<T>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<number>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy<T>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<number>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy<T>(
+            collection: NumericDictionary<T>,
+            iteratee?: NumericDictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<number>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy<T>(
+            collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+            iteratee?: string,
+            thisArg?: any
+        ): Dictionary<number>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy<W, T>(
+            collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+            iteratee?: W
+        ): Dictionary<number>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy<T>(
+            collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+            iteratee?: Object
+        ): Dictionary<number>;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.countBy
+         */
+        countBy(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.countBy
+         */
+        countBy(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy<W>(
+            iteratee?: W
+        ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.countBy
+         */
+        countBy<T>(
+            iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>|NumericDictionaryIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy<W>(
+            iteratee?: W
+        ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.countBy
+         */
+        countBy(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.countBy
+         */
+        countBy(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy<W>(
+            iteratee?: W
+        ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.countBy
+         */
+        countBy<T>(
+            iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>|NumericDictionaryIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+
+        /**
+         * @see _.countBy
+         */
+        countBy<W>(
+            iteratee?: W
+        ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+    }
+
+    //_.detect
+    interface LoDashStatic {
+        /**
+         * @see _.find
+         */
+        detect<T>(
+            collection: List<T>,
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.find
+         */
+        detect<T>(
+            collection: Dictionary<T>,
+            predicate?: DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.find
+         */
+        detect<T>(
+            collection: List<T>|Dictionary<T>,
+            predicate?: string,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.find
+         */
+        detect<TObject extends {}, T>(
+            collection: List<T>|Dictionary<T>,
+            predicate?: TObject
+        ): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.find
+         */
+        detect(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.find
+         */
+        detect(
+            predicate?: string,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.find
+         */
+        detect<TObject extends {}>(
+            predicate?: TObject
+        ): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.find
+         */
+        detect<TResult>(
+            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see _.find
+         */
+        detect<TResult>(
+            predicate?: string,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see _.find
+         */
+        detect<TObject extends {}, TResult>(
+            predicate?: TObject
+        ): TResult;
+    }
+
+    //_.each
+    interface LoDashStatic {
+        /**
+         * @see _.forEach
+         */
+        each<T>(
+            collection: T[],
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.forEach
+         */
+        each<T>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): List<T>;
+
+        /**
+         * @see _.forEach
+         */
+        each<T>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.forEach
+         */
+        each<T extends {}>(
+            collection: T,
+            iteratee?: ObjectIterator<any, any>,
+            thisArgs?: any
+        ): T;
+
+        /**
+         * @see _.forEach
+         */
+        each<T extends {}, TValue>(
+            collection: T,
+            iteratee?: ObjectIterator<TValue, any>,
+            thisArgs?: any
+        ): T;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.forEach
+         */
+        each(
+            iteratee: ListIterator<string, any>,
+            thisArg?: any
+        ): LoDashImplicitWrapper<string>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.forEach
+         */
+        each(
+            iteratee: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.forEach
+         */
+        each<TValue>(
+            iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.forEach
+         */
+        each(
+            iteratee: ListIterator<string, any>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<string>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.forEach
+         */
+        each(
+            iteratee: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.forEach
+         */
+        each<TValue>(
+            iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.eachRight
+    interface LoDashStatic {
+        /**
+         * @see _.forEachRight
+         */
+        eachRight<T>(
+            collection: T[],
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.forEachRight
+         */
+        eachRight<T>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): List<T>;
+
+        /**
+         * @see _.forEachRight
+         */
+        eachRight<T>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.forEachRight
+         */
+        eachRight<T extends {}>(
+            collection: T,
+            iteratee?: ObjectIterator<any, any>,
+            thisArgs?: any
+        ): T;
+
+        /**
+         * @see _.forEachRight
+         */
+        eachRight<T extends {}, TValue>(
+            collection: T,
+            iteratee?: ObjectIterator<TValue, any>,
+            thisArgs?: any
+        ): T;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.forEachRight
+         */
+        eachRight(
+            iteratee: ListIterator<string, any>,
+            thisArg?: any
+        ): LoDashImplicitWrapper<string>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.forEachRight
+         */
+        eachRight(
+            iteratee: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.forEachRight
+         */
+        eachRight<TValue>(
+            iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.forEachRight
+         */
+        eachRight(
+            iteratee: ListIterator<string, any>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<string>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.forEachRight
+         */
+        eachRight(
+            iteratee: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.forEachRight
+         */
+        eachRight<TValue>(
+            iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.every
+    interface LoDashStatic {
+        /**
+         * Checks if predicate returns truthy for all elements of collection. The predicate is bound to thisArg and
+         * invoked with three arguments: (value, index|key, collection).
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @alias _.all
+         *
+         * @param collection The collection to iterate over.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns true if all elements pass the predicate check, else false.
+         */
+        every<T>(
+            collection: List<T>,
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        every<T>(
+            collection: Dictionary<T>,
+            predicate?: DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        every<T>(
+            collection: List<T>|Dictionary<T>,
+            predicate?: string,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        every<TObject extends {}, T>(
+            collection: List<T>|Dictionary<T>,
+            predicate?: TObject
+        ): boolean;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.every
+         */
+        every(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        every(
+            predicate?: string,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        every<TObject extends {}>(
+            predicate?: TObject
+        ): boolean;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.every
+         */
+        every<TResult>(
+            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        every(
+            predicate?: string,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.every
+         */
+        every<TObject extends {}>(
+            predicate?: TObject
+        ): boolean;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.every
+         */
+        every(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.every
+         */
+        every(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.every
+         */
+        every<TObject extends {}>(
+            predicate?: TObject
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.every
+         */
+        every<TResult>(
+            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.every
+         */
+        every(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.every
+         */
+        every<TObject extends {}>(
+            predicate?: TObject
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.filter
+    interface LoDashStatic {
+        /**
+         * Iterates over elements of collection, returning an array of all elements predicate returns truthy for. The
+         * predicate is bound to thisArg and invoked with three arguments: (value, index|key, collection).
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @alias _.select
+         *
+         * @param collection The collection to iterate over.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the new filtered array.
+         */
+        filter<T>(
+            collection: List<T>,
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.filter
+         */
+        filter<T>(
+            collection: Dictionary<T>,
+            predicate?: DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.filter
+         */
+        filter(
+            collection: string,
+            predicate?: StringIterator<boolean>,
+            thisArg?: any
+        ): string[];
+
+        /**
+         * @see _.filter
+         */
+        filter<T>(
+            collection: List<T>|Dictionary<T>,
+            predicate: string,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.filter
+         */
+        filter<W extends {}, T>(
+            collection: List<T>|Dictionary<T>,
+            predicate: W
+        ): T[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.filter
+         */
+        filter(
+            predicate?: StringIterator<boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<string>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.filter
+         */
+        filter(
+            predicate: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        filter(
+            predicate: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        filter<W>(predicate: W): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.filter
+         */
+        filter<T>(
+            predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        filter<T>(
+            predicate: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        filter<W, T>(predicate: W): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.filter
+         */
+        filter(
+            predicate?: StringIterator<boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<string>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.filter
+         */
+        filter(
+            predicate: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        filter(
+            predicate: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        filter<W>(predicate: W): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.filter
+         */
+        filter<T>(
+            predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        filter<T>(
+            predicate: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        filter<W, T>(predicate: W): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.find
+    interface LoDashStatic {
+        /**
+         * Iterates over elements of collection, returning the first element predicate returns truthy for.
+         * The predicate is bound to thisArg and invoked with three arguments: (value, index|key, collection).
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @alias _.detect
+         *
+         * @param collection The collection to search.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the matched element, else undefined.
+         */
+        find<T>(
+            collection: List<T>,
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.find
+         */
+        find<T>(
+            collection: Dictionary<T>,
+            predicate?: DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.find
+         */
+        find<T>(
+            collection: List<T>|Dictionary<T>,
+            predicate?: string,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.find
+         */
+        find<TObject extends {}, T>(
+            collection: List<T>|Dictionary<T>,
+            predicate?: TObject
+        ): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.find
+         */
+        find(
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.find
+         */
+        find(
+            predicate?: string,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.find
+         */
+        find<TObject extends {}>(
+            predicate?: TObject
+        ): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.find
+         */
+        find<TResult>(
+            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see _.find
+         */
+        find<TResult>(
+            predicate?: string,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see _.find
+         */
+        find<TObject extends {}, TResult>(
+            predicate?: TObject
+        ): TResult;
+    }
+
+    //_.findWhere
+    interface LoDashStatic {
+        /**
+        * @see _.find
+        **/
+        findWhere<T>(
+            collection: Array<T>,
+            callback: ListIterator<T, boolean>,
+            thisArg?: any): T;
+
+        /**
+        * @see _.find
+        **/
+        findWhere<T>(
+            collection: List<T>,
+            callback: ListIterator<T, boolean>,
+            thisArg?: any): T;
+
+        /**
+        * @see _.find
+        **/
+        findWhere<T>(
+            collection: Dictionary<T>,
+            callback: DictionaryIterator<T, boolean>,
+            thisArg?: any): T;
+
+        /**
+        * @see _.find
+        * @param _.matches style callback
+        **/
+        findWhere<W, T>(
+            collection: Array<T>,
+            whereValue: W): T;
+
+        /**
+        * @see _.find
+        * @param _.matches style callback
+        **/
+        findWhere<W, T>(
+            collection: List<T>,
+            whereValue: W): T;
+
+        /**
+        * @see _.find
+        * @param _.matches style callback
+        **/
+        findWhere<W, T>(
+            collection: Dictionary<T>,
+            whereValue: W): T;
+
+        /**
+        * @see _.find
+        * @param _.property style callback
+        **/
+        findWhere<T>(
+            collection: Array<T>,
+            pluckValue: string): T;
+
+        /**
+        * @see _.find
+        * @param _.property style callback
+        **/
+        findWhere<T>(
+            collection: List<T>,
+            pluckValue: string): T;
+
+        /**
+        * @see _.find
+        * @param _.property style callback
+        **/
+        findWhere<T>(
+            collection: Dictionary<T>,
+            pluckValue: string): T;
+    }
+
+    //_.findLast
+    interface LoDashStatic {
+        /**
+        * This method is like _.find except that it iterates over elements of a collection from
+        * right to left.
+        * @param collection Searches for a value in this list.
+        * @param callback The function called per iteration.
+        * @param thisArg The this binding of callback.
+        * @return The found element, else undefined.
+        **/
+        findLast<T>(
+            collection: Array<T>,
+            callback: ListIterator<T, boolean>,
+            thisArg?: any): T;
+
+        /**
+        * @see _.find
+        **/
+        findLast<T>(
+            collection: List<T>,
+            callback: ListIterator<T, boolean>,
+            thisArg?: any): T;
+
+        /**
+        * @see _.find
+        **/
+        findLast<T>(
+            collection: Dictionary<T>,
+            callback: DictionaryIterator<T, boolean>,
+            thisArg?: any): T;
+
+        /**
+        * @see _.find
+        * @param _.pluck style callback
+        **/
+        findLast<W, T>(
+            collection: Array<T>,
+            whereValue: W): T;
+
+        /**
+        * @see _.find
+        * @param _.pluck style callback
+        **/
+        findLast<W, T>(
+            collection: List<T>,
+            whereValue: W): T;
+
+        /**
+        * @see _.find
+        * @param _.pluck style callback
+        **/
+        findLast<W, T>(
+            collection: Dictionary<T>,
+            whereValue: W): T;
+
+        /**
+        * @see _.find
+        * @param _.where style callback
+        **/
+        findLast<T>(
+            collection: Array<T>,
+            pluckValue: string): T;
+
+        /**
+        * @see _.find
+        * @param _.where style callback
+        **/
+        findLast<T>(
+            collection: List<T>,
+            pluckValue: string): T;
+
+        /**
+        * @see _.find
+        * @param _.where style callback
+        **/
+        findLast<T>(
+            collection: Dictionary<T>,
+            pluckValue: string): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+        * @see _.findLast
+        */
+        findLast(
+            callback: ListIterator<T, boolean>,
+            thisArg?: any): T;
+        /**
+        * @see _.findLast
+        * @param _.where style callback
+        */
+        findLast<W>(
+            whereValue: W): T;
+
+        /**
+        * @see _.findLast
+        * @param _.where style callback
+        */
+        findLast(
+            pluckValue: string): T;
+    }
+
+    //_.forEach
+    interface LoDashStatic {
+        /**
+         * Iterates over elements of collection invoking iteratee for each element. The iteratee is bound to thisArg
+         * and invoked with three arguments:
+         * (value, index|key, collection). Iteratee functions may exit iteration early by explicitly returning false.
+         *
+         * Note: As with other "Collections" methods, objects with a "length" property are iterated like arrays. To
+         * avoid this behavior _.forIn or _.forOwn may be used for object iteration.
+         *
+         * @alias _.each
+         *
+         * @param collection The collection to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         */
+        forEach<T>(
+            collection: T[],
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.forEach
+         */
+        forEach<T>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): List<T>;
+
+        /**
+         * @see _.forEach
+         */
+        forEach<T>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.forEach
+         */
+        forEach<T extends {}>(
+            collection: T,
+            iteratee?: ObjectIterator<any, any>,
+            thisArgs?: any
+        ): T;
+
+        /**
+         * @see _.forEach
+         */
+        forEach<T extends {}, TValue>(
+            collection: T,
+            iteratee?: ObjectIterator<TValue, any>,
+            thisArgs?: any
+        ): T;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.forEach
+         */
+        forEach(
+            iteratee: ListIterator<string, any>,
+            thisArg?: any
+        ): LoDashImplicitWrapper<string>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.forEach
+         */
+        forEach(
+            iteratee: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.forEach
+         */
+        forEach<TValue>(
+            iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.forEach
+         */
+        forEach(
+            iteratee: ListIterator<string, any>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<string>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.forEach
+         */
+        forEach(
+            iteratee: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.forEach
+         */
+        forEach<TValue>(
+            iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.forEachRight
+    interface LoDashStatic {
+        /**
+         * This method is like _.forEach except that it iterates over elements of collection from right to left.
+         *
+         * @alias _.eachRight
+         *
+         * @param collection The collection to iterate over.
+         * @param iteratee The function called per iteration.
+         * @param thisArg The this binding of callback.
+         */
+        forEachRight<T>(
+            collection: T[],
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.forEachRight
+         */
+        forEachRight<T>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): List<T>;
+
+        /**
+         * @see _.forEachRight
+         */
+        forEachRight<T>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.forEachRight
+         */
+        forEachRight<T extends {}>(
+            collection: T,
+            iteratee?: ObjectIterator<any, any>,
+            thisArgs?: any
+        ): T;
+
+        /**
+         * @see _.forEachRight
+         */
+        forEachRight<T extends {}, TValue>(
+            collection: T,
+            iteratee?: ObjectIterator<TValue, any>,
+            thisArgs?: any
+        ): T;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.forEachRight
+         */
+        forEachRight(
+            iteratee: ListIterator<string, any>,
+            thisArg?: any
+        ): LoDashImplicitWrapper<string>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.forEachRight
+         */
+        forEachRight(
+            iteratee: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.forEachRight
+         */
+        forEachRight<TValue>(
+            iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.forEachRight
+         */
+        forEachRight(
+            iteratee: ListIterator<string, any>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<string>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.forEachRight
+         */
+        forEachRight(
+            iteratee: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.forEachRight
+         */
+        forEachRight<TValue>(
+            iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.groupBy
+    interface LoDashStatic {
+        /**
+         * Creates an object composed of keys generated from the results of running each element of collection through
+         * iteratee. The corresponding value of each key is an array of the elements responsible for generating the
+         * key. The iteratee is bound to thisArg and invoked with three arguments:
+         * (value, index|key, collection).
+         *
+         * If a property name is provided for iteratee the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for iteratee the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param collection The collection to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the composed aggregate object.
+         */
+        groupBy<T, TKey>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, TKey>,
+            thisArg?: any
+        ): Dictionary<T[]>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T>(
+            collection: List<any>,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T[]>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T, TKey>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, TKey>,
+            thisArg?: any
+        ): Dictionary<T[]>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T>(
+            collection: Dictionary<any>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T[]>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T, TValue>(
+            collection: List<T>|Dictionary<T>,
+            iteratee?: string,
+            thisArg?: TValue
+        ): Dictionary<T[]>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T>(
+            collection: List<T>|Dictionary<T>,
+            iteratee?: string,
+            thisArg?: any
+        ): Dictionary<T[]>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<TWhere, T>(
+            collection: List<T>|Dictionary<T>,
+            iteratee?: TWhere
+        ): Dictionary<T[]>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T>(
+            collection: List<T>|Dictionary<T>,
+            iteratee?: Object
+        ): Dictionary<T[]>;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.groupBy
+         */
+        groupBy<TKey>(
+            iteratee?: ListIterator<T, TKey>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.groupBy
+         */
+        groupBy<TKey>(
+            iteratee?: ListIterator<T, TKey>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<TValue>(
+            iteratee?: string,
+            thisArg?: TValue
+        ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<TWhere>(
+            iteratee?: TWhere
+        ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T, TKey>(
+            iteratee?: ListIterator<T, TKey>|DictionaryIterator<T, TKey>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T>(
+            iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T, TValue>(
+            iteratee?: string,
+            thisArg?: TValue
+        ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<TWhere, T>(
+            iteratee?: TWhere
+        ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T>(
+            iteratee?: Object
+        ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.groupBy
+         */
+        groupBy<TKey>(
+            iteratee?: ListIterator<T, TKey>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.groupBy
+         */
+        groupBy<TKey>(
+            iteratee?: ListIterator<T, TKey>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<TValue>(
+            iteratee?: string,
+            thisArg?: TValue
+        ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<TWhere>(
+            iteratee?: TWhere
+        ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T, TKey>(
+            iteratee?: ListIterator<T, TKey>|DictionaryIterator<T, TKey>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T>(
+            iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T, TValue>(
+            iteratee?: string,
+            thisArg?: TValue
+        ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<TWhere, T>(
+            iteratee?: TWhere
+        ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+        /**
+         * @see _.groupBy
+         */
+        groupBy<T>(
+            iteratee?: Object
+        ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+    }
+
+    //_.include
+    interface LoDashStatic {
+        /**
+         * @see _.includes
+         */
+        include<T>(
+            collection: List<T>|Dictionary<T>,
+            target: T,
+            fromIndex?: number
+        ): boolean;
+
+        /**
+         * @see _.includes
+         */
+        include(
+            collection: string,
+            target: string,
+            fromIndex?: number
+        ): boolean;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        include(
+            target: T,
+            fromIndex?: number
+        ): boolean;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        include<TValue>(
+            target: TValue,
+            fromIndex?: number
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        include(
+            target: string,
+            fromIndex?: number
+        ): boolean;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        include(
+            target: T,
+            fromIndex?: number
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        include<TValue>(
+            target: TValue,
+            fromIndex?: number
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        include(
+            target: string,
+            fromIndex?: number
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.includes
+    interface LoDashStatic {
+        /**
+         * Checks if target is in collection using SameValueZero for equality comparisons. If fromIndex is negative,
+         * it’s used as the offset from the end of collection.
+         *
+         * @alias _.contains, _.include
+         *
+         * @param collection The collection to search.
+         * @param target The value to search for.
+         * @param fromIndex The index to search from.
+         * @return True if the target element is found, else false.
+         */
+        includes<T>(
+            collection: List<T>|Dictionary<T>,
+            target: T,
+            fromIndex?: number
+        ): boolean;
+
+        /**
+         * @see _.includes
+         */
+        includes(
+            collection: string,
+            target: string,
+            fromIndex?: number
+        ): boolean;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        includes(
+            target: T,
+            fromIndex?: number
+        ): boolean;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        includes<TValue>(
+            target: TValue,
+            fromIndex?: number
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        includes(
+            target: string,
+            fromIndex?: number
+        ): boolean;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        includes(
+            target: T,
+            fromIndex?: number
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        includes<TValue>(
+            target: TValue,
+            fromIndex?: number
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.includes
+         */
+        includes(
+            target: string,
+            fromIndex?: number
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.indexBy
+    interface LoDashStatic {
+        /**
+         * Creates an object composed of keys generated from the results of running each element of collection through
+         * iteratee. The corresponding value of each key is the last element responsible for generating the key. The
+         * iteratee function is bound to thisArg and invoked with three arguments:
+         * (value, index|key, collection).
+         *
+         * If a property name is provided for iteratee the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for iteratee the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param collection The collection to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the composed aggregate object.
+         */
+        indexBy<T>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<T>(
+            collection: NumericDictionary<T>,
+            iteratee?: NumericDictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<T>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<T>(
+            collection: List<T>|NumericDictionary<T>|Dictionary<T>,
+            iteratee?: string,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<W extends Object, T>(
+            collection: List<T>|NumericDictionary<T>|Dictionary<T>,
+            iteratee?: W
+        ): Dictionary<T>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<T>(
+            collection: List<T>|NumericDictionary<T>|Dictionary<T>,
+            iteratee?: Object
+        ): Dictionary<T>;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.indexBy
+         */
+        indexBy(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.indexBy
+         */
+        indexBy(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<W extends Object>(
+            iteratee?: W
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.indexBy
+         */
+        indexBy<T>(
+            iteratee?: ListIterator<T, any>|NumericDictionaryIterator<T, any>|DictionaryIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<W extends Object, T>(
+            iteratee?: W
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<T>(
+            iteratee?: Object
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.indexBy
+         */
+        indexBy(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.indexBy
+         */
+        indexBy(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<W extends Object>(
+            iteratee?: W
+        ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.indexBy
+         */
+        indexBy<T>(
+            iteratee?: ListIterator<T, any>|NumericDictionaryIterator<T, any>|DictionaryIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<W extends Object, T>(
+            iteratee?: W
+        ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.indexBy
+         */
+        indexBy<T>(
+            iteratee?: Object
+        ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+    }
+
+    //_.invoke
+    interface LoDashStatic {
+        /**
+        * Invokes the method named by methodName on each element in the collection returning
+        * an array of the results of each invoked method. Additional arguments will be provided
+        * to each invoked method. If methodName is a function it will be invoked for, and this
+        * bound to, each element in the collection.
+        * @param collection The collection to iterate over.
+        * @param methodName The name of the method to invoke.
+        * @param args Arguments to invoke the method with.
+        **/
+        invoke<T extends {}>(
+            collection: Array<T>,
+            methodName: string,
+            ...args: any[]): any;
+
+        /**
+        * @see _.invoke
+        **/
+        invoke<T extends {}>(
+            collection: List<T>,
+            methodName: string,
+            ...args: any[]): any;
+
+        /**
+        * @see _.invoke
+        **/
+        invoke<T extends {}>(
+            collection: Dictionary<T>,
+            methodName: string,
+            ...args: any[]): any;
+
+        /**
+        * @see _.invoke
+        **/
+        invoke<T extends {}>(
+            collection: Array<T>,
+            method: Function,
+            ...args: any[]): any;
+
+        /**
+        * @see _.invoke
+        **/
+        invoke<T extends {}>(
+            collection: List<T>,
+            method: Function,
+            ...args: any[]): any;
+
+        /**
+        * @see _.invoke
+        **/
+        invoke<T extends {}>(
+            collection: Dictionary<T>,
+            method: Function,
+            ...args: any[]): any;
+    }
+
+    //_.map
+    interface LoDashStatic {
+        /**
+         * Creates an array of values by running each element in collection through iteratee. The iteratee is bound to
+         * thisArg and invoked with three arguments: (value, index|key, collection).
+         *
+         * If a property name is provided for iteratee the created _.property style callback returns the property value
+         * of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for iteratee the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * Many lodash methods are guarded to work as iteratees for methods like _.every, _.filter, _.map, _.mapValues,
+         * _.reject, and _.some.
+         *
+         * The guarded methods are:
+         * ary, callback, chunk, clone, create, curry, curryRight, drop, dropRight, every, fill, flatten, invert, max,
+         * min, parseInt, slice, sortBy, take, takeRight, template, trim, trimLeft, trimRight, trunc, random, range,
+         * sample, some, sum, uniq, and words
+         *
+         * @alias _.collect
+         *
+         * @param collection The collection to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the new mapped array.
+         */
+        map<T, TResult>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, TResult>,
+            thisArg?: any
+        ): TResult[];
+
+        /**
+         * @see _.map
+         */
+        map<T extends {}, TResult>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, TResult>,
+            thisArg?: any
+        ): TResult[];
+
+        /**
+         * @see _.map
+         */
+        map<T, TResult>(
+            collection: List<T>|Dictionary<T>,
+            iteratee?: string
+        ): TResult[];
+
+        /**
+         * @see _.map
+         */
+        map<T, TObject extends {}>(
+            collection: List<T>|Dictionary<T>,
+            iteratee?: TObject
+        ): boolean[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.map
+         */
+        map<TResult>(
+            iteratee?: ListIterator<T, TResult>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        map<TResult>(
+            iteratee?: string
+        ): LoDashImplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        map<TObject extends {}>(
+            iteratee?: TObject
+        ): LoDashImplicitArrayWrapper<boolean>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.map
+         */
+        map<TValue, TResult>(
+            iteratee?: ListIterator<TValue, TResult>|DictionaryIterator<TValue, TResult>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        map<TValue, TResult>(
+            iteratee?: string
+        ): LoDashImplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        map<TObject extends {}>(
+            iteratee?: TObject
+        ): LoDashImplicitArrayWrapper<boolean>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.map
+         */
+        map<TResult>(
+            iteratee?: ListIterator<T, TResult>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        map<TResult>(
+            iteratee?: string
+        ): LoDashExplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        map<TObject extends {}>(
+            iteratee?: TObject
+        ): LoDashExplicitArrayWrapper<boolean>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.map
+         */
+        map<TValue, TResult>(
+            iteratee?: ListIterator<TValue, TResult>|DictionaryIterator<TValue, TResult>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        map<TValue, TResult>(
+            iteratee?: string
+        ): LoDashExplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.map
+         */
+        map<TObject extends {}>(
+            iteratee?: TObject
+        ): LoDashExplicitArrayWrapper<boolean>;
+    }
+
+    //_.partition
+    interface LoDashStatic {
+        /**
+        * Creates an array of elements split into two groups, the first of which contains elements predicate returns truthy for,
+        * while the second of which contains elements predicate returns falsey for.
+        * The predicate is bound to thisArg and invoked with three arguments: (value, index|key, collection).
+        *
+        * If a property name is provided for predicate the created _.property style callback
+        * returns the property value of the given element.
+        *
+        * If a value is also provided for thisArg the created _.matchesProperty style callback
+        * returns true for elements that have a matching property value, else false.
+        *
+        * If an object is provided for predicate the created _.matches style callback returns
+        * true for elements that have the properties of the given object, else false.
+        *
+        * @param collection The collection to iterate over.
+        * @param callback The function called per iteration.
+        * @param thisArg The this binding of predicate.
+        * @return Returns the array of grouped elements.
+        **/
+        partition<T>(
+            collection: List<T>,
+            callback: ListIterator<T, boolean>,
+            thisArg?: any): T[][];
+
+        /**
+         * @see _.partition
+         **/
+        partition<T>(
+            collection: Dictionary<T>,
+            callback: DictionaryIterator<T, boolean>,
+            thisArg?: any): T[][];
+
+        /**
+         * @see _.partition
+         **/
+        partition<W, T>(
+            collection: List<T>,
+            whereValue: W): T[][];
+
+        /**
+         * @see _.partition
+         **/
+        partition<W, T>(
+            collection: Dictionary<T>,
+            whereValue: W): T[][];
+
+        /**
+         * @see _.partition
+         **/
+        partition<T>(
+            collection: List<T>,
+            path: string,
+            srcValue: any): T[][];
+
+        /**
+         * @see _.partition
+         **/
+        partition<T>(
+            collection: Dictionary<T>,
+            path: string,
+            srcValue: any): T[][];
+
+        /**
+         * @see _.partition
+         **/
+        partition<T>(
+            collection: List<T>,
+            pluckValue: string): T[][];
+
+        /**
+         * @see _.partition
+         **/
+        partition<T>(
+            collection: Dictionary<T>,
+            pluckValue: string): T[][];
+    }
+
+    interface LoDashImplicitStringWrapper {
+        /**
+         * @see _.partition
+         */
+        partition(
+            callback: ListIterator<string, boolean>,
+            thisArg?: any): LoDashImplicitArrayWrapper<string[]>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.partition
+         */
+        partition(
+            callback: ListIterator<T, boolean>,
+            thisArg?: any): LoDashImplicitArrayWrapper<T[]>;
+        /**
+         * @see _.partition
+         */
+        partition<W>(
+            whereValue: W): LoDashImplicitArrayWrapper<T[]>;
+        /**
+         * @see _.partition
+         */
+        partition(
+            path: string,
+            srcValue: any): LoDashImplicitArrayWrapper<T[]>;
+        /**
+         * @see _.partition
+         */
+        partition(
+            pluckValue: string): LoDashImplicitArrayWrapper<T[]>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.partition
+         */
+        partition<TResult>(
+            callback: ListIterator<TResult, boolean>,
+            thisArg?: any): LoDashImplicitArrayWrapper<TResult[]>;
+
+        /**
+         * @see _.partition
+         */
+        partition<TResult>(
+            callback: DictionaryIterator<TResult, boolean>,
+            thisArg?: any): LoDashImplicitArrayWrapper<TResult[]>;
+
+        /**
+         * @see _.partition
+         */
+        partition<W, TResult>(
+            whereValue: W): LoDashImplicitArrayWrapper<TResult[]>;
+
+        /**
+         * @see _.partition
+         */
+        partition<TResult>(
+            path: string,
+            srcValue: any): LoDashImplicitArrayWrapper<TResult[]>;
+
+        /**
+         * @see _.partition
+         */
+        partition<TResult>(
+            pluckValue: string): LoDashImplicitArrayWrapper<TResult[]>;
+    }
+
+    //_.pluck
+    interface LoDashStatic {
+        /**
+         * Gets the property value of path from all elements in collection.
+         *
+         * @param collection The collection to iterate over.
+         * @param path The path of the property to pluck.
+         * @return A new array of property values.
+         */
+        pluck<T extends {}>(
+            collection: List<T>|Dictionary<T>,
+            path: StringRepresentable|StringRepresentable[]
+        ): any[];
+
+        /**
+         * @see _.pluck
+         */
+        pluck<T extends {}, TResult>(
+            collection: List<T>|Dictionary<T>,
+            path: StringRepresentable|StringRepresentable[]
+        ): TResult[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.pluck
+         */
+        pluck<TResult>(path: StringRepresentable|StringRepresentable[]): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.pluck
+         */
+        pluck<TResult>(path: StringRepresentable|StringRepresentable[]): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.pluck
+         */
+        pluck<TResult>(path: StringRepresentable|StringRepresentable[]): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.pluck
+         */
+        pluck<TResult>(path: StringRepresentable|StringRepresentable[]): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    //_.reduce
+    interface LoDashStatic {
+        /**
+        * Reduces a collection to a value which is the accumulated result of running each
+        * element in the collection through the callback, where each successive callback execution
+        * consumes the return value of the previous execution. If accumulator is not provided the
+        * first element of the collection will be used as the initial accumulator value. The callback
+        * is bound to thisArg and invoked with four arguments; (accumulator, value, index|key, collection).
+        * @param collection The collection to iterate over.
+        * @param callback The function called per iteration.
+        * @param accumulator Initial value of the accumulator.
+        * @param thisArg The this binding of callback.
+        * @return Returns the accumulated value.
+        **/
+        reduce<T, TResult>(
+            collection: Array<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        reduce<T, TResult>(
+            collection: List<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        reduce<T, TResult>(
+            collection: Dictionary<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        reduce<T, TResult>(
+            collection: Array<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        reduce<T, TResult>(
+            collection: List<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        reduce<T, TResult>(
+            collection: Dictionary<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<T, TResult>(
+            collection: Array<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<T, TResult>(
+            collection: List<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<T, TResult>(
+            collection: Dictionary<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<T, TResult>(
+            collection: Array<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<T, TResult>(
+            collection: List<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<T, TResult>(
+            collection: Dictionary<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<T, TResult>(
+            collection: Array<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<T, TResult>(
+            collection: List<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<T, TResult>(
+            collection: Dictionary<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<T, TResult>(
+            collection: Array<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<T, TResult>(
+            collection: List<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<T, TResult>(
+            collection: Dictionary<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+         /**
+        * @see _.reduce
+        **/
+        reduce<TResult>(
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        reduce<TResult>(
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<TResult>(
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<TResult>(
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<TResult>(
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<TResult>(
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+         /**
+        * @see _.reduce
+        **/
+        reduce<TValue, TResult>(
+            callback: MemoIterator<TValue, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        reduce<TValue, TResult>(
+            callback: MemoIterator<TValue, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<TValue, TResult>(
+            callback: MemoIterator<TValue, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        inject<TValue, TResult>(
+            callback: MemoIterator<TValue, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<TValue, TResult>(
+            callback: MemoIterator<TValue, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduce
+        **/
+        foldl<TValue, TResult>(
+            callback: MemoIterator<TValue, TResult>,
+            thisArg?: any): TResult;
+    }
+
+    //_.reduceRight
+    interface LoDashStatic {
+        /**
+        * This method is like _.reduce except that it iterates over elements of a collection from
+        * right to left.
+        * @param collection The collection to iterate over.
+        * @param callback The function called per iteration.
+        * @param accumulator Initial value of the accumulator.
+        * @param thisArg The this binding of callback.
+        * @return The accumulated value.
+        **/
+        reduceRight<T, TResult>(
+            collection: Array<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduceRight
+        **/
+        reduceRight<T, TResult>(
+            collection: List<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduceRight
+        **/
+        reduceRight<T, TResult>(
+            collection: Dictionary<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduceRight
+        **/
+        reduceRight<T, TResult>(
+            collection: Array<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduceRight
+        **/
+        reduceRight<T, TResult>(
+            collection: List<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduceRight
+        **/
+        reduceRight<T, TResult>(
+            collection: Dictionary<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduceRight
+        **/
+        foldr<T, TResult>(
+            collection: Array<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduceRight
+        **/
+        foldr<T, TResult>(
+            collection: List<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduceRight
+        **/
+        foldr<T, TResult>(
+            collection: Dictionary<T>,
+            callback: MemoIterator<T, TResult>,
+            accumulator: TResult,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduceRight
+        **/
+        foldr<T, TResult>(
+            collection: Array<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduceRight
+        **/
+        foldr<T, TResult>(
+            collection: List<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+
+        /**
+        * @see _.reduceRight
+        **/
+        foldr<T, TResult>(
+            collection: Dictionary<T>,
+            callback: MemoIterator<T, TResult>,
+            thisArg?: any): TResult;
+    }
+
+    //_.reject
+    interface LoDashStatic {
+        /**
+         * The opposite of _.filter; this method returns the elements of collection that predicate does not return
+         * truthy for.
+         *
+         * @param collection The collection to iterate over.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the new filtered array.
+         */
+        reject<T>(
+            collection: List<T>,
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.reject
+         */
+        reject<T>(
+            collection: Dictionary<T>,
+            predicate?: DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.reject
+         */
+        reject(
+            collection: string,
+            predicate?: StringIterator<boolean>,
+            thisArg?: any
+        ): string[];
+
+        /**
+         * @see _.reject
+         */
+        reject<T>(
+            collection: List<T>|Dictionary<T>,
+            predicate: string,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.reject
+         */
+        reject<W extends {}, T>(
+            collection: List<T>|Dictionary<T>,
+            predicate: W
+        ): T[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.reject
+         */
+        reject(
+            predicate?: StringIterator<boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<string>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.reject
+         */
+        reject(
+            predicate: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.reject
+         */
+        reject(
+            predicate: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.reject
+         */
+        reject<W>(predicate: W): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.reject
+         */
+        reject<T>(
+            predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.reject
+         */
+        reject<T>(
+            predicate: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.reject
+         */
+        reject<W, T>(predicate: W): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.reject
+         */
+        reject(
+            predicate?: StringIterator<boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<string>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.reject
+         */
+        reject(
+            predicate: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.reject
+         */
+        reject(
+            predicate: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.reject
+         */
+        reject<W>(predicate: W): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.reject
+         */
+        reject<T>(
+            predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.reject
+         */
+        reject<T>(
+            predicate: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.reject
+         */
+        reject<W, T>(predicate: W): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.sample
+    interface LoDashStatic {
+        /**
+        * Retrieves a random element or n random elements from a collection.
+        * @param collection The collection to sample.
+        * @return Returns the random sample(s) of collection.
+        **/
+        sample<T>(collection: Array<T>): T;
+
+        /**
+        * @see _.sample
+        **/
+        sample<T>(collection: List<T>): T;
+
+        /**
+        * @see _.sample
+        **/
+        sample<T>(collection: Dictionary<T>): T;
+
+        /**
+        * @see _.sample
+        * @param n The number of elements to sample.
+        **/
+        sample<T>(collection: Array<T>, n: number): T[];
+
+        /**
+        * @see _.sample
+        * @param n The number of elements to sample.
+        **/
+        sample<T>(collection: List<T>, n: number): T[];
+
+        /**
+        * @see _.sample
+        * @param n The number of elements to sample.
+        **/
+        sample<T>(collection: Dictionary<T>, n: number): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.sample
+         **/
+        sample(n: number): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sample
+         **/
+        sample(): LoDashImplicitWrapper<T>;
+    }
+
+    //_.select
+    interface LoDashStatic {
+        /**
+         * @see _.filter
+         */
+        select<T>(
+            collection: List<T>,
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.filter
+         */
+        select<T>(
+            collection: Dictionary<T>,
+            predicate?: DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.filter
+         */
+        select(
+            collection: string,
+            predicate?: StringIterator<boolean>,
+            thisArg?: any
+        ): string[];
+
+        /**
+         * @see _.filter
+         */
+        select<T>(
+            collection: List<T>|Dictionary<T>,
+            predicate: string,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.filter
+         */
+        select<W extends {}, T>(
+            collection: List<T>|Dictionary<T>,
+            predicate: W
+        ): T[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.filter
+         */
+        select(
+            predicate?: StringIterator<boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<string>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.filter
+         */
+        select(
+            predicate: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        select(
+            predicate: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        select<W>(predicate: W): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.filter
+         */
+        select<T>(
+            predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        select<T>(
+            predicate: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        select<W, T>(predicate: W): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.filter
+         */
+        select(
+            predicate?: StringIterator<boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<string>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.filter
+         */
+        select(
+            predicate: ListIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        select(
+            predicate: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        select<W>(predicate: W): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.filter
+         */
+        select<T>(
+            predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        select<T>(
+            predicate: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.filter
+         */
+        select<W, T>(predicate: W): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.shuffle
+    interface LoDashStatic {
+        /**
+         * Creates an array of shuffled values, using a version of the Fisher-Yates shuffle.
+         *
+         * @param collection The collection to shuffle.
+         * @return Returns the new shuffled array.
+         */
+        shuffle<T>(collection: List<T>|Dictionary<T>): T[];
+
+        /**
+         * @see _.shuffle
+         */
+        shuffle(collection: string): string[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.shuffle
+         */
+        shuffle(): LoDashImplicitArrayWrapper<string>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.shuffle
+         */
+        shuffle(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.shuffle
+         */
+        shuffle<T>(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.shuffle
+         */
+        shuffle(): LoDashExplicitArrayWrapper<string>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.shuffle
+         */
+        shuffle(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.shuffle
+         */
+        shuffle<T>(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.size
+    interface LoDashStatic {
+        /**
+         * Gets the size of collection by returning its length for array-like values or the number of own enumerable
+         * properties for objects.
+         *
+         * @param collection The collection to inspect.
+         * @return Returns the size of collection.
+         */
+        size<T>(collection: List<T>|Dictionary<T>): number;
+
+        /**
+         * @see _.size
+         */
+        size(collection: string): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.size
+         */
+        size(): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.size
+         */
+        size(): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.size
+         */
+        size(): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.size
+         */
+        size(): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.size
+         */
+        size(): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.size
+         */
+        size(): LoDashExplicitWrapper<number>;
+    }
+
+    //_.some
+    interface LoDashStatic {
+        /**
+         * Checks if predicate returns truthy for any element of collection. The function returns as soon as it finds
+         * a passing value and does not iterate over the entire collection. The predicate is bound to thisArg and
+         * invoked with three arguments: (value, index|key, collection).
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @alias _.any
+         *
+         * @param collection The collection to iterate over.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns true if any element passes the predicate check, else false.
+         */
+        some<T>(
+            collection: List<T>,
+            predicate?: ListIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        some<T>(
+            collection: Dictionary<T>,
+            predicate?: DictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        some<T>(
+            collection: NumericDictionary<T>,
+            predicate?: NumericDictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        some<T>(
+            collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+            predicate?: string,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        some<TObject extends {}, T>(
+            collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+            predicate?: TObject
+        ): boolean;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.some
+         */
+        some(
+            predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        some(
+            predicate?: string,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        some<TObject extends {}>(
+            predicate?: TObject
+        ): boolean;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.some
+         */
+        some<TResult>(
+            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        some(
+            predicate?: string,
+            thisArg?: any
+        ): boolean;
+
+        /**
+         * @see _.some
+         */
+        some<TObject extends {}>(
+            predicate?: TObject
+        ): boolean;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.some
+         */
+        some(
+            predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.some
+         */
+        some(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.some
+         */
+        some<TObject extends {}>(
+            predicate?: TObject
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.some
+         */
+        some<TResult>(
+            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.some
+         */
+        some(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.some
+         */
+        some<TObject extends {}>(
+            predicate?: TObject
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.sortBy
+    interface LoDashStatic {
+        /**
+         * Creates an array of elements, sorted in ascending order by the results of running each element in a
+         * collection through iteratee. This method performs a stable sort, that is, it preserves the original sort
+         * order of equal elements. The iteratee is bound to thisArg and invoked with three arguments:
+         * (value, index|key, collection).
+         *
+         * If a property name is provided for iteratee the created _.property style callback returns the property
+         * valueof the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for iteratee the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param collection The collection to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the new sorted array.
+         */
+        sortBy<T, TSort>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<T, TSort>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, TSort>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<T>(
+            collection: List<T>|Dictionary<T>,
+            iteratee: string
+        ): T[];
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<W extends {}, T>(
+            collection: List<T>|Dictionary<T>,
+            whereValue: W
+        ): T[];
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<T>(
+            collection: List<T>|Dictionary<T>
+        ): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.sortBy
+         */
+        sortBy<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy(iteratee: string): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<W extends {}>(whereValue: W): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.sortBy
+         */
+        sortBy<T, TSort>(
+            iteratee?: ListIterator<T, TSort>|DictionaryIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<T>(iteratee: string): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<W extends {}, T>(whereValue: W): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<T>(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.sortBy
+         */
+        sortBy<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy(iteratee: string): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<W extends {}>(whereValue: W): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.sortBy
+         */
+        sortBy<T, TSort>(
+            iteratee?: ListIterator<T, TSort>|DictionaryIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<T>(iteratee: string): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<W extends {}, T>(whereValue: W): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<T>(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.sortByAll
+    interface LoDashStatic {
+        /**
+        * This method is like "_.sortBy" except that it can sort by multiple iteratees or
+        * property names.
+        *
+        * If a property name is provided for an iteratee the created "_.property" style callback
+        * returns the property value of the given element.
+        *
+        * If a value is also provided for thisArg the created "_.matchesProperty" style callback
+        * returns true for elements that have a matching property value, else false.
+        *
+        * If an object is provided for an iteratee the created "_.matches" style callback returns
+        * true for elements that have the properties of the given object, else false.
+        *
+        * @param collection The collection to iterate over.
+        * @param callback The function called per iteration.
+        * @param thisArg The this binding of callback.
+        * @return A new array of sorted elements.
+        **/
+        sortByAll<T>(
+            collection: Array<T>,
+            iteratees: (ListIterator<T, any>|string|Object)[]): T[];
+
+        /**
+        * @see _.sortByAll
+        **/
+        sortByAll<T>(
+            collection: List<T>,
+            iteratees: (ListIterator<T, any>|string|Object)[]): T[];
+
+        /**
+        * @see _.sortByAll
+        **/
+        sortByAll<T>(
+            collection: Array<T>,
+            ...iteratees: (ListIterator<T, any>|string|Object)[]): T[];
+
+        /**
+        * @see _.sortByAll
+        **/
+        sortByAll<T>(
+            collection: List<T>,
+            ...iteratees: (ListIterator<T, any>|string|Object)[]): T[];
+
+        /**
+         * Sorts by all the given arguments, using either ListIterator, pluckValue, or whereValue foramts
+         * @param args The rules by which to sort
+         */
+        sortByAll<T>(
+            collection: (Array<T>|List<T>),
+            ...args: (ListIterator<T, boolean>|Object|string)[]
+        ): T[];
+    }
+
+    interface 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)[]): LoDashImplicitArrayWrapper<T>;
+
+        /**
+        * @see _.sortByAll
+        **/
+        sortByAll(
+            iteratees: (ListIterator<T, any>|string|Object)[]): LoDashImplicitArrayWrapper<T>;
+
+        /**
+        * @see _.sortByAll
+        **/
+        sortByAll(
+            ...iteratees: (ListIterator<T, any>|string|Object)[]): LoDashImplicitArrayWrapper<T>;
+    }
+
+    //_.sortByOrder
+    interface LoDashStatic {
+        /**
+         * This method is like _.sortByAll except that it allows specifying the sort orders of the iteratees to sort
+         * by. If orders is unspecified, all values are sorted in ascending order. Otherwise, a value is sorted in
+         * ascending order if its corresponding order is "asc", and descending if "desc".
+         *
+         * If a property name is provided for an iteratee the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If an object is provided for an iteratee the created _.matches style callback returns true for elements
+         * that have the properties of the given object, else false.
+         *
+         * @param collection The collection to iterate over.
+         * @param iteratees The iteratees to sort by.
+         * @param orders The sort orders of iteratees.
+         * @return Returns the new sorted array.
+         */
+        sortByOrder<W extends Object, T>(
+            collection: List<T>,
+            iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): T[];
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<T>(
+            collection: List<T>,
+            iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): T[];
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<W extends Object, T>(
+            collection: NumericDictionary<T>,
+            iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): T[];
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<T>(
+            collection: NumericDictionary<T>,
+            iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): T[];
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<W extends Object, T>(
+            collection: Dictionary<T>,
+            iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): T[];
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<T>(
+            collection: Dictionary<T>,
+            iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): T[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder(
+            iteratees: ListIterator<T, any>|string|(ListIterator<T, any>|string)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<W extends Object>(
+            iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<W extends Object, T>(
+            iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<T>(
+            iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<W extends Object, T>(
+            iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<T>(
+            iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<W extends Object, T>(
+            iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<T>(
+            iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder(
+            iteratees: ListIterator<T, any>|string|(ListIterator<T, any>|string)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<W extends Object>(
+            iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<W extends Object, T>(
+            iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<T>(
+            iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<W extends Object, T>(
+            iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<T>(
+            iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<W extends Object, T>(
+            iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortByOrder
+         */
+        sortByOrder<T>(
+            iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[],
+            orders?: boolean|string|(boolean|string)[]
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.where
+    interface LoDashStatic {
+        /**
+        * Performs a deep comparison of each element in a collection to the given properties
+        * object, returning an array of all elements that have equivalent property values.
+        * @param collection The collection to iterate over.
+        * @param properties The object of property values to filter by.
+        * @return A new array of elements that have the given properties.
+        **/
+        where<T, U extends {}>(
+            list: Array<T>,
+            properties: U): T[];
+
+        /**
+        * @see _.where
+        **/
+        where<T, U extends {}>(
+            list: List<T>,
+            properties: U): T[];
+
+        /**
+        * @see _.where
+        **/
+        where<T, U extends {}>(
+            list: Dictionary<T>,
+            properties: U): T[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+        * @see _.where
+        **/
+        where<U extends {}>(properties: U): LoDashImplicitArrayWrapper<T>;
+    }
+
+    /********
+     * Date *
+     ********/
+
+    //_.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.
+         */
+        now(): number;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.now
+         */
+        now(): number;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.now
+         */
+        now(): LoDashExplicitWrapper<number>;
+    }
+
+    /*************
+     * Functions *
+     *************/
+
+    //_.after
+    interface LoDashStatic {
+        /**
+         * The opposite of _.before; this method creates a function that invokes func once it’s called n or more times.
+         *
+         * @param n The number of calls before func is invoked.
+         * @param func The function to restrict.
+         * @return Returns the new restricted function.
+         */
+        after<TFunc extends Function>(
+            n: number,
+            func: TFunc
+        ): TFunc;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+        * @see _.after
+        **/
+        after<TFunc extends Function>(func: TFunc): LoDashImplicitObjectWrapper<TFunc>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.after
+         **/
+        after<TFunc extends Function>(func: TFunc): LoDashExplicitObjectWrapper<TFunc>;
+    }
+
+    //_.ary
+    interface LoDashStatic {
+        /**
+         * Creates a function that accepts up to n arguments ignoring any additional arguments.
+         *
+         * @param func The function to cap arguments for.
+         * @param n The arity cap.
+         * @returns Returns the new function.
+         */
+        ary<TResult extends Function>(
+            func: Function,
+            n?: number
+        ): TResult;
+
+        ary<T extends Function, TResult extends Function>(
+            func: T,
+            n?: number
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.ary
+         */
+        ary<TResult extends Function>(n?: number): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.ary
+         */
+        ary<TResult extends Function>(n?: number): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.backflow
+    interface LoDashStatic {
+        /**
+         * @see _.flowRight
+         */
+        backflow<TResult extends Function>(...funcs: Function[]): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.flowRight
+         */
+        backflow<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.flowRight
+         */
+        backflow<TResult extends Function>(...funcs: Function[]): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.before
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes func, with the this binding and arguments of the created function, while
+         * it’s called less than n times. Subsequent calls to the created function return the result of the last func
+         * invocation.
+         *
+         * @param n The number of calls at which func is no longer invoked.
+         * @param func The function to restrict.
+         * @return Returns the new restricted function.
+         */
+        before<TFunc extends Function>(
+            n: number,
+            func: TFunc
+        ): TFunc;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.before
+         **/
+        before<TFunc extends Function>(func: TFunc): LoDashImplicitObjectWrapper<TFunc>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.before
+         **/
+        before<TFunc extends Function>(func: TFunc): LoDashExplicitObjectWrapper<TFunc>;
+    }
+
+    //_.bind
+    interface FunctionBind {
+        placeholder: any;
+
+        <T extends Function, TResult extends Function>(
+            func: T,
+            thisArg: any,
+            ...partials: any[]
+        ): TResult;
+
+        <TResult extends Function>(
+            func: Function,
+            thisArg: any,
+            ...partials: any[]
+        ): TResult;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes func with the this binding of thisArg and prepends any additional _.bind
+         * arguments to those provided to the bound function.
+         *
+         * The _.bind.placeholder value, which defaults to _ in monolithic builds, may be used as a placeholder for
+         * partially applied arguments.
+         *
+         * Note: Unlike native Function#bind this method does not set the "length" property of bound functions.
+         *
+         * @param func The function to bind.
+         * @param thisArg The this binding of func.
+         * @param partials The arguments to be partially applied.
+         * @return Returns the new bound function.
+         */
+        bind: FunctionBind;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.bind
+         */
+        bind<TResult extends Function>(
+            thisArg: any,
+            ...partials: any[]
+        ): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.bind
+         */
+        bind<TResult extends Function>(
+            thisArg: any,
+            ...partials: any[]
+        ): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.bindAll
+    interface LoDashStatic {
+        /**
+         * Binds methods of an object to the object itself, overwriting the existing method. Method names may be
+         * specified as individual arguments or as arrays of method names. If no method names are provided all
+         * enumerable function properties, own and inherited, of object are bound.
+         *
+         * Note: This method does not set the "length" property of bound functions.
+         *
+         * @param object The object to bind and assign the bound methods to.
+         * @param methodNames The object method names to bind, specified as individual method names or arrays of
+         * method names.
+         * @return Returns object.
+         */
+        bindAll<T>(
+            object: T,
+            ...methodNames: (string|string[])[]
+        ): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.bindAll
+         */
+        bindAll(...methodNames: (string|string[])[]): LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.bindAll
+         */
+        bindAll(...methodNames: (string|string[])[]): LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.bindKey
+    interface FunctionBindKey {
+        placeholder: any;
+
+        <T extends Object, TResult extends Function>(
+            object: T,
+            key: any,
+            ...partials: any[]
+        ): TResult;
+
+        <TResult extends Function>(
+            object: Object,
+            key: any,
+            ...partials: any[]
+        ): TResult;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes the method at object[key] and prepends any additional _.bindKey arguments
+         * to those provided to the bound function.
+         *
+         * This method differs from _.bind by allowing bound functions to reference methods that may be redefined
+         * or don’t yet exist. See Peter Michaux’s article for more details.
+         *
+         * The _.bindKey.placeholder value, which defaults to _ in monolithic builds, may be used as a placeholder
+         * for partially applied arguments.
+         *
+         * @param object The object the method belongs to.
+         * @param key The key of the method.
+         * @param partials The arguments to be partially applied.
+         * @return Returns the new bound function.
+         */
+        bindKey: FunctionBindKey;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.bindKey
+         */
+        bindKey<TResult extends Function>(
+            key: any,
+            ...partials: any[]
+        ): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.bindKey
+         */
+        bindKey<TResult extends Function>(
+            key: any,
+            ...partials: any[]
+        ): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.compose
+    interface LoDashStatic {
+        /**
+         * @see _.flowRight
+         */
+        compose<TResult extends Function>(...funcs: Function[]): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.flowRight
+         */
+        compose<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.flowRight
+         */
+        compose<TResult extends Function>(...funcs: Function[]): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.createCallback
+    interface LoDashStatic {
+        /**
+        * Produces a callback bound to an optional thisArg. If func is a property name the created
+        * callback will return the property value for a given element. If func is an object the created
+        * callback will return true for elements that contain the equivalent object properties,
+        * otherwise it will return false.
+        * @param func The value to convert to a callback.
+        * @param thisArg The this binding of the created callback.
+        * @param argCount The number of arguments the callback accepts.
+        * @return A callback function.
+        **/
+        createCallback(
+            func: string,
+            thisArg?: any,
+            argCount?: number): () => any;
+
+        /**
+        * @see _.createCallback
+        **/
+        createCallback(
+            func: Dictionary<any>,
+            thisArg?: any,
+            argCount?: number): () => boolean;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+        * @see _.createCallback
+        **/
+        createCallback(
+            thisArg?: any,
+            argCount?: number): LoDashImplicitObjectWrapper<() => any>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+        * @see _.createCallback
+        **/
+        createCallback(
+            thisArg?: any,
+            argCount?: number): LoDashImplicitObjectWrapper<() => any>;
+    }
+
+    //_.curry
+    interface LoDashStatic {
+        /**
+         * Creates a function that accepts one or more arguments of func that when called either invokes func returning
+         * its result, if all func arguments have been provided, or returns a function that accepts one or more of the
+         * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
+         * @param func The function to curry.
+         * @return Returns the new curried function.
+         */
+        curry<T1, R>(func: (t1: T1) => R):
+            CurriedFunction1<T1, R>;
+        /**
+         * Creates a function that accepts one or more arguments of func that when called either invokes func returning
+         * its result, if all func arguments have been provided, or returns a function that accepts one or more of the
+         * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
+         * @param func The function to curry.
+         * @return Returns the new curried function.
+         */
+        curry<T1, T2, R>(func: (t1: T1, t2: T2) => R):
+            CurriedFunction2<T1, T2, R>;
+        /**
+         * Creates a function that accepts one or more arguments of func that when called either invokes func returning
+         * its result, if all func arguments have been provided, or returns a function that accepts one or more of the
+         * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
+         * @param func The function to curry.
+         * @return Returns the new curried function.
+         */
+        curry<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R):
+            CurriedFunction3<T1, T2, T3, R>;
+        /**
+         * Creates a function that accepts one or more arguments of func that when called either invokes func returning
+         * its result, if all func arguments have been provided, or returns a function that accepts one or more of the
+         * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
+         * @param func The function to curry.
+         * @return Returns the new curried function.
+         */
+        curry<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R):
+            CurriedFunction4<T1, T2, T3, T4, R>;
+        /**
+         * Creates a function that accepts one or more arguments of func that when called either invokes func returning
+         * its result, if all func arguments have been provided, or returns a function that accepts one or more of the
+         * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
+         * @param func The function to curry.
+         * @return Returns the new curried function.
+         */
+        curry<T1, T2, T3, T4, T5, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R):
+            CurriedFunction5<T1, T2, T3, T4, T5, R>;
+        /**
+         * Creates a function that accepts one or more arguments of func that when called either invokes func returning
+         * its result, if all func arguments have been provided, or returns a function that accepts one or more of the
+         * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
+         * @param func The function to curry.
+         * @param arity The arity of func.
+         * @return Returns the new curried function.
+         */
+        curry<TResult extends Function>(
+          func: Function,
+          arity?: number): TResult;
+    }
+
+    interface CurriedFunction1<T1, R> {
+        (): CurriedFunction1<T1, R>;
+        (t1: T1): R;
+    }
+
+    interface CurriedFunction2<T1, T2, R> {
+        (): CurriedFunction2<T1, T2, R>;
+        (t1: T1): CurriedFunction1<T2, R>;
+        (t1: T1, t2: T2): R;
+    }
+
+    interface CurriedFunction3<T1, T2, T3, R> {
+        (): CurriedFunction3<T1, T2, T3, R>;
+        (t1: T1): CurriedFunction2<T2, T3, R>;
+        (t1: T1, t2: T2): CurriedFunction1<T3, R>;
+        (t1: T1, t2: T2, t3: T3): R;
+    }
+
+    interface CurriedFunction4<T1, T2, T3, T4, R> {
+        (): CurriedFunction4<T1, T2, T3, T4, R>;
+        (t1: T1): CurriedFunction3<T2, T3, T4, R>;
+        (t1: T1, t2: T2): CurriedFunction2<T3, T4, R>;
+        (t1: T1, t2: T2, t3: T3): CurriedFunction1<T4, R>;
+        (t1: T1, t2: T2, t3: T3, t4: T4): R;
+    }
+
+    interface CurriedFunction5<T1, T2, T3, T4, T5, R> {
+        (): CurriedFunction5<T1, T2, T3, T4, T5, R>;
+        (t1: T1): CurriedFunction4<T2, T3, T4, T5, R>;
+        (t1: T1, t2: T2): CurriedFunction3<T3, T4, T5, R>;
+        (t1: T1, t2: T2, t3: T3): CurriedFunction2<T4, T5, R>;
+        (t1: T1, t2: T2, t3: T3, t4: T4): CurriedFunction1<T5, R>;
+        (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+        * @see _.curry
+        **/
+        curry<TResult extends Function>(arity?: number): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    //_.curryRight
+    interface LoDashStatic {
+        /**
+         * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight
+         * instead of _.partial.
+         * @param func The function to curry.
+         * @return Returns the new curried function.
+         */
+        curryRight<T1, R>(func: (t1: T1) => R):
+            CurriedFunction1<T1, R>;
+        /**
+         * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight
+         * instead of _.partial.
+         * @param func The function to curry.
+         * @return Returns the new curried function.
+         */
+        curryRight<T1, T2, R>(func: (t1: T1, t2: T2) => R):
+            CurriedFunction2<T2, T1, R>;
+        /**
+         * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight
+         * instead of _.partial.
+         * @param func The function to curry.
+         * @return Returns the new curried function.
+         */
+        curryRight<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R):
+            CurriedFunction3<T3, T2, T1, R>;
+        /**
+         * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight
+         * instead of _.partial.
+         * @param func The function to curry.
+         * @return Returns the new curried function.
+         */
+        curryRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R):
+            CurriedFunction4<T4, T3, T2, T1, R>;
+        /**
+         * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight
+         * instead of _.partial.
+         * @param func The function to curry.
+         * @return Returns the new curried function.
+         */
+        curryRight<T1, T2, T3, T4, T5, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R):
+            CurriedFunction5<T5, T4, T3, T2, T1, R>;
+        /**
+         * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight
+         * instead of _.partial.
+         * @param func The function to curry.
+         * @param arity The arity of func.
+         * @return Returns the new curried function.
+         */
+        curryRight<TResult extends Function>(
+          func: Function,
+          arity?: number): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.curryRight
+         **/
+        curryRight<TResult extends Function>(arity?: number): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    //_.debounce
+    interface DebounceSettings {
+        /**
+         * Specify invoking on the leading edge of the timeout.
+         */
+        leading?: boolean;
+
+        /**
+         * The maximum time func is allowed to be delayed before it’s invoked.
+         */
+        maxWait?: number;
+
+        /**
+         * Specify invoking on the trailing edge of the timeout.
+         */
+        trailing?: boolean;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since
+         * the last time the debounced function was invoked. The debounced function comes with a cancel method to
+         * cancel delayed invocations. Provide an options object to indicate that func should be invoked on the
+         * leading and/or trailing edge of the wait timeout. Subsequent calls to the debounced function return the
+         * result of the last func invocation.
+         *
+         * Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only
+         * if the the debounced function is invoked more than once during the wait timeout.
+         *
+         * See David Corbacho’s article for details over the differences between _.debounce and _.throttle.
+         *
+         * @param func The function to debounce.
+         * @param wait The number of milliseconds to delay.
+         * @param options The options object.
+         * @param options.leading Specify invoking on the leading edge of the timeout.
+         * @param options.maxWait The maximum time func is allowed to be delayed before it’s invoked.
+         * @param options.trailing Specify invoking on the trailing edge of the timeout.
+         * @return Returns the new debounced function.
+         */
+        debounce<T extends Function>(
+            func: T,
+            wait?: number,
+            options?: DebounceSettings
+        ): T & Cancelable;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.debounce
+         */
+        debounce(
+            wait?: number,
+            options?: DebounceSettings
+        ): LoDashImplicitObjectWrapper<T & Cancelable>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.debounce
+         */
+        debounce(
+            wait?: number,
+            options?: DebounceSettings
+        ): LoDashExplicitObjectWrapper<T & Cancelable>;
+    }
+
+    //_.defer
+    interface LoDashStatic {
+        /**
+         * Defers invoking the func until the current call stack has cleared. Any additional arguments are provided to
+         * func when it’s invoked.
+         *
+         * @param func The function to defer.
+         * @param args The arguments to invoke the function with.
+         * @return Returns the timer id.
+         */
+        defer<T extends Function>(
+            func: T,
+            ...args: any[]
+        ): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.defer
+         */
+        defer(...args: any[]): LoDashImplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.defer
+         */
+        defer(...args: any[]): LoDashExplicitWrapper<number>;
+    }
+
+    //_.delay
+    interface LoDashStatic {
+        /**
+         * Invokes func after wait milliseconds. Any additional arguments are provided to func when it’s invoked.
+         *
+         * @param func The function to delay.
+         * @param wait The number of milliseconds to delay invocation.
+         * @param args The arguments to invoke the function with.
+         * @return Returns the timer id.
+         */
+        delay<T extends Function>(
+            func: T,
+            wait: number,
+            ...args: any[]
+        ): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.delay
+         */
+        delay(
+            wait: number,
+            ...args: any[]
+        ): LoDashImplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.delay
+         */
+        delay(
+            wait: number,
+            ...args: any[]
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    //_.flow
+    interface LoDashStatic {
+        /**
+         * Creates a function that returns the result of invoking the provided functions with the this binding of the
+         * created function, where each successive invocation is supplied the return value of the previous.
+         *
+         * @param funcs Functions to invoke.
+         * @return Returns the new function.
+         */
+        flow<TResult extends Function>(...funcs: Function[]): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.flow
+         */
+        flow<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.flow
+         */
+        flow<TResult extends Function>(...funcs: Function[]): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.flowRight
+    interface LoDashStatic {
+        /**
+         * This method is like _.flow except that it creates a function that invokes the provided functions from right
+         * to left.
+         *
+         * @alias _.backflow, _.compose
+         *
+         * @param funcs Functions to invoke.
+         * @return Returns the new function.
+         */
+        flowRight<TResult extends Function>(...funcs: Function[]): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.flowRight
+         */
+        flowRight<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.flowRight
+         */
+        flowRight<TResult extends Function>(...funcs: Function[]): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+
+    //_.memoize
+    interface MemoizedFunction extends Function {
+        cache: MapCache;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for
+         * storing the result based on the arguments provided to the memoized function. By default, the first argument
+         * provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with
+         * the this binding of the memoized function.
+         * @param func The function to have its output memoized.
+         * @param resolver The function to resolve the cache key.
+         * @return Returns the new memoizing function.
+         */
+        memoize<TResult extends MemoizedFunction>(
+            func: Function,
+            resolver?: Function): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.memoize
+         */
+        memoize<TResult extends MemoizedFunction>(resolver?: Function): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    //_.modArgs
+    interface LoDashStatic {
+        /**
+         * Creates a function that runs each argument through a corresponding transform function.
+         *
+         * @param func The function to wrap.
+         * @param transforms The functions to transform arguments, specified as individual functions or arrays
+         * of functions.
+         * @return Returns the new function.
+         */
+        modArgs<T extends Function, TResult extends Function>(
+            func: T,
+            ...transforms: Function[]
+        ): TResult;
+
+        /**
+         * @see _.modArgs
+         */
+        modArgs<T extends Function, TResult extends Function>(
+            func: T,
+            transforms: Function[]
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.modArgs
+         */
+        modArgs<TResult extends Function>(...transforms: Function[]): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.modArgs
+         */
+        modArgs<TResult extends Function>(transforms: Function[]): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.modArgs
+         */
+        modArgs<TResult extends Function>(...transforms: Function[]): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.modArgs
+         */
+        modArgs<TResult extends Function>(transforms: Function[]): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.negate
+    interface LoDashStatic {
+        /**
+         * Creates a function that negates the result of the predicate func. The func predicate is invoked with
+         * the this binding and arguments of the created function.
+         *
+         * @param predicate The predicate to negate.
+         * @return Returns the new function.
+         */
+        negate<T extends Function>(predicate: T): (...args: any[]) => boolean;
+
+        /**
+         * @see _.negate
+         */
+        negate<T extends Function, TResult extends Function>(predicate: T): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.negate
+         */
+        negate(): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>;
+
+        /**
+         * @see _.negate
+         */
+        negate<TResult extends Function>(): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.negate
+         */
+        negate(): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>;
+
+        /**
+         * @see _.negate
+         */
+        negate<TResult extends Function>(): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.once
+    interface LoDashStatic {
+        /**
+         * Creates a function that is restricted to invoking func once. Repeat calls to the function return the value
+         * of the first call. The func is invoked with the this binding and arguments of the created function.
+         *
+         * @param func The function to restrict.
+         * @return Returns the new restricted function.
+         */
+        once<T extends Function>(func: T): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.once
+         */
+        once(): LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.once
+         */
+        once(): LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.partial
+    interface LoDashStatic {
+        /**
+        * Creates a function that, when called, invokes func with any additional partial arguments
+        * prepended to those provided to the new function. This method is similar to _.bind except
+        * it does not alter the this binding.
+        * @param func The function to partially apply arguments to.
+        * @param args Arguments to be partially applied.
+        * @return The new partially applied function.
+        **/
+        partial: Partial;
+    }
+
+    type PH = LoDashStatic;
+
+    interface Function0<R> {
+        (): R;
+    }
+    interface Function1<T1, R> {
+        (t1: T1): R;
+    }
+    interface Function2<T1, T2, R> {
+        (t1: T1, t2: T2): R;
+    }
+    interface Function3<T1, T2, T3, R> {
+        (t1: T1, t2: T2, t3: T3): R;
+    }
+    interface Function4<T1, T2, T3, T4, R> {
+        (t1: T1, t2: T2, t3: T3, t4: T4): R;
+    }
+
+    interface Partial {
+        // arity 0
+        <R>(func: Function0<R>): Function0<R>;
+        // arity 1
+        <T1, R>(func: Function1<T1, R>): Function1<T1, R>;
+        <T1, R>(func: Function1<T1, R>, arg1: T1): Function0<R>;
+        // arity 2
+        <T1, T2, R>(func: Function2<T1, T2, R>):                      Function2<T1, T2, R>;
+        <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1):            Function1<    T2, R>;
+        <T1, T2, R>(func: Function2<T1, T2, R>, plc1: PH, arg2: T2):  Function1<T1,     R>;
+        <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, arg2: T2):  Function0<        R>;
+        // arity 3
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>):                                Function3<T1, T2, T3, R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1):                      Function2<    T2, T3, R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: PH, arg2: T2):            Function2<T1,     T3, R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2):            Function1<        T3, R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: PH, plc2: PH, arg3: T3):  Function2<T1, T2,     R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: PH, arg3: T3):  Function1<    T2,     R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: PH, arg2: T2, arg3: T3):  Function1<T1,         R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3):  Function0<            R>;
+        // arity 4
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>):                                          Function4<T1, T2, T3, T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1):                                Function3<    T2, T3, T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, arg2: T2):                      Function3<T1,     T3, T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2):                      Function2<        T3, T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, plc2: PH, arg3: T3):            Function3<T1, T2,     T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3):            Function2<    T2,     T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, arg2: T2, arg3: T3):            Function2<T1,         T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3):            Function1<            T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, plc2: PH, plc3: PH, arg4: T4):  Function3<T1, T2, T3,     R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, plc3: PH, arg4: T4):  Function2<    T2, T3,     R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, arg2: T2, plc3: PH, arg4: T4):  Function2<T1,     T3,     R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: PH, arg4: T4):  Function1<        T3,     R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, plc2: PH, arg3: T3, arg4: T4):  Function2<T1, T2,         R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3, arg4: T4):  Function1<    T2,         R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, arg2: T2, arg3: T3, arg4: T4):  Function1<T1,             R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4):  Function0<                R>;
+        // catch-all
+        (func: Function, ...args: any[]): Function;
+    }
+
+    //_.partialRight
+    interface LoDashStatic {
+        /**
+        * This method is like _.partial except that partial arguments are appended to those provided
+        * to the new function.
+        * @param func The function to partially apply arguments to.
+        * @param args Arguments to be partially applied.
+        * @return The new partially applied function.
+        **/
+        partialRight: PartialRight
+    }
+
+    interface PartialRight {
+        // arity 0
+        <R>(func: Function0<R>): Function0<R>;
+        // arity 1
+        <T1, R>(func: Function1<T1, R>): Function1<T1, R>;
+        <T1, R>(func: Function1<T1, R>, arg1: T1): Function0<R>;
+        // arity 2
+        <T1, T2, R>(func: Function2<T1, T2, R>):                      Function2<T1, T2, R>;
+        <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, plc2: PH):  Function1<    T2, R>;
+        <T1, T2, R>(func: Function2<T1, T2, R>,           arg2: T2):  Function1<T1,     R>;
+        <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, arg2: T2):  Function0<        R>;
+        // arity 3
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>):                                Function3<T1, T2, T3, R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: PH, plc3: PH):  Function2<    T2, T3, R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>,           arg2: T2, plc3: PH):  Function2<T1,     T3, R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, plc3: PH):  Function1<        T3, R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>,                     arg3: T3):  Function2<T1, T2,     R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: PH, arg3: T3):  Function1<    T2,     R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>,           arg2: T2, arg3: T3):  Function1<T1,         R>;
+        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3):  Function0<            R>;
+        // arity 4
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>):                                          Function4<T1, T2, T3, T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, plc3: PH, plc4: PH):  Function3<    T2, T3, T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,           arg2: T2, plc3: PH, plc4: PH):  Function3<T1,     T3, T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: PH, plc4: PH):  Function2<        T3, T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,                     arg3: T3, plc4: PH):  Function3<T1, T2,     T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3, plc4: PH):  Function2<    T2,     T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,           arg2: T2, arg3: T3, plc4: PH):  Function2<T1,         T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, plc4: PH):  Function1<            T4, R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,                               arg4: T4):  Function3<T1, T2, T3,     R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, plc3: PH, arg4: T4):  Function2<    T2, T3,     R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,           arg2: T2, plc3: PH, arg4: T4):  Function2<T1,     T3,     R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: PH, arg4: T4):  Function1<        T3,     R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,                     arg3: T3, arg4: T4):  Function2<T1, T2,         R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3, arg4: T4):  Function1<    T2,         R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,           arg2: T2, arg3: T3, arg4: T4):  Function1<T1,             R>;
+        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4):  Function0<                R>;
+        // catch-all
+        (func: Function, ...args: any[]): Function;
+    }
+
+    //_.rearg
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes func with arguments arranged according to the specified indexes where the
+         * argument value at the first index is provided as the first argument, the argument value at the second index
+         * is provided as the second argument, and so on.
+         * @param func The function to rearrange arguments for.
+         * @param indexes The arranged argument indexes, specified as individual indexes or arrays of indexes.
+         * @return Returns the new function.
+         */
+        rearg<TResult extends Function>(func: Function, indexes: number[]): TResult;
+
+        /**
+         * @see _.rearg
+         */
+        rearg<TResult extends Function>(func: Function, ...indexes: number[]): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.rearg
+         */
+        rearg<TResult extends Function>(indexes: number[]): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.rearg
+         */
+        rearg<TResult extends Function>(...indexes: number[]): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    //_.restParam
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes func with the this binding of the created function and arguments from start
+         * and beyond provided as an array.
+         *
+         * Note: This method is based on the rest parameter.
+         *
+         * @param func The function to apply a rest parameter to.
+         * @param start The start position of the rest parameter.
+         * @return Returns the new function.
+         */
+        restParam<TResult extends Function>(
+            func: Function,
+            start?: number
+        ): TResult;
+
+        /**
+         * @see _.restParam
+         */
+        restParam<TResult extends Function, TFunc extends Function>(
+            func: TFunc,
+            start?: number
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.restParam
+         */
+        restParam<TResult extends Function>(start?: number): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.restParam
+         */
+        restParam<TResult extends Function>(start?: number): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.spread
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes func with the this binding of the created function and an array of arguments
+         * much like Function#apply.
+         *
+         * Note: This method is based on the spread operator.
+         *
+         * @param func The function to spread arguments over.
+         * @return Returns the new function.
+         */
+        spread<F extends Function, T extends Function>(func: F): T;
+
+        /**
+         * @see _.spread
+         */
+        spread<T extends Function>(func: Function): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.spread
+         */
+        spread<T extends Function>(): LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.spread
+         */
+        spread<T extends Function>(): LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.throttle
+    interface ThrottleSettings {
+        /**
+         * If you'd like to disable the leading-edge call, pass this as false.
+         */
+        leading?: boolean;
+
+        /**
+         * If you'd like to disable the execution on the trailing-edge, pass false.
+         */
+        trailing?: boolean;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Creates a throttled function that only invokes func at most once per every wait milliseconds. The throttled
+         * function comes with a cancel method to cancel delayed invocations. Provide an options object to indicate
+         * that func should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent calls to
+         * the throttled function return the result of the last func call.
+         *
+         * Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only if
+         * the the throttled function is invoked more than once during the wait timeout.
+         *
+         * @param func The function to throttle.
+         * @param wait The number of milliseconds to throttle invocations to.
+         * @param options The options object.
+         * @param options.leading Specify invoking on the leading edge of the timeout.
+         * @param options.trailing Specify invoking on the trailing edge of the timeout.
+         * @return Returns the new throttled function.
+         */
+        throttle<T extends Function>(
+            func: T,
+            wait?: number,
+            options?: ThrottleSettings
+        ): T & Cancelable;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.throttle
+         */
+        throttle(
+            wait?: number,
+            options?: ThrottleSettings
+        ): LoDashImplicitObjectWrapper<T & Cancelable>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.throttle
+         */
+        throttle(
+            wait?: number,
+            options?: ThrottleSettings
+        ): LoDashExplicitObjectWrapper<T & Cancelable>;
+    }
+
+    //_.wrap
+    interface LoDashStatic {
+        /**
+         * Creates a function that provides value to the wrapper function as its first argument. Any additional
+         * arguments provided to the function are appended to those provided to the wrapper function. The wrapper is
+         * invoked with the this binding of the created function.
+         *
+         * @param value The value to wrap.
+         * @param wrapper The wrapper function.
+         * @return Returns the new function.
+         */
+        wrap<V, W extends Function, R extends Function>(
+            value: V,
+            wrapper: W
+        ): R;
+
+        /**
+         * @see _.wrap
+         */
+        wrap<V, R extends Function>(
+            value: V,
+            wrapper: Function
+        ): R;
+
+        /**
+         * @see _.wrap
+         */
+        wrap<R extends Function>(
+            value: any,
+            wrapper: Function
+        ): R;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.wrap
+         */
+        wrap<W extends Function, R extends Function>(wrapper: W): LoDashImplicitObjectWrapper<R>;
+
+        /**
+         * @see _.wrap
+         */
+        wrap<R extends Function>(wrapper: Function): LoDashImplicitObjectWrapper<R>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.wrap
+         */
+        wrap<W extends Function, R extends Function>(wrapper: W): LoDashImplicitObjectWrapper<R>;
+
+        /**
+         * @see _.wrap
+         */
+        wrap<R extends Function>(wrapper: Function): LoDashImplicitObjectWrapper<R>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.wrap
+         */
+        wrap<W extends Function, R extends Function>(wrapper: W): LoDashImplicitObjectWrapper<R>;
+
+        /**
+         * @see _.wrap
+         */
+        wrap<R extends Function>(wrapper: Function): LoDashImplicitObjectWrapper<R>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.wrap
+         */
+        wrap<W extends Function, R extends Function>(wrapper: W): LoDashExplicitObjectWrapper<R>;
+
+        /**
+         * @see _.wrap
+         */
+        wrap<R extends Function>(wrapper: Function): LoDashExplicitObjectWrapper<R>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.wrap
+         */
+        wrap<W extends Function, R extends Function>(wrapper: W): LoDashExplicitObjectWrapper<R>;
+
+        /**
+         * @see _.wrap
+         */
+        wrap<R extends Function>(wrapper: Function): LoDashExplicitObjectWrapper<R>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.wrap
+         */
+        wrap<W extends Function, R extends Function>(wrapper: W): LoDashExplicitObjectWrapper<R>;
+
+        /**
+         * @see _.wrap
+         */
+        wrap<R extends Function>(wrapper: Function): LoDashExplicitObjectWrapper<R>;
+    }
+
+    /********
+     * Lang *
+     ********/
+
+    //_.clone
+    interface LoDashStatic {
+        /**
+         * Creates a clone of value. If isDeep is true nested objects are cloned, otherwise they are assigned by
+         * reference. If customizer is provided it’s invoked to produce the cloned values. If customizer returns
+         * undefined cloning is handled by the method instead. The customizer is bound to thisArg and invoked with up
+         * to three argument; (value [, index|key, object]).
+         * Note: This method is loosely based on the structured clone algorithm. The enumerable properties of arguments
+         * objects and objects created by constructors other than Object are cloned to plain Object objects. An empty
+         * object is returned for uncloneable values such as functions, DOM nodes, Maps, Sets, and WeakMaps.
+         * @param value The value to clone.
+         * @param isDeep Specify a deep clone.
+         * @param customizer The function to customize cloning values.
+         * @param thisArg The this binding of customizer.
+         * @return Returns the cloned value.
+         */
+        clone<T>(
+            value: T,
+            isDeep?: boolean,
+            customizer?: (value: any) => any,
+            thisArg?: any): T;
+
+        /**
+         * @see _.clone
+         */
+        clone<T>(
+            value: T,
+            customizer?: (value: any) => any,
+            thisArg?: any): T;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.clone
+         */
+        clone(
+            isDeep?: boolean,
+            customizer?: (value: any) => any,
+            thisArg?: any): T;
+
+        /**
+         * @see _.clone
+         */
+        clone(
+            customizer?: (value: any) => any,
+            thisArg?: any): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.clone
+         */
+        clone(
+            isDeep?: boolean,
+            customizer?: (value: any) => any,
+            thisArg?: any): T[];
+
+        /**
+         * @see _.clone
+         */
+        clone(
+            customizer?: (value: any) => any,
+            thisArg?: any): T[];
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.clone
+         */
+        clone(
+            isDeep?: boolean,
+            customizer?: (value: any) => any,
+            thisArg?: any): T;
+
+        /**
+         * @see _.clone
+         */
+        clone(
+            customizer?: (value: any) => any,
+            thisArg?: any): T;
+    }
+
+    //_.cloneDeep
+    interface LoDashStatic {
+        /**
+         * Creates a deep clone of value. If customizer is provided it’s invoked to produce the cloned values. If
+         * customizer returns undefined cloning is handled by the method instead. The customizer is bound to thisArg
+         * and invoked with up to three argument; (value [, index|key, object]).
+         * Note: This method is loosely based on the structured clone algorithm. The enumerable properties of arguments
+         * objects and objects created by constructors other than Object are cloned to plain Object objects. An empty
+         * object is returned for uncloneable values such as functions, DOM nodes, Maps, Sets, and WeakMaps.
+         * @param value The value to deep clone.
+         * @param customizer The function to customize cloning values.
+         * @param thisArg The this binding of customizer.
+         * @return Returns the deep cloned value.
+         */
+        cloneDeep<T>(
+            value: T,
+            customizer?: (value: any) => any,
+            thisArg?: any): T;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.cloneDeep
+         */
+        cloneDeep(
+            customizer?: (value: any) => any,
+            thisArg?: any): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.cloneDeep
+         */
+        cloneDeep(
+            customizer?: (value: any) => any,
+            thisArg?: any): T[];
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.cloneDeep
+         */
+        cloneDeep(
+            customizer?: (value: any) => any,
+            thisArg?: any): T;
+    }
+
+    //_.eq
+    interface LoDashStatic {
+        /**
+         * @see _.isEqual
+         */
+        eq(
+            value: any,
+            other: any,
+            customizer?: IsEqualCustomizer,
+            thisArg?: any
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isEqual
+         */
+        eq(
+            other: any,
+            customizer?: IsEqualCustomizer,
+            thisArg?: any
+        ): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isEqual
+         */
+        eq(
+            other: any,
+            customizer?: IsEqualCustomizer,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.gt
+    interface LoDashStatic {
+        /**
+         * Checks if value is greater than other.
+         *
+         * @param value The value to compare.
+         * @param other The other value to compare.
+         * @return Returns true if value is greater than other, else false.
+         */
+        gt(
+            value: any,
+            other: any
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.gt
+         */
+        gt(other: any): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.gt
+         */
+        gt(other: any): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.gte
+    interface LoDashStatic {
+        /**
+         * Checks if value is greater than or equal to other.
+         *
+         * @param value The value to compare.
+         * @param other The other value to compare.
+         * @return Returns true if value is greater than or equal to other, else false.
+         */
+        gte(
+            value: any,
+            other: any
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.gte
+         */
+        gte(other: any): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.gte
+         */
+        gte(other: any): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isArguments
+    interface LoDashStatic {
+        /**
+         * Checks if value is classified as an arguments object.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is correctly classified, else false.
+         */
+        isArguments(value?: any): value is IArguments;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isArguments
+         */
+        isArguments(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isArguments
+         */
+        isArguments(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isArray
+    interface LoDashStatic {
+        /**
+         * Checks if value is classified as an Array object.
+         * @param value The value to check.
+         *
+         * @return Returns true if value is correctly classified, else false.
+         */
+        isArray<T>(value?: any): value is T[];
+    }
+
+    interface LoDashImplicitWrapperBase<T,TWrapper> {
+        /**
+         * @see _.isArray
+         */
+        isArray(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T,TWrapper> {
+        /**
+         * @see _.isArray
+         */
+        isArray(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isBoolean
+    interface LoDashStatic {
+        /**
+         * Checks if value is classified as a boolean primitive or object.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is correctly classified, else false.
+         */
+        isBoolean(value?: any): value is boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isBoolean
+         */
+        isBoolean(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isBoolean
+         */
+        isBoolean(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isDate
+    interface LoDashStatic {
+        /**
+         * Checks if value is classified as a Date object.
+         * @param value The value to check.
+         *
+         * @return Returns true if value is correctly classified, else false.
+         */
+        isDate(value?: any): value is Date;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isDate
+         */
+        isDate(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isDate
+         */
+        isDate(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isElement
+    interface LoDashStatic {
+        /**
+         * Checks if value is a DOM element.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is a DOM element, else false.
+         */
+        isElement(value?: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isElement
+         */
+        isElement(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isElement
+         */
+        isElement(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isEmpty
+    interface LoDashStatic {
+        /**
+         * Checks if value is empty. A value is considered empty unless it’s an arguments object, array, string, or
+         * jQuery-like collection with a length greater than 0 or an object with own enumerable properties.
+         * @param value The value to inspect.
+         * @return Returns true if value is empty, else false.
+         **/
+        isEmpty(value?: any[]|Dictionary<any>|string|any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T,TWrapper> {
+        /**
+         * @see _.isEmpty
+         */
+        isEmpty(): boolean;
+    }
+
+    //_.isEqual
+    interface IsEqualCustomizer {
+        (value: any, other: any, indexOrKey?: number|string): boolean;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Performs a deep comparison between two values to determine if they are equivalent. If customizer is
+         * provided it’s invoked to compare values. If customizer returns undefined comparisons are handled by the
+         * method instead. The customizer is bound to thisArg and invoked with up to three arguments: (value, other
+         * [, index|key]).
+         *
+         * Note: This method supports comparing arrays, booleans, Date objects, numbers, Object objects, regexes,
+         * and strings. Objects are compared by their own, not inherited, enumerable properties. Functions and DOM
+         * nodes are not supported. Provide a customizer function to extend support for comparing other values.
+         *
+         * @alias _.eq
+         *
+         * @param value The value to compare.
+         * @param other The other value to compare.
+         * @param customizer The function to customize value comparisons.
+         * @param thisArg The this binding of customizer.
+         * @return Returns true if the values are equivalent, else false.
+         */
+        isEqual(
+            value: any,
+            other: any,
+            customizer?: IsEqualCustomizer,
+            thisArg?: any
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isEqual
+         */
+        isEqual(
+            other: any,
+            customizer?: IsEqualCustomizer,
+            thisArg?: any
+        ): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isEqual
+         */
+        isEqual(
+            other: any,
+            customizer?: IsEqualCustomizer,
+            thisArg?: any
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isError
+    interface LoDashStatic {
+        /**
+         * Checks if value is an Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, or URIError
+         * object.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is an error object, else false.
+         */
+        isError(value: any): value is Error;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isError
+         */
+        isError(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isError
+         */
+        isError(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isFinite
+    interface LoDashStatic {
+        /**
+         * Checks if value is a finite primitive number.
+         *
+         * Note: This method is based on Number.isFinite.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is a finite number, else false.
+         */
+        isFinite(value?: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isFinite
+         */
+        isFinite(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isFinite
+         */
+        isFinite(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isFunction
+    interface LoDashStatic {
+        /**
+         * Checks if value is classified as a Function object.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is correctly classified, else false.
+         */
+        isFunction(value?: any): value is Function;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isFunction
+         */
+        isFunction(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isFunction
+         */
+        isFunction(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isMatch
+    interface isMatchCustomizer {
+        (value: any, other: any, indexOrKey?: number|string): boolean;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Performs a deep comparison between object and source to determine if object contains equivalent property
+         * values. If customizer is provided it’s invoked to compare values. If customizer returns undefined
+         * comparisons are handled by the method instead. The customizer is bound to thisArg and invoked with three
+         * arguments: (value, other, index|key).
+         * @param object The object to inspect.
+         * @param source The object of property values to match.
+         * @param customizer The function to customize value comparisons.
+         * @param thisArg The this binding of customizer.
+         * @return Returns true if object is a match, else false.
+         */
+        isMatch(object: Object, source: Object, customizer?: isMatchCustomizer, thisArg?: any): boolean;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.isMatch
+         */
+        isMatch(source: Object, customizer?: isMatchCustomizer, thisArg?: any): boolean;
+    }
+
+    //_.isNaN
+    interface LoDashStatic {
+        /**
+         * Checks if value is NaN.
+         *
+         * Note: This method is not the same as isNaN which returns true for undefined and other non-numeric values.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is NaN, else false.
+         */
+        isNaN(value?: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isNaN
+         */
+        isNaN(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isNaN
+         */
+        isNaN(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isNative
+    interface LoDashStatic {
+        /**
+         * Checks if value is a native function.
+         * @param value The value to check.
+         *
+         * @retrun Returns true if value is a native function, else false.
+         */
+        isNative(value: any): value is Function;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isNative
+         */
+        isNative(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isNative
+         */
+        isNative(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isNull
+    interface LoDashStatic {
+        /**
+         * Checks if value is null.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is null, else false.
+         */
+        isNull(value?: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isNull
+         */
+        isNull(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isNull
+         */
+        isNull(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isNumber
+    interface LoDashStatic {
+        /**
+         * Checks if value is classified as a Number primitive or object.
+         *
+         * Note: To exclude Infinity, -Infinity, and NaN, which are classified as numbers, use the _.isFinite method.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is correctly classified, else false.
+         */
+        isNumber(value?: any): value is number;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isNumber
+         */
+        isNumber(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isNumber
+         */
+        isNumber(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isObject
+    interface LoDashStatic {
+        /**
+         * Checks if value is the language type of Object. (e.g. arrays, functions, objects, regexes, new Number(0),
+         * and new String(''))
+         *
+         * @param value The value to check.
+         * @return Returns true if value is an object, else false.
+         */
+        isObject(value?: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isObject
+         */
+        isObject(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isObject
+         */
+        isObject(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isPlainObject
+    interface LoDashStatic {
+        /**
+         * Checks if value is a plain object, that is, an object created by the Object constructor or one with a
+         * [[Prototype]] of null.
+         *
+         * Note: This method assumes objects created by the Object constructor have no inherited enumerable properties.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is a plain object, else false.
+         */
+        isPlainObject(value?: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isPlainObject
+         */
+        isPlainObject(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isPlainObject
+         */
+        isPlainObject(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isRegExp
+    interface LoDashStatic {
+        /**
+         * Checks if value is classified as a RegExp object.
+         * @param value The value to check.
+         *
+         * @return Returns true if value is correctly classified, else false.
+         */
+        isRegExp(value?: any): value is RegExp;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isRegExp
+         */
+        isRegExp(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isRegExp
+         */
+        isRegExp(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isString
+    interface LoDashStatic {
+        /**
+         * Checks if value is classified as a String primitive or object.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is correctly classified, else false.
+         */
+        isString(value?: any): value is string;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isString
+         */
+        isString(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isString
+         */
+        isString(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isTypedArray
+    interface LoDashStatic {
+        /**
+         * Checks if value is classified as a typed array.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is correctly classified, else false.
+         */
+        isTypedArray(value: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isTypedArray
+         */
+        isTypedArray(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isTypedArray
+         */
+        isTypedArray(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isUndefined
+    interface LoDashStatic {
+        /**
+         * Checks if value is undefined.
+         *
+         * @param value The value to check.
+         * @return Returns true if value is undefined, else false.
+         */
+        isUndefined(value: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isUndefined
+         */
+        isUndefined(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isUndefined
+         */
+        isUndefined(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.lt
+    interface LoDashStatic {
+        /**
+         * Checks if value is less than other.
+         *
+         * @param value The value to compare.
+         * @param other The other value to compare.
+         * @return Returns true if value is less than other, else false.
+         */
+        lt(
+            value: any,
+            other: any
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.lt
+         */
+        lt(other: any): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.lt
+         */
+        lt(other: any): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.lte
+    interface LoDashStatic {
+        /**
+         * Checks if value is less than or equal to other.
+         *
+         * @param value The value to compare.
+         * @param other The other value to compare.
+         * @return Returns true if value is less than or equal to other, else false.
+         */
+        lte(
+            value: any,
+            other: any
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.lte
+         */
+        lte(other: any): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.lte
+         */
+        lte(other: any): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.toArray
+    interface LoDashStatic {
+        /**
+         * Converts value to an array.
+         *
+         * @param value The value to convert.
+         * @return Returns the converted array.
+         */
+        toArray<T>(value: List<T>|Dictionary<T>|NumericDictionary<T>): T[];
+
+        /**
+         * @see _.toArray
+         */
+        toArray<TValue, TResult>(value: TValue): TResult[];
+
+        /**
+         * @see _.toArray
+         */
+        toArray<TResult>(value?: any): TResult[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.toArray
+         */
+        toArray<TResult>(): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.toArray
+         */
+        toArray(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.toArray
+         */
+        toArray<TResult>(): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.toArray
+         */
+        toArray<TResult>(): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.toArray
+         */
+        toArray(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.toArray
+         */
+        toArray<TResult>(): LoDashExplicitArrayWrapper<TResult>;
+    }
+
+    //_.toPlainObject
+    interface LoDashStatic {
+        /**
+         * Converts value to a plain object flattening inherited enumerable properties of value to own properties
+         * of the plain object.
+         *
+         * @param value The value to convert.
+         * @return Returns the converted plain object.
+         */
+        toPlainObject<TResult extends {}>(value?: any): TResult;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.toPlainObject
+         */
+        toPlainObject<TResult extends {}>(): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    /********
+     * Math *
+     ********/
+
+    //_.add
+    interface LoDashStatic {
+        /**
+         * Adds two numbers.
+         *
+         * @param augend The first number to add.
+         * @param addend The second number to add.
+         * @return Returns the sum.
+         */
+        add(
+            augend: number,
+            addend: number
+        ): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.add
+         */
+        add(addend: number): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.add
+         */
+        add(addend: number): LoDashExplicitWrapper<number>;
+    }
+
+    //_.ceil
+    interface LoDashStatic {
+        /**
+         * Calculates n rounded up to precision.
+         *
+         * @param n The number to round up.
+         * @param precision The precision to round up to.
+         * @return Returns the rounded up number.
+         */
+        ceil(
+            n: number,
+            precision?: number
+        ): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.ceil
+         */
+        ceil(precision?: number): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.ceil
+         */
+        ceil(precision?: number): LoDashExplicitWrapper<number>;
+    }
+
+    //_.floor
+    interface LoDashStatic {
+        /**
+         * Calculates n rounded down to precision.
+         *
+         * @param n The number to round down.
+         * @param precision The precision to round down to.
+         * @return Returns the rounded down number.
+         */
+        floor(
+            n: number,
+            precision?: number
+        ): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.floor
+         */
+        floor(precision?: number): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.floor
+         */
+        floor(precision?: number): LoDashExplicitWrapper<number>;
+    }
+
+    //_.max
+    interface LoDashStatic {
+        /**
+         * Gets the maximum value of collection. If collection is empty or falsey -Infinity is returned. If an iteratee
+         * function is provided it’s invoked for each value in collection to generate the criterion by which the value
+         * is ranked. The iteratee is bound to thisArg and invoked with three arguments: (value, index, collection).
+         *
+         * If a property name is provided for iteratee the created _.property style callback returns the property value
+         * of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for iteratee the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param collection The collection to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the maximum value.
+         */
+        max<T>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.max
+         */
+        max<T>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.max
+         */
+        max<T>(
+            collection: List<T>|Dictionary<T>,
+            iteratee?: string,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.max
+         */
+        max<TObject extends {}, T>(
+            collection: List<T>|Dictionary<T>,
+            whereValue?: TObject
+        ): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.max
+         */
+        max(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.max
+         */
+        max(
+            iteratee?: string,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.max
+         */
+        max<TObject extends {}>(
+            whereValue?: TObject
+        ): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.max
+         */
+        max<T>(
+            iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.max
+         */
+        max<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.max
+         */
+        max<TObject extends {}, T>(
+            whereValue?: TObject
+        ): T;
+    }
+
+    //_.min
+    interface LoDashStatic {
+        /**
+         * Gets the minimum value of collection. If collection is empty or falsey Infinity is returned. If an iteratee
+         * function is provided it’s invoked for each value in collection to generate the criterion by which the value
+         * is ranked. The iteratee is bound to thisArg and invoked with three arguments: (value, index, collection).
+         *
+         * If a property name is provided for iteratee the created _.property style callback returns the property value
+         * of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for iteratee the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param collection The collection to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the minimum value.
+         */
+        min<T>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.min
+         */
+        min<T>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.min
+         */
+        min<T>(
+            collection: List<T>|Dictionary<T>,
+            iteratee?: string,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.min
+         */
+        min<TObject extends {}, T>(
+            collection: List<T>|Dictionary<T>,
+            whereValue?: TObject
+        ): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.min
+         */
+        min(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.min
+         */
+        min(
+            iteratee?: string,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.min
+         */
+        min<TObject extends {}>(
+            whereValue?: TObject
+        ): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.min
+         */
+        min<T>(
+            iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.min
+         */
+        min<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): T;
+
+        /**
+         * @see _.min
+         */
+        min<TObject extends {}, T>(
+            whereValue?: TObject
+        ): T;
+    }
+
+    //_.round
+    interface LoDashStatic {
+        /**
+         * Calculates n rounded to precision.
+         *
+         * @param n The number to round.
+         * @param precision The precision to round to.
+         * @return Returns the rounded number.
+         */
+        round(
+            n: number,
+            precision?: number
+        ): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.round
+         */
+        round(precision?: number): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.round
+         */
+        round(precision?: number): LoDashExplicitWrapper<number>;
+    }
+
+    //_.sum
+    interface LoDashStatic {
+        /**
+         * Gets the sum of the values in collection.
+         *
+         * @param collection The collection to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the sum.
+         */
+        sum<T>(
+            collection: List<T>,
+            iteratee: ListIterator<T, number>,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sum
+         **/
+        sum<T>(
+            collection: Dictionary<T>,
+            iteratee: DictionaryIterator<T, number>,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sum
+         */
+        sum<T>(
+            collection: List<number>|Dictionary<number>,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sum
+         */
+        sum<T>(collection: List<T>|Dictionary<T>): number;
+
+        /**
+         * @see _.sum
+         */
+        sum(collection: List<number>|Dictionary<number>): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.sum
+         */
+        sum(
+            iteratee: ListIterator<T, number>,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sum
+         */
+        sum(iteratee: string): number;
+
+        /**
+         * @see _.sum
+         */
+        sum(): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.sum
+         **/
+        sum<TValue>(
+            iteratee: ListIterator<TValue, number>|DictionaryIterator<TValue, number>,
+            thisArg?: any
+        ): number;
+
+        /**
+         * @see _.sum
+         */
+        sum(iteratee: string): number;
+
+        /**
+         * @see _.sum
+         */
+        sum(): number;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.sum
+         */
+        sum(
+            iteratee: ListIterator<T, number>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sum
+         */
+        sum(iteratee: string): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sum
+         */
+        sum(): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.sum
+         */
+        sum<TValue>(
+            iteratee: ListIterator<TValue, number>|DictionaryIterator<TValue, number>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sum
+         */
+        sum(iteratee: string): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sum
+         */
+        sum(): LoDashExplicitWrapper<number>;
+    }
+
+    /**********
+     * Number *
+     **********/
+
+    //_.inRange
+    interface LoDashStatic {
+        /**
+         * Checks if n is between start and up to but not including, end. If end is not specified it’s set to start
+         * with start then set to 0.
+         *
+         * @param n The number to check.
+         * @param start The start of the range.
+         * @param end The end of the range.
+         * @return Returns true if n is in the range, else false.
+         */
+        inRange(
+            n: number,
+            start: number,
+            end: number
+        ): boolean;
+
+
+        /**
+         * @see _.inRange
+         */
+        inRange(
+            n: number,
+            end: number
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.inRange
+         */
+        inRange(
+            start: number,
+            end: number
+        ): boolean;
+
+        /**
+         * @see _.inRange
+         */
+        inRange(end: number): boolean;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.inRange
+         */
+        inRange(
+            start: number,
+            end: number
+        ): LoDashExplicitWrapper<boolean>;
+
+        /**
+         * @see _.inRange
+         */
+        inRange(end: number): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.random
+    interface LoDashStatic {
+        /**
+         * Produces a random number between min and max (inclusive). If only one argument is provided a number between
+         * 0 and the given number is returned. If floating is true, or either min or max are floats, a floating-point
+         * number is returned instead of an integer.
+         *
+         * @param min The minimum possible value.
+         * @param max The maximum possible value.
+         * @param floating Specify returning a floating-point number.
+         * @return Returns the random number.
+         */
+        random(
+            min?: number,
+            max?: number,
+            floating?: boolean
+        ): number;
+
+        /**
+         * @see _.random
+         */
+        random(
+            min?: number,
+            floating?: boolean
+        ): number;
+
+        /**
+         * @see _.random
+         */
+        random(floating?: boolean): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.random
+         */
+        random(
+            max?: number,
+            floating?: boolean
+        ): number;
+
+        /**
+         * @see _.random
+         */
+        random(floating?: boolean): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.random
+         */
+        random(
+            max?: number,
+            floating?: boolean
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.random
+         */
+        random(floating?: boolean): LoDashExplicitWrapper<number>;
+    }
+
+    /**********
+     * Object *
+     **********/
+
+    //_.assign
+    interface AssignCustomizer {
+        (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}): any;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Assigns own enumerable properties of source object(s) to the destination object. Subsequent sources
+         * overwrite property assignments of previous sources. If customizer is provided it’s invoked to produce the
+         * assigned values. The customizer is bound to thisArg and invoked with five arguments:
+         * (objectValue, sourceValue, key, object, source).
+         *
+         * Note: This method mutates object and is based on Object.assign.
+         *
+         * @alias _.extend
+         *
+         * @param object The destination object.
+         * @param source The source objects.
+         * @param customizer The function to customize assigned values.
+         * @param thisArg The this binding of callback.
+         * @return The destination object.
+         */
+        assign<TObject extends {}, TSource extends {}, TResult extends {}>(
+            object: TObject,
+            source: TSource,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see assign
+         */
+        assign<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see assign
+         */
+        assign<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see assign
+         */
+        assign<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {},
+            TResult extends {}>
+        (
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see _.assign
+         */
+        assign<TObject extends {}>(object: TObject): TObject;
+
+        /**
+         * @see _.assign
+         */
+        assign<TObject extends {}, TResult extends {}>(
+            object: TObject, ...otherArgs: any[]
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.assign
+         */
+        assign<TSource extends {}, TResult extends {}>(
+            source: TSource,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assign
+         */
+        assign<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assign
+         */
+        assign<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assign
+         */
+        assign<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.assign
+         */
+        assign(): LoDashImplicitObjectWrapper<T>;
+
+        /**
+         * @see _.assign
+         */
+        assign<TResult extends {}>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.assign
+         */
+        assign<TSource extends {}, TResult extends {}>(
+            source: TSource,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assign
+         */
+        assign<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assign
+         */
+        assign<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assign
+         */
+        assign<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.assign
+         */
+        assign(): LoDashExplicitObjectWrapper<T>;
+
+        /**
+         * @see _.assign
+         */
+        assign<TResult extends {}>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.create
+    interface LoDashStatic {
+        /**
+         * Creates an object that inherits from the given prototype object. If a properties object is provided its own
+         * enumerable properties are assigned to the created object.
+         *
+         * @param prototype The object to inherit from.
+         * @param properties The properties to assign to the object.
+         * @return Returns the new object.
+         */
+        create<T extends Object, U extends Object>(
+            prototype: T,
+            properties?: U
+        ): T & U;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.create
+         */
+        create<U extends Object>(properties?: U): LoDashImplicitObjectWrapper<T & U>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.create
+         */
+        create<U extends Object>(properties?: U): LoDashExplicitObjectWrapper<T & U>;
+    }
+
+    //_.defaults
+    interface LoDashStatic {
+        /**
+         * Assigns own enumerable properties of source object(s) to the destination object for all destination
+         * properties that resolve to undefined. Once a property is set, additional values of the same property are
+         * ignored.
+         *
+         * Note: This method mutates object.
+         *
+         * @param object The destination object.
+         * @param sources The source objects.
+         * @return The destination object.
+         */
+        defaults<Obj extends {}, TResult extends {}>(
+            object: Obj,
+            ...sources: {}[]
+        ): TResult;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<Obj extends {}, S1 extends {}, TResult extends {}>(
+            object: Obj,
+            source1: S1,
+            ...sources: {}[]
+        ): TResult;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<Obj extends {}, S1 extends {}, S2 extends {}, TResult extends {}>(
+            object: Obj,
+            source1: S1,
+            source2: S2,
+            ...sources: {}[]
+        ): TResult;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<Obj extends {}, S1 extends {}, S2 extends {}, S3 extends {}, TResult extends {}>(
+            object: Obj,
+            source1: S1,
+            source2: S2,
+            source3: S3,
+            ...sources: {}[]
+        ): TResult;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<Obj extends {}, S1 extends {}, S2 extends {}, S3 extends {}, S4 extends {}, TResult extends {}>(
+            object: Obj,
+            source1: S1,
+            source2: S2,
+            source3: S3,
+            source4: S4,
+            ...sources: {}[]
+        ): TResult;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<TResult extends {}>(
+            object: {},
+            ...sources: {}[]
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.defaults
+         */
+        defaults<S1 extends {}, TResult extends {}>(
+            source1: S1,
+            ...sources: {}[]
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<S1 extends {}, S2 extends {}, TResult extends {}>(
+            source1: S1,
+            source2: S2,
+            ...sources: {}[]
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<S1 extends {}, S2 extends {}, S3 extends {}, TResult extends {}>(
+            source1: S1,
+            source2: S2,
+            source3: S3,
+            ...sources: {}[]
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<S1 extends {}, S2 extends {}, S3 extends {}, S4 extends {}, TResult extends {}>(
+            source1: S1,
+            source2: S2,
+            source3: S3,
+            source4: S4,
+            ...sources: {}[]
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.defaults
+         */
+        defaults(): LoDashImplicitObjectWrapper<T>;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<TResult>(...sources: {}[]): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.defaults
+         */
+        defaults<S1 extends {}, TResult extends {}>(
+            source1: S1,
+            ...sources: {}[]
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<S1 extends {}, S2 extends {}, TResult extends {}>(
+            source1: S1,
+            source2: S2,
+            ...sources: {}[]
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<S1 extends {}, S2 extends {}, S3 extends {}, TResult extends {}>(
+            source1: S1,
+            source2: S2,
+            source3: S3,
+            ...sources: {}[]
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<S1 extends {}, S2 extends {}, S3 extends {}, S4 extends {}, TResult extends {}>(
+            source1: S1,
+            source2: S2,
+            source3: S3,
+            source4: S4,
+            ...sources: {}[]
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.defaults
+         */
+        defaults(): LoDashExplicitObjectWrapper<T>;
+
+        /**
+         * @see _.defaults
+         */
+        defaults<TResult>(...sources: {}[]): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.defaultsDeep
+    interface LoDashStatic {
+        /**
+         * This method is like _.defaults except that it recursively assigns default properties.
+         * @param object The destination object.
+         * @param sources The source objects.
+         * @return Returns object.
+         **/
+        defaultsDeep<T, TResult>(
+            object: T,
+            ...sources: any[]): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.defaultsDeep
+         **/
+        defaultsDeep<TResult>(...sources: any[]): LoDashImplicitObjectWrapper<TResult>
+    }
+
+    //_.extend
+    interface LoDashStatic {
+        /**
+         * @see assign
+         */
+        extend<TObject extends {}, TSource extends {}, TResult extends {}>(
+            object: TObject,
+            source: TSource,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see assign
+         */
+        extend<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see assign
+         */
+        extend<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see assign
+         */
+        extend<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {},
+            TResult extends {}>
+            (
+                object: TObject,
+                source1: TSource1,
+                source2: TSource2,
+                source3: TSource3,
+                source4: TSource4,
+                customizer?: AssignCustomizer,
+                thisArg?: any
+            ): TResult;
+
+        /**
+         * @see _.assign
+         */
+        extend<TObject extends {}>(object: TObject): TObject;
+
+        /**
+         * @see _.assign
+         */
+        extend<TObject extends {}, TResult extends {}>(
+            object: TObject, ...otherArgs: any[]
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.assign
+         */
+        extend<TSource extends {}, TResult extends {}>(
+            source: TSource,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assign
+         */
+        extend<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assign
+         */
+        extend<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assign
+         */
+        extend<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.assign
+         */
+        extend(): LoDashImplicitObjectWrapper<T>;
+
+        /**
+         * @see _.assign
+         */
+        extend<TResult extends {}>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.assign
+         */
+        extend<TSource extends {}, TResult extends {}>(
+            source: TSource,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assign
+         */
+        extend<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assign
+         */
+        extend<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assign
+         */
+        extend<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer?: AssignCustomizer,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.assign
+         */
+        extend(): LoDashExplicitObjectWrapper<T>;
+
+        /**
+         * @see _.assign
+         */
+        extend<TResult extends {}>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.findKey
+    interface LoDashStatic {
+        /**
+         * This method is like _.find except that it returns the key of the first element predicate returns truthy for
+         * instead of the element itself.
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param object The object to search.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the key of the matched element, else undefined.
+         */
+        findKey<TValues, TObject>(
+            object: TObject,
+            predicate?: DictionaryIterator<TValues, boolean>,
+            thisArg?: any
+        ): string;
+
+        /**
+         * @see _.findKey
+         */
+        findKey<TObject>(
+            object: TObject,
+            predicate?: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): string;
+
+        /**
+         * @see _.findKey
+         */
+        findKey<TObject>(
+            object: TObject,
+            predicate?: string,
+            thisArg?: any
+        ): string;
+
+        /**
+         * @see _.findKey
+         */
+        findKey<TWhere extends Dictionary<any>, TObject>(
+            object: TObject,
+            predicate?: TWhere
+        ): string;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.findKey
+         */
+        findKey<TValues>(
+            predicate?: DictionaryIterator<TValues, boolean>,
+            thisArg?: any
+        ): string;
+
+        /**
+         * @see _.findKey
+         */
+        findKey(
+            predicate?: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): string;
+
+        /**
+         * @see _.findKey
+         */
+        findKey(
+            predicate?: string,
+            thisArg?: any
+        ): string;
+
+        /**
+         * @see _.findKey
+         */
+        findKey<TWhere extends Dictionary<any>>(
+            predicate?: TWhere
+        ): string;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.findKey
+         */
+        findKey<TValues>(
+            predicate?: DictionaryIterator<TValues, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<string>;
+
+        /**
+         * @see _.findKey
+         */
+        findKey(
+            predicate?: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<string>;
+
+        /**
+         * @see _.findKey
+         */
+        findKey(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<string>;
+
+        /**
+         * @see _.findKey
+         */
+        findKey<TWhere extends Dictionary<any>>(
+            predicate?: TWhere
+        ): LoDashExplicitWrapper<string>;
+    }
+
+    //_.findLastKey
+    interface LoDashStatic {
+        /**
+         * This method is like _.findKey except that it iterates over elements of a collection in the opposite order.
+         *
+         * If a property name is provided for predicate the created _.property style callback returns the property
+         * value of the given element.
+         *
+         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+         * elements that have a matching property value, else false.
+         *
+         * If an object is provided for predicate the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @param object The object to search.
+         * @param predicate The function invoked per iteration.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the key of the matched element, else undefined.
+         */
+        findLastKey<TValues, TObject>(
+            object: TObject,
+            predicate?: DictionaryIterator<TValues, boolean>,
+            thisArg?: any
+        ): string;
+
+        /**
+         * @see _.findLastKey
+         */
+        findLastKey<TObject>(
+            object: TObject,
+            predicate?: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): string;
+
+        /**
+         * @see _.findLastKey
+         */
+        findLastKey<TObject>(
+            object: TObject,
+            predicate?: string,
+            thisArg?: any
+        ): string;
+
+        /**
+         * @see _.findLastKey
+         */
+        findLastKey<TWhere extends Dictionary<any>, TObject>(
+            object: TObject,
+            predicate?: TWhere
+        ): string;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.findLastKey
+         */
+        findLastKey<TValues>(
+            predicate?: DictionaryIterator<TValues, boolean>,
+            thisArg?: any
+        ): string;
+
+        /**
+         * @see _.findLastKey
+         */
+        findLastKey(
+            predicate?: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): string;
+
+        /**
+         * @see _.findLastKey
+         */
+        findLastKey(
+            predicate?: string,
+            thisArg?: any
+        ): string;
+
+        /**
+         * @see _.findLastKey
+         */
+        findLastKey<TWhere extends Dictionary<any>>(
+            predicate?: TWhere
+        ): string;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.findLastKey
+         */
+        findLastKey<TValues>(
+            predicate?: DictionaryIterator<TValues, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<string>;
+
+        /**
+         * @see _.findLastKey
+         */
+        findLastKey(
+            predicate?: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): LoDashExplicitWrapper<string>;
+
+        /**
+         * @see _.findLastKey
+         */
+        findLastKey(
+            predicate?: string,
+            thisArg?: any
+        ): LoDashExplicitWrapper<string>;
+
+        /**
+         * @see _.findLastKey
+         */
+        findLastKey<TWhere extends Dictionary<any>>(
+            predicate?: TWhere
+        ): LoDashExplicitWrapper<string>;
+    }
+
+    //_.forIn
+    interface LoDashStatic {
+        /**
+         * Iterates over own and inherited enumerable properties of an object invoking iteratee for each property. The
+         * iteratee is bound to thisArg and invoked with three arguments: (value, key, object). Iteratee functions may
+         * exit iteration early by explicitly returning false.
+         *
+         * @param object The object to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns object.
+         */
+        forIn<T>(
+            object: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.forIn
+         */
+        forIn<T extends {}>(
+            object: T,
+            iteratee?: ObjectIterator<any, any>,
+            thisArg?: any
+        ): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.forIn
+         */
+        forIn<TValue>(
+            iteratee?: DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): _.LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.forIn
+         */
+        forIn<TValue>(
+            iteratee?: DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): _.LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.forInRight
+    interface LoDashStatic {
+        /**
+         * This method is like _.forIn except that it iterates over properties of object in the opposite order.
+         *
+         * @param object The object to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns object.
+         */
+        forInRight<T>(
+            object: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.forInRight
+         */
+        forInRight<T extends {}>(
+            object: T,
+            iteratee?: ObjectIterator<any, any>,
+            thisArg?: any
+        ): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.forInRight
+         */
+        forInRight<TValue>(
+            iteratee?: DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): _.LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.forInRight
+         */
+        forInRight<TValue>(
+            iteratee?: DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): _.LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.forOwn
+    interface LoDashStatic {
+        /**
+         * Iterates over own enumerable properties of an object invoking iteratee for each property. The iteratee is
+         * bound to thisArg and invoked with three arguments: (value, key, object). Iteratee functions may exit
+         * iteration early by explicitly returning false.
+         *
+         * @param object The object to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns object.
+         */
+        forOwn<T>(
+            object: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.forOwn
+         */
+        forOwn<T extends {}>(
+            object: T,
+            iteratee?: ObjectIterator<any, any>,
+            thisArg?: any
+        ): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.forOwn
+         */
+        forOwn<TValue>(
+            iteratee?: DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): _.LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.forOwn
+         */
+        forOwn<TValue>(
+            iteratee?: DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): _.LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.forOwnRight
+    interface LoDashStatic {
+        /**
+         * This method is like _.forOwn except that it iterates over properties of object in the opposite order.
+         *
+         * @param object The object to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns object.
+         */
+        forOwnRight<T>(
+            object: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.forOwnRight
+         */
+        forOwnRight<T extends {}>(
+            object: T,
+            iteratee?: ObjectIterator<any, any>,
+            thisArg?: any
+        ): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.forOwnRight
+         */
+        forOwnRight<TValue>(
+            iteratee?: DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): _.LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.forOwnRight
+         */
+        forOwnRight<TValue>(
+            iteratee?: DictionaryIterator<TValue, any>,
+            thisArg?: any
+        ): _.LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.functions
+    interface LoDashStatic {
+        /**
+         * Creates an array of function property names from all enumerable properties, own and inherited, of object.
+         *
+         * @alias _.methods
+         *
+         * @param object The object to inspect.
+         * @return Returns the new array of property names.
+         */
+        functions<T extends {}>(object: any): string[];
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.functions
+         */
+        functions(): _.LoDashImplicitArrayWrapper<string>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.functions
+         */
+        functions(): _.LoDashExplicitArrayWrapper<string>;
+    }
+
+    //_.get
+    interface LoDashStatic {
+        /**
+         * Gets the property value at path of object. If the resolved
+         * value is undefined the defaultValue is used in its place.
+         * @param object The object to query.
+         * @param path The path of the property to get.
+         * @param defaultValue The value returned if the resolved value is undefined.
+         * @return Returns the resolved value.
+         **/
+        get<TResult>(object: Object,
+               path: string|number|boolean|Array<string|number|boolean>,
+               defaultValue?:TResult
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.get
+         **/
+        get<TResult>(path: string|number|boolean|Array<string|number|boolean>,
+                     defaultValue?: TResult
+        ): TResult;
+    }
+
+    //_.has
+    interface LoDashStatic {
+        /**
+         * Checks if path is a direct property.
+         *
+         * @param object The object to query.
+         * @param path The path to check.
+         * @return Returns true if path is a direct property, else false.
+         */
+        has<T extends {}>(
+            object: T,
+            path: StringRepresentable|StringRepresentable[]
+        ): boolean;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.has
+         */
+        has(path: StringRepresentable|StringRepresentable[]): boolean;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.has
+         */
+        has(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.invert
+    interface LoDashStatic {
+        /**
+         * Creates an object composed of the inverted keys and values of object. If object contains duplicate values,
+         * subsequent values overwrite property assignments of previous values unless multiValue is true.
+         *
+         * @param object The object to invert.
+         * @param multiValue Allow multiple values per key.
+         * @return Returns the new inverted object.
+         */
+        invert<T extends {}, TResult extends {}>(
+            object: T,
+            multiValue?: boolean
+        ): TResult;
+
+        /**
+         * @see _.invert
+         */
+        invert<TResult extends {}>(
+            object: Object,
+            multiValue?: boolean
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.invert
+         */
+        invert<TResult extends {}>(multiValue?: boolean): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.invert
+         */
+        invert<TResult extends {}>(multiValue?: boolean): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.keys
+    interface LoDashStatic {
+        /**
+         * Creates an array of the own enumerable property names of object.
+         *
+         * Note: Non-object values are coerced to objects. See the ES spec for more details.
+         *
+         * @param object The object to query.
+         * @return Returns the array of property names.
+         */
+        keys(object?: any): string[];
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.keys
+         */
+        keys(): LoDashImplicitArrayWrapper<string>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.keys
+         */
+        keys(): LoDashExplicitArrayWrapper<string>;
+    }
+
+    //_.keysIn
+    interface LoDashStatic {
+        /**
+         * Creates an array of the own and inherited enumerable property names of object.
+         *
+         * Note: Non-object values are coerced to objects.
+         *
+         * @param object The object to query.
+         * @return An array of property names.
+         */
+        keysIn(object?: any): string[];
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.keysIn
+         */
+        keysIn(): LoDashImplicitArrayWrapper<string>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.keysIn
+         */
+        keysIn(): LoDashExplicitArrayWrapper<string>;
+    }
+
+    //_.mapKeys
+    interface LoDashStatic {
+        /**
+         * The opposite of _.mapValues; this method creates an object with the same values as object and keys generated
+         * by running each own enumerable property of object through iteratee.
+         *
+         * @param object The object to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the new mapped object.
+         */
+        mapKeys<T, TKey>(
+            object: List<T>,
+            iteratee?: ListIterator<T, TKey>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<T, TKey>(
+            object: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, TKey>,
+            thisArg?: any
+        ): Dictionary<T>;
+
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<T, TObject extends {}>(
+            object: List<T>|Dictionary<T>,
+            iteratee?: TObject
+        ): Dictionary<T>;
+
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<T>(
+            object: List<T>|Dictionary<T>,
+            iteratee?: string,
+            thisArg?: any
+        ): Dictionary<T>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<TKey>(
+            iteratee?: ListIterator<T, TKey>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<TObject extends {}>(
+            iteratee?: TObject
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<TResult, TKey>(
+            iteratee?: ListIterator<TResult, TKey>|DictionaryIterator<TResult, TKey>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
+
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<TResult, TObject extends {}>(
+            iteratee?: TObject
+        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
+
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<TResult>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<TKey>(
+            iteratee?: ListIterator<T, TKey>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<TObject extends {}>(
+            iteratee?: TObject
+        ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<TResult, TKey>(
+            iteratee?: ListIterator<TResult, TKey>|DictionaryIterator<TResult, TKey>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<TResult>>;
+
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<TResult, TObject extends {}>(
+            iteratee?: TObject
+        ): LoDashExplicitObjectWrapper<Dictionary<TResult>>;
+
+        /**
+         * @see _.mapKeys
+         */
+        mapKeys<TResult>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<Dictionary<TResult>>;
+    }
+
+    //_.mapValues
+    interface LoDashStatic {
+        /**
+        * Creates an object with the same keys as object and values generated by running each own
+        * enumerable property of object through iteratee. The iteratee function is bound to thisArg
+        * and invoked with three arguments: (value, key, object).
+        *
+        * If a property name is provided iteratee the created "_.property" style callback returns
+        * the property value of the given element.
+        *
+        * If a value is also provided for thisArg the creted "_.matchesProperty" style callback returns
+        * true for elements that have a matching property value, else false;.
+        *
+        * If an object is provided for iteratee the created "_.matches" style callback returns true
+        * for elements that have the properties of the given object, else false.
+        *
+        * @param {Object} object The object to iterate over.
+        * @param {Function|Object|string} [iteratee=_.identity]  The function invoked per iteration.
+        * @param {Object} [thisArg] The `this` binding of `iteratee`.
+        * @return {Object} Returns the new mapped object.
+        */
+        mapValues<T, TResult>(obj: Dictionary<T>, callback: ObjectIterator<T, TResult>, thisArg?: any): Dictionary<TResult>;
+        mapValues<T>(obj: Dictionary<T>, where: Dictionary<T>): Dictionary<boolean>;
+        mapValues<T, TMapped>(obj: T, pluck: string): TMapped;
+        mapValues<T>(obj: T, callback: ObjectIterator<any, any>, thisArg?: any): 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): 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): 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>): 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>): LoDashImplicitArrayWrapper<boolean>;
+    }
+
+    //_.merge
+    interface MergeCustomizer {
+        (value: any, srcValue: any, key?: string, object?: Object, source?: Object): any;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Recursively merges own enumerable properties of the source object(s), that don’t resolve to undefined into
+         * the destination object. Subsequent sources overwrite property assignments of previous sources. If customizer
+         * is provided it’s invoked to produce the merged values of the destination and source properties. If
+         * customizer returns undefined merging is handled by the method instead. The customizer is bound to thisArg
+         * and invoked with five arguments: (objectValue, sourceValue, key, object, source).
+         *
+         * @param object The destination object.
+         * @param source The source objects.
+         * @param customizer The function to customize assigned values.
+         * @param thisArg The this binding of customizer.
+         * @return Returns object.
+         */
+        merge<TObject, TSource>(
+            object: TObject,
+            source: TSource,
+            customizer?: MergeCustomizer,
+            thisArg?: any
+        ): TObject & TSource;
+
+        /**
+         * @see _.merge
+         */
+        merge<TObject, TSource1, TSource2>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            customizer?: MergeCustomizer,
+            thisArg?: any
+        ): TObject & TSource1 & TSource2;
+
+        /**
+         * @see _.merge
+         */
+        merge<TObject, TSource1, TSource2, TSource3>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer?: MergeCustomizer,
+            thisArg?: any
+        ): TObject & TSource1 & TSource2 & TSource3;
+
+        /**
+         * @see _.merge
+         */
+        merge<TObject, TSource1, TSource2, TSource3, TSource4>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer?: MergeCustomizer,
+            thisArg?: any
+        ): TObject & TSource1 & TSource2 & TSource3 & TSource4;
+
+        /**
+         * @see _.merge
+         */
+        merge<TResult>(
+            object: any,
+            ...otherArgs: any[]
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.merge
+         */
+        merge<TSource>(
+            source: TSource,
+            customizer?: MergeCustomizer,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<T & TSource>;
+
+        /**
+         * @see _.merge
+         */
+        merge<TSource1, TSource2>(
+            source1: TSource1,
+            source2: TSource2,
+            customizer?: MergeCustomizer,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;
+
+        /**
+         * @see _.merge
+         */
+        merge<TSource1, TSource2, TSource3>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer?: MergeCustomizer,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+        /**
+         * @see _.merge
+         */
+        merge<TSource1, TSource2, TSource3, TSource4>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer?: MergeCustomizer,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+        /**
+         * @see _.merge
+         */
+        merge<TResult>(
+            ...otherArgs: any[]
+        ): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    //_.methods
+    interface LoDashStatic {
+        /**
+         * @see _.functions
+         */
+        methods<T extends {}>(object: any): string[];
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.functions
+         */
+        methods(): _.LoDashImplicitArrayWrapper<string>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.functions
+         */
+        methods(): _.LoDashExplicitArrayWrapper<string>;
+    }
+
+    //_.omit
+    interface LoDashStatic {
+        /**
+         * The opposite of _.pick; this method creates an object composed of the own and inherited enumerable
+         * properties of object that are not omitted.
+         *
+         * @param object The source object.
+         * @param predicate The function invoked per iteration or property names to omit, specified as individual
+         * property names or arrays of property names.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the new object.
+         */
+        omit<TResult extends {}, T extends {}>(
+            object: T,
+            predicate: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see _.omit
+         */
+        omit<TResult extends {}, T extends {}>(
+            object: T,
+            ...predicate: (StringRepresentable|StringRepresentable[])[]
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.omit
+         */
+        omit<TResult extends {}>(
+            predicate: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.omit
+         */
+        omit<TResult extends {}>(
+            ...predicate: (StringRepresentable|StringRepresentable[])[]
+        ): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.omit
+         */
+        omit<TResult extends {}>(
+            predicate: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.omit
+         */
+        omit<TResult extends {}>(
+            ...predicate: (StringRepresentable|StringRepresentable[])[]
+        ): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.pairs
+    interface LoDashStatic {
+        /**
+         * Creates a two dimensional array of the key-value pairs for object, e.g. [[key1, value1], [key2, value2]].
+         *
+         * @param object The object to query.
+         * @return Returns the new array of key-value pairs.
+         */
+        pairs<T extends {}>(object?: T): any[][];
+
+        pairs<T extends {}, TResult>(object?: T): TResult[][];
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.pairs
+         */
+        pairs<TResult>(): LoDashImplicitArrayWrapper<TResult[]>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.pairs
+         */
+        pairs<TResult>(): LoDashExplicitArrayWrapper<TResult[]>;
+    }
+
+    //_.pick
+    interface LoDashStatic {
+        /**
+         * Creates an object composed of the picked object properties. Property names may be specified as individual
+         * arguments or as arrays of property names. If predicate is provided it’s invoked for each property of object
+         * picking the properties predicate returns truthy for. The predicate is bound to thisArg and invoked with
+         * three arguments: (value, key, object).
+         *
+         * @param object The source object.
+         * @param predicate The function invoked per iteration or property names to pick, specified as individual
+         * property names or arrays of property names.
+         * @param thisArg The this binding of predicate.
+         * @return Returns the new object.
+         */
+        pick<TResult extends {}, T extends {}>(
+            object: T,
+            predicate: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): TResult;
+
+        /**
+         * @see _.pick
+         */
+        pick<TResult extends {}, T extends {}>(
+            object: T,
+            ...predicate: (StringRepresentable|StringRepresentable[])[]
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.pick
+         */
+        pick<TResult extends {}>(
+            predicate: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.pick
+         */
+        pick<TResult extends {}>(
+            ...predicate: (StringRepresentable|StringRepresentable[])[]
+        ): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.pick
+         */
+        pick<TResult extends {}>(
+            predicate: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.pick
+         */
+        pick<TResult extends {}>(
+            ...predicate: (StringRepresentable|StringRepresentable[])[]
+        ): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.result
+    interface LoDashStatic {
+        /**
+         * This method is like _.get except that if the resolved value is a function it’s invoked with the this binding
+         * of its parent object and its result is returned.
+         *
+         * @param object The object to query.
+         * @param path The path of the property to resolve.
+         * @param defaultValue The value returned if the resolved value is undefined.
+         * @return Returns the resolved value.
+         */
+        result<TObject, TResult>(
+            object: TObject,
+            path: number|string|boolean|Array<number|string|boolean>,
+            defaultValue?: TResult
+        ): TResult;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.result
+         */
+        result<TResult>(
+            path: number|string|boolean|Array<number|string|boolean>,
+            defaultValue?: TResult
+        ): TResult;
+    }
+
+    //_.set
+    interface LoDashStatic {
+        /**
+         * Sets the property value of path on object. If a portion of path does not exist it’s created.
+         *
+         * @param object The object to augment.
+         * @param path The path of the property to set.
+         * @param value The value to set.
+         * @return Returns object.
+         */
+        set<T>(
+            object: T,
+            path: StringRepresentable|StringRepresentable[],
+            value: any
+        ): T;
+
+        /**
+         * @see _.set
+         */
+        set<V, T>(
+            object: T,
+            path: StringRepresentable|StringRepresentable[],
+            value: V
+        ): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.set
+         */
+        set<V>(
+            path: StringRepresentable|StringRepresentable[],
+            value: V
+        ): LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.set
+         */
+        set<V>(
+            path: StringRepresentable|StringRepresentable[],
+            value: V
+        ): LoDashExplicitObjectWrapper<T>;
+    }
+
+    //_.transform
+    interface LoDashStatic {
+        /**
+         * An alternative to _.reduce; this method transforms object to a new accumulator object which is the result of
+         * running each of its own enumerable properties through iteratee, with each invocation potentially mutating
+         * the accumulator object. The iteratee is bound to thisArg and invoked with four arguments: (accumulator,
+         * value, key, object). Iteratee functions may exit iteration early by explicitly returning false.
+         *
+         * @param object The object to iterate over.
+         * @param iteratee The function invoked per iteration.
+         * @param accumulator The custom accumulator value.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the accumulated value.
+         */
+        transform<T, TResult>(
+            object: T[],
+            iteratee?: MemoVoidArrayIterator<T, TResult[]>,
+            accumulator?: TResult[],
+            thisArg?: any
+        ): TResult[];
+
+        /**
+         * @see _.transform
+         */
+        transform<T, TResult>(
+            object: T[],
+            iteratee?: MemoVoidArrayIterator<T, Dictionary<TResult>>,
+            accumulator?: Dictionary<TResult>,
+            thisArg?: any
+        ): Dictionary<TResult>;
+
+        /**
+         * @see _.transform
+         */
+        transform<T, TResult>(
+            object: Dictionary<T>,
+            iteratee?: MemoVoidDictionaryIterator<T, Dictionary<TResult>>,
+            accumulator?: Dictionary<TResult>,
+            thisArg?: any
+        ): Dictionary<TResult>;
+
+        /**
+         * @see _.transform
+         */
+        transform<T, TResult>(
+            object: Dictionary<T>,
+            iteratee?: MemoVoidDictionaryIterator<T, TResult[]>,
+            accumulator?: TResult[],
+            thisArg?: any
+        ): TResult[];
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.transform
+         */
+        transform<TResult>(
+            iteratee?: MemoVoidArrayIterator<T, TResult[]>,
+            accumulator?: TResult[],
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.transform
+         */
+        transform<TResult>(
+            iteratee?: MemoVoidArrayIterator<T, Dictionary<TResult>>,
+            accumulator?: Dictionary<TResult>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.transform
+         */
+        transform<T, TResult>(
+            iteratee?: MemoVoidDictionaryIterator<T, Dictionary<TResult>>,
+            accumulator?: Dictionary<TResult>,
+            thisArg?: any
+        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
+
+        /**
+         * @see _.transform
+         */
+        transform<T, TResult>(
+            iteratee?: MemoVoidDictionaryIterator<T, TResult[]>,
+            accumulator?: TResult[],
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<TResult>;
+    }
+
+    //_.values
+    interface LoDashStatic {
+        /**
+         * Creates an array of the own enumerable property values of object.
+         *
+         * @param object The object to query.
+         * @return Returns an array of property values.
+         */
+        values<T>(object?: any): T[];
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.values
+         */
+        values<T>(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.values
+         */
+        values<T>(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.valuesIn
+    interface LoDashStatic {
+        /**
+         * Creates an array of the own and inherited enumerable property values of object.
+         *
+         * @param object The object to query.
+         * @return Returns the array of property values.
+         */
+        valuesIn<T>(object?: any): T[];
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.valuesIn
+         */
+        valuesIn<T>(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.valuesIn
+         */
+        valuesIn<T>(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    /**********
+     * String *
+     **********/
+
+    //_.camelCase
+    interface LoDashStatic {
+        /**
+         * Converts string to camel case.
+         *
+         * @param string The string to convert.
+         * @return Returns the camel cased string.
+         */
+        camelCase(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.camelCase
+         */
+        camelCase(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.camelCase
+         */
+        camelCase(): LoDashExplicitWrapper<string>;
+    }
+
+    //_.capitalize
+    interface LoDashStatic {
+        capitalize(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.capitalize
+         */
+        capitalize(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.capitalize
+         */
+        capitalize(): LoDashExplicitWrapper<string>;
+    }
+
+    //_.deburr
+    interface LoDashStatic {
+        /**
+         * Deburrs string by converting latin-1 supplementary letters to basic latin letters and removing combining
+         * diacritical marks.
+         *
+         * @param string The string to deburr.
+         * @return Returns the deburred string.
+         */
+        deburr(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.deburr
+         */
+        deburr(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.deburr
+         */
+        deburr(): LoDashExplicitWrapper<string>;
+    }
+
+    //_.endsWith
+    interface LoDashStatic {
+        /**
+         * Checks if string ends with the given target string.
+         *
+         * @param string The string to search.
+         * @param target The string to search for.
+         * @param position The position to search from.
+         * @return Returns true if string ends with target, else false.
+         */
+        endsWith(
+            string?: string,
+            target?: string,
+            position?: number
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.endsWith
+         */
+        endsWith(
+            target?: string,
+            position?: number
+        ): boolean;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.endsWith
+         */
+        endsWith(
+            target?: string,
+            position?: number
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    // _.escape
+    interface LoDashStatic {
+        /**
+         * Converts the characters "&", "<", ">", '"', "'", and "`", in string to their corresponding HTML entities.
+         *
+         * Note: No other characters are escaped. To escape additional characters use a third-party library like he.
+         *
+         * Though the ">" character is escaped for symmetry, characters like ">" and "/" don’t need escaping in HTML
+         * and have no special meaning unless they're part of a tag or unquoted attribute value. See Mathias Bynens’s
+         * article (under "semi-related fun fact") for more details.
+         *
+         * Backticks are escaped because in Internet Explorer < 9, they can break out of attribute values or HTML
+         * comments. See #59, #102, #108, and #133 of the HTML5 Security Cheatsheet for more details.
+         *
+         * When working with HTML you should always quote attribute values to reduce XSS vectors.
+         *
+         * @param string The string to escape.
+         * @return Returns the escaped string.
+         */
+        escape(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.escape
+         */
+        escape(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.escape
+         */
+        escape(): LoDashExplicitWrapper<string>;
+    }
+
+    // _.escapeRegExp
+    interface LoDashStatic {
+        /**
+         * Escapes the RegExp special characters "\", "/", "^", "$", ".", "|", "?", "*", "+", "(", ")", "[", "]",
+         * "{" and "}" in string.
+         *
+         * @param string The string to escape.
+         * @return Returns the escaped string.
+         */
+        escapeRegExp(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.escapeRegExp
+         */
+        escapeRegExp(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.escapeRegExp
+         */
+        escapeRegExp(): LoDashExplicitWrapper<string>;
+    }
+
+    //_.kebabCase
+    interface LoDashStatic {
+        /**
+         * Converts string to kebab case.
+         *
+         * @param string The string to convert.
+         * @return Returns the kebab cased string.
+         */
+        kebabCase(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.kebabCase
+         */
+        kebabCase(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.kebabCase
+         */
+        kebabCase(): LoDashExplicitWrapper<string>;
+    }
+
+    //_.pad
+    interface LoDashStatic {
+        /**
+         * Pads string on the left and right sides if it’s shorter than length. Padding characters are truncated if
+         * they can’t be evenly divided by length.
+         *
+         * @param string The string to pad.
+         * @param length The padding length.
+         * @param chars The string used as padding.
+         * @return Returns the padded string.
+         */
+        pad(
+            string?: string,
+            length?: number,
+            chars?: string
+        ): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.pad
+         */
+        pad(
+            length?: number,
+            chars?: string
+        ): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.pad
+         */
+        pad(
+            length?: number,
+            chars?: string
+        ): LoDashExplicitWrapper<string>;
+    }
+
+    //_.padLeft
+    interface LoDashStatic {
+        /**
+         * Pads string on the left side if it’s shorter than length. Padding characters are truncated if they exceed
+         * length.
+         *
+         * @param string The string to pad.
+         * @param length The padding length.
+         * @param chars The string used as padding.
+         * @return Returns the padded string.
+         */
+        padLeft(
+            string?: string,
+            length?: number,
+            chars?: string
+        ): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.padLeft
+         */
+        padLeft(
+            length?: number,
+            chars?: string
+        ): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.padLeft
+         */
+        padLeft(
+            length?: number,
+            chars?: string
+        ): LoDashExplicitWrapper<string>;
+    }
+
+    //_.padRight
+    interface LoDashStatic {
+        /**
+         * Pads string on the right side if it’s shorter than length. Padding characters are truncated if they exceed
+         * length.
+         *
+         * @param string The string to pad.
+         * @param length The padding length.
+         * @param chars The string used as padding.
+         * @return Returns the padded string.
+         */
+        padRight(
+            string?: string,
+            length?: number,
+            chars?: string
+        ): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.padRight
+         */
+        padRight(
+            length?: number,
+            chars?: string
+        ): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.padRight
+         */
+        padRight(
+            length?: number,
+            chars?: string
+        ): LoDashExplicitWrapper<string>;
+    }
+
+    //_.parseInt
+    interface LoDashStatic {
+        /**
+         * Converts string to an integer of the specified radix. If radix is undefined or 0, a radix of 10 is used
+         * unless value is a hexadecimal, in which case a radix of 16 is used.
+         *
+         * Note: This method aligns with the ES5 implementation of parseInt.
+         *
+         * @param string The string to convert.
+         * @param radix The radix to interpret value by.
+         * @return Returns the converted integer.
+         */
+        parseInt(
+            string: string,
+            radix?: number
+        ): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.parseInt
+         */
+        parseInt(radix?: number): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.parseInt
+         */
+        parseInt(radix?: number): LoDashExplicitWrapper<number>;
+    }
+
+    //_.repeat
+    interface LoDashStatic {
+        /**
+         * Repeats the given string n times.
+         *
+         * @param string The string to repeat.
+         * @param n The number of times to repeat the string.
+         * @return Returns the repeated string.
+         */
+        repeat(
+            string?: string,
+            n?: number
+        ): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.repeat
+         */
+        repeat(n?: number): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.repeat
+         */
+        repeat(n?: number): LoDashExplicitWrapper<string>;
+    }
+
+    //_.snakeCase
+    interface LoDashStatic {
+        /**
+         * Converts string to snake case.
+         *
+         * @param string The string to convert.
+         * @return Returns the snake cased string.
+         */
+        snakeCase(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.snakeCase
+         */
+        snakeCase(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.snakeCase
+         */
+        snakeCase(): LoDashExplicitWrapper<string>;
+    }
+
+    //_.startCase
+    interface LoDashStatic {
+        /**
+         * Converts string to start case.
+         *
+         * @param string The string to convert.
+         * @return Returns the start cased string.
+         */
+        startCase(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.startCase
+         */
+        startCase(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.startCase
+         */
+        startCase(): LoDashExplicitWrapper<string>;
+    }
+
+    //_.startsWith
+    interface LoDashStatic {
+        /**
+         * Checks if string starts with the given target string.
+         *
+         * @param string The string to search.
+         * @param target The string to search for.
+         * @param position The position to search from.
+         * @return Returns true if string starts with target, else false.
+         */
+        startsWith(
+            string?: string,
+            target?: string,
+            position?: number
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.startsWith
+         */
+        startsWith(
+            target?: string,
+            position?: number
+        ): boolean;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.startsWith
+         */
+        startsWith(
+            target?: string,
+            position?: number
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.template
+    interface TemplateOptions extends TemplateSettings {
+        /**
+         * The sourceURL of the template's compiled source.
+         */
+        sourceURL?: string;
+    }
+
+    interface TemplateExecutor {
+        (data?: Object): string;
+        source: string;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Creates a compiled template function that can interpolate data properties in "interpolate" delimiters,
+         * HTML-escape interpolated data properties in "escape" delimiters, and execute JavaScript in "evaluate"
+         * delimiters. Data properties may be accessed as free variables in the template. If a setting object is
+         * provided it takes precedence over _.templateSettings values.
+         *
+         * Note: In the development build _.template utilizes
+         * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) for easier
+         * debugging.
+         *
+         * For more information on precompiling templates see
+         * [lodash's custom builds documentation](https://lodash.com/custom-builds).
+         *
+         * For more information on Chrome extension sandboxes see
+         * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
+         *
+         * @param string The template string.
+         * @param options The options object.
+         * @param options.escape The HTML "escape" delimiter.
+         * @param options.evaluate The "evaluate" delimiter.
+         * @param options.imports An object to import into the template as free variables.
+         * @param options.interpolate The "interpolate" delimiter.
+         * @param options.sourceURL The sourceURL of the template's compiled source.
+         * @param options.variable The data object variable name.
+         * @return Returns the compiled template function.
+         */
+        template(
+            string: string,
+            options?: TemplateOptions
+        ): TemplateExecutor;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.template
+         */
+        template(options?: TemplateOptions): TemplateExecutor;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.template
+         */
+        template(options?: TemplateOptions): LoDashExplicitObjectWrapper<TemplateExecutor>;
+    }
+
+    //_.trim
+    interface LoDashStatic {
+        /**
+         * Removes leading and trailing whitespace or specified characters from string.
+         *
+         * @param string The string to trim.
+         * @param chars The characters to trim.
+         * @return Returns the trimmed string.
+         */
+        trim(
+            string?: string,
+            chars?: string
+        ): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.trim
+         */
+        trim(chars?: string): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.trim
+         */
+        trim(chars?: string): LoDashExplicitWrapper<string>;
+    }
+
+    //_.trimLeft
+    interface LoDashStatic {
+        /**
+         * Removes leading whitespace or specified characters from string.
+         *
+         * @param string The string to trim.
+         * @param chars The characters to trim.
+         * @return Returns the trimmed string.
+         */
+        trimLeft(
+            string?: string,
+            chars?: string
+        ): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.trimLeft
+         */
+        trimLeft(chars?: string): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.trimLeft
+         */
+        trimLeft(chars?: string): LoDashExplicitWrapper<string>;
+    }
+
+    //_.trimRight
+    interface LoDashStatic {
+        /**
+         * Removes trailing whitespace or specified characters from string.
+         *
+         * @param string The string to trim.
+         * @param chars The characters to trim.
+         * @return Returns the trimmed string.
+         */
+        trimRight(
+            string?: string,
+            chars?: string
+        ): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.trimRight
+         */
+        trimRight(chars?: string): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.trimRight
+         */
+        trimRight(chars?: string): LoDashExplicitWrapper<string>;
+    }
+
+    //_.trunc
+    interface TruncOptions {
+        /** The maximum string length. */
+        length?: number;
+        /** The string to indicate text is omitted. */
+        omission?: string;
+        /** The separator pattern to truncate to. */
+        separator?: string|RegExp;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Truncates string if it’s longer than the given maximum string length. The last characters of the truncated
+         * string are replaced with the omission string which defaults to "…".
+         *
+         * @param string The string to truncate.
+         * @param options The options object or maximum string length.
+         * @return Returns the truncated string.
+         */
+        trunc(
+            string?: string,
+            options?: TruncOptions|number
+        ): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.trunc
+         */
+        trunc(options?: TruncOptions|number): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.trunc
+         */
+        trunc(options?: TruncOptions|number): LoDashExplicitWrapper<string>;
+    }
+
+    //_.unescape
+    interface LoDashStatic {
+        /**
+         * The inverse of _.escape; this method converts the HTML entities &amp;, &lt;, &gt;, &quot;, &#39;, and &#96;
+         * in string to their corresponding characters.
+         *
+         * @param string The string to unescape.
+         * @return Returns the unescaped string.
+         */
+        unescape(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.unescape
+         */
+        unescape(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.unescape
+         */
+        unescape(): LoDashExplicitWrapper<string>;
+    }
+
+    //_.words
+    interface LoDashStatic {
+        /**
+         * Splits string into an array of its words.
+         *
+         * @param string The string to inspect.
+         * @param pattern The pattern to match words.
+         * @return Returns the words of string.
+         */
+        words(
+            string?: string,
+            pattern?: string|RegExp
+        ): string[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.words
+         */
+        words(pattern?: string|RegExp): string[];
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.words
+         */
+        words(pattern?: string|RegExp): LoDashExplicitArrayWrapper<string>;
+    }
+
+    /***********
+     * Utility *
+     ***********/
+
+    //_.attempt
+    interface LoDashStatic {
+        /**
+         * Attempts to invoke func, returning either the result or the caught error object. Any additional arguments
+         * are provided to func when it’s invoked.
+         *
+         * @param func The function to attempt.
+         * @return Returns the func result or error object.
+         */
+        attempt<TResult>(func: (...args: any[]) => TResult): TResult|Error;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.attempt
+         */
+        attempt<TResult>(): TResult|Error;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.attempt
+         */
+        attempt<TResult>(): LoDashExplicitObjectWrapper<TResult|Error>;
+    }
+
+    //_.callback
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes func with the this binding of thisArg and arguments of the created function.
+         * If func is a property name the created callback returns the property value for a given element. If func is
+         * an object the created callback returns true for elements that contain the equivalent object properties,
+         * otherwise it returns false.
+         *
+         * @param func The value to convert to a callback.
+         * @param thisArg The this binding of func.
+         * @result Returns the callback.
+         */
+        callback<TResult>(
+            func: Function,
+            thisArg?: any
+        ): (...args: any[]) => TResult;
+
+        /**
+         * @see _.callback
+         */
+        callback<TResult>(
+            func: string,
+            thisArg?: any
+        ): (object: any) => TResult;
+
+        /**
+         * @see _.callback
+         */
+        callback(
+            func: Object,
+            thisArg?: any
+        ): (object: any) => boolean;
+
+        /**
+         * @see _.callback
+         */
+        callback<TResult>(): (value: TResult) => TResult;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.callback
+         */
+        callback<TResult>(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => TResult>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.callback
+         */
+        callback(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => boolean>;
+
+        /**
+         * @see _.callback
+         */
+        callback<TResult>(thisArg?: any): LoDashImplicitObjectWrapper<(...args: any[]) => TResult>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.callback
+         */
+        callback<TResult>(thisArg?: any): LoDashExplicitObjectWrapper<(object: any) => TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.callback
+         */
+        callback(thisArg?: any): LoDashExplicitObjectWrapper<(object: any) => boolean>;
+
+        /**
+         * @see _.callback
+         */
+        callback<TResult>(thisArg?: any): LoDashExplicitObjectWrapper<(...args: any[]) => TResult>;
+    }
+
+    //_.constant
+    interface LoDashStatic {
+        /**
+         * Creates a function that returns value.
+         *
+         * @param value The value to return from the new function.
+         * @return Returns the new function.
+         */
+        constant<T>(value: T): () => T;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.constant
+         */
+        constant<TResult>(): LoDashImplicitObjectWrapper<() => TResult>;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.constant
+         */
+        constant<TResult>(): LoDashExplicitObjectWrapper<() => TResult>;
+    }
+
+    //_.identity
+    interface LoDashStatic {
+        /**
+         * This method returns the first argument provided to it.
+         * @param value Any value.
+         * @return Returns value.
+         */
+        identity<T>(value?: T): T;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.identity
+         */
+        identity(): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.identity
+         */
+        identity(): T[];
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.identity
+         */
+        identity(): T;
+    }
+
+    //_.iteratee
+    interface LoDashStatic {
+        /**
+         * @see _.callback
+         */
+        iteratee<TResult>(
+            func: Function,
+            thisArg?: any
+        ): (...args: any[]) => TResult;
+
+        /**
+         * @see _.callback
+         */
+        iteratee<TResult>(
+            func: string,
+            thisArg?: any
+        ): (object: any) => TResult;
+
+        /**
+         * @see _.callback
+         */
+        iteratee(
+            func: Object,
+            thisArg?: any
+        ): (object: any) => boolean;
+
+        /**
+         * @see _.callback
+         */
+        iteratee<TResult>(): (value: TResult) => TResult;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.callback
+         */
+        iteratee<TResult>(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => TResult>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.callback
+         */
+        iteratee(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => boolean>;
+
+        /**
+         * @see _.callback
+         */
+        iteratee<TResult>(thisArg?: any): LoDashImplicitObjectWrapper<(...args: any[]) => TResult>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.callback
+         */
+        iteratee<TResult>(thisArg?: any): LoDashExplicitObjectWrapper<(object: any) => TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.callback
+         */
+        iteratee(thisArg?: any): LoDashExplicitObjectWrapper<(object: any) => boolean>;
+
+        /**
+         * @see _.callback
+         */
+        iteratee<TResult>(thisArg?: any): LoDashExplicitObjectWrapper<(...args: any[]) => TResult>;
+    }
+
+    //_.matches
+    interface LoDashStatic {
+        /**
+         * Creates a function that performs a deep comparison between a given object and source, returning true if the
+         * given object has equivalent property values, else false.
+         *
+         * Note: This method supports comparing arrays, booleans, Date objects, numbers, Object objects, regexes, and
+         * strings. Objects are compared by their own, not inherited, enumerable properties. For comparing a single own
+         * or inherited property value see _.matchesProperty.
+         *
+         * @param source The object of property values to match.
+         * @return Returns the new function.
+         */
+        matches<T>(source: T): (value: any) => boolean;
+
+        /**
+         * @see _.matches
+         */
+        matches<T, V>(source: T): (value: V) => boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.matches
+         */
+        matches<V>(): LoDashImplicitObjectWrapper<(value: V) => boolean>;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.matches
+         */
+        matches<V>(): LoDashExplicitObjectWrapper<(value: V) => boolean>;
+    }
+
+    //_.matchesProperty
+    interface LoDashStatic {
+        /**
+         * Creates a function that compares the property value of path on a given object to value.
+         *
+         * Note: This method supports comparing arrays, booleans, Date objects, numbers, Object objects, regexes, and
+         * strings. Objects are compared by their own, not inherited, enumerable properties.
+         *
+         * @param path The path of the property to get.
+         * @param srcValue The value to match.
+         * @return Returns the new function.
+         */
+        matchesProperty<T>(
+            path: StringRepresentable|StringRepresentable[],
+            srcValue: T
+        ): (value: any) => boolean;
+
+        /**
+         * @see _.matchesProperty
+         */
+        matchesProperty<T, V>(
+            path: StringRepresentable|StringRepresentable[],
+            srcValue: T
+        ): (value: V) => boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.matchesProperty
+         */
+        matchesProperty<SrcValue>(
+            srcValue: SrcValue
+        ): LoDashImplicitObjectWrapper<(value: any) => boolean>;
+
+        /**
+         * @see _.matchesProperty
+         */
+        matchesProperty<SrcValue, Value>(
+            srcValue: SrcValue
+        ): LoDashImplicitObjectWrapper<(value: Value) => boolean>;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.matchesProperty
+         */
+        matchesProperty<SrcValue>(
+            srcValue: SrcValue
+        ): LoDashExplicitObjectWrapper<(value: any) => boolean>;
+
+        /**
+         * @see _.matchesProperty
+         */
+        matchesProperty<SrcValue, Value>(
+            srcValue: SrcValue
+        ): LoDashExplicitObjectWrapper<(value: Value) => boolean>;
+    }
+
+    //_.method
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes the method at path on a given object. Any additional arguments are provided
+         * to the invoked method.
+         *
+         * @param path The path of the method to invoke.
+         * @param args The arguments to invoke the method with.
+         * @return Returns the new function.
+         */
+        method<TObject, TResult>(
+            path: string|StringRepresentable[],
+            ...args: any[]
+        ): (object: TObject) => TResult;
+
+        /**
+         * @see _.method
+         */
+        method<TResult>(
+            path: string|StringRepresentable[],
+            ...args: any[]
+        ): (object: any) => TResult;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.method
+         */
+        method<TObject, TResult>(...args: any[]): LoDashImplicitObjectWrapper<(object: TObject) => TResult>;
+
+        /**
+         * @see _.method
+         */
+        method<TResult>(...args: any[]): LoDashImplicitObjectWrapper<(object: any) => TResult>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.method
+         */
+        method<TObject, TResult>(...args: any[]): LoDashImplicitObjectWrapper<(object: TObject) => TResult>;
+
+        /**
+         * @see _.method
+         */
+        method<TResult>(...args: any[]): LoDashImplicitObjectWrapper<(object: any) => TResult>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.method
+         */
+        method<TObject, TResult>(...args: any[]): LoDashExplicitObjectWrapper<(object: TObject) => TResult>;
+
+        /**
+         * @see _.method
+         */
+        method<TResult>(...args: any[]): LoDashExplicitObjectWrapper<(object: any) => TResult>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.method
+         */
+        method<TObject, TResult>(...args: any[]): LoDashExplicitObjectWrapper<(object: TObject) => TResult>;
+
+        /**
+         * @see _.method
+         */
+        method<TResult>(...args: any[]): LoDashExplicitObjectWrapper<(object: any) => TResult>;
+    }
+
+    //_.methodOf
+    interface LoDashStatic {
+        /**
+         * The opposite of _.method; this method creates a function that invokes the method at a given path on object.
+         * Any additional arguments are provided to the invoked method.
+         *
+         * @param object The object to query.
+         * @param args The arguments to invoke the method with.
+         * @return Returns the new function.
+         */
+        methodOf<TObject extends {}, TResult>(
+            object: TObject,
+            ...args: any[]
+        ): (path: StringRepresentable|StringRepresentable[]) => TResult;
+
+        /**
+         * @see _.methodOf
+         */
+        methodOf<TResult>(
+            object: {},
+            ...args: any[]
+        ): (path: StringRepresentable|StringRepresentable[]) => TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.methodOf
+         */
+        methodOf<TResult>(
+            ...args: any[]
+        ): LoDashImplicitObjectWrapper<(path: StringRepresentable|StringRepresentable[]) => TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.methodOf
+         */
+        methodOf<TResult>(
+            ...args: any[]
+        ): LoDashExplicitObjectWrapper<(path: StringRepresentable|StringRepresentable[]) => TResult>;
+    }
+
+    //_.mixin
+    interface MixinOptions {
+        chain?: boolean;
+    }
+
+    interface LoDashStatic {
+        /**
+         * Adds all own enumerable function properties of a source object to the destination object. If object is a
+         * function then methods are added to its prototype as well.
+         *
+         * Note: Use _.runInContext to create a pristine lodash function to avoid conflicts caused by modifying
+         * the original.
+         *
+         * @param object The destination object.
+         * @param source The object of functions to add.
+         * @param options The options object.
+         * @param options.chain Specify whether the functions added are chainable.
+         * @return Returns object.
+         */
+        mixin<TResult, TObject>(
+            object: TObject,
+            source: Dictionary<Function>,
+            options?: MixinOptions
+        ): TResult;
+
+        /**
+         * @see _.mixin
+         */
+        mixin<TResult>(
+            source: Dictionary<Function>,
+            options?: MixinOptions
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.mixin
+         */
+        mixin<TResult>(
+            source: Dictionary<Function>,
+            options?: MixinOptions
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.mixin
+         */
+        mixin<TResult>(
+            options?: MixinOptions
+        ): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.mixin
+         */
+        mixin<TResult>(
+            source: Dictionary<Function>,
+            options?: MixinOptions
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.mixin
+         */
+        mixin<TResult>(
+            options?: MixinOptions
+        ): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.noConflict
+    interface LoDashStatic {
+        /**
+         * Reverts the _ variable to its previous value and returns a reference to the lodash function.
+         *
+         * @return Returns the lodash function.
+         */
+        noConflict(): typeof _;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.noConflict
+         */
+        noConflict(): typeof _;
+    }
+
+    //_.noop
+    interface LoDashStatic {
+        /**
+         * A no-operation function that returns undefined regardless of the arguments it receives.
+         *
+         * @return undefined
+         */
+        noop(...args: any[]): void;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.noop
+         */
+        noop(...args: any[]): void;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.noop
+         */
+        noop(...args: any[]): _.LoDashExplicitWrapper<void>;
+    }
+
+    //_.property
+    interface LoDashStatic {
+        /**
+         * Creates a function that returns the property value at path on a given object.
+         *
+         * @param path The path of the property to get.
+         * @return Returns the new function.
+         */
+        property<TObj, TResult>(path: StringRepresentable|StringRepresentable[]): (obj: TObj) => TResult;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.property
+         */
+        property<TObj, TResult>(): LoDashImplicitObjectWrapper<(obj: TObj) => TResult>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.property
+         */
+        property<TObj, TResult>(): LoDashImplicitObjectWrapper<(obj: TObj) => TResult>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.property
+         */
+        property<TObj, TResult>(): LoDashExplicitObjectWrapper<(obj: TObj) => TResult>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.property
+         */
+        property<TObj, TResult>(): LoDashExplicitObjectWrapper<(obj: TObj) => TResult>;
+    }
+
+    //_.propertyOf
+    interface LoDashStatic {
+        /**
+         * The opposite of _.property; this method creates a function that returns the property value at a given path
+         * on object.
+         *
+         * @param object The object to query.
+         * @return Returns the new function.
+         */
+        propertyOf<T extends {}>(object: T): (path: string|string[]) => any;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.propertyOf
+         */
+        propertyOf(): LoDashImplicitObjectWrapper<(path: string|string[]) => any>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.propertyOf
+         */
+        propertyOf(): LoDashExplicitObjectWrapper<(path: string|string[]) => any>;
+    }
+
+    //_.range
+    interface LoDashStatic {
+        /**
+         * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end.
+         * If end is not specified it’s set to start with start then set to 0. If end is less than start a zero-length
+         * range is created unless a negative step is specified.
+         *
+         * @param start The start of the range.
+         * @param end The end of the range.
+         * @param step The value to increment or decrement by.
+         * @return Returns a new range array.
+         */
+        range(
+            start: number,
+            end: number,
+            step?: number
+        ): number[];
+
+        /**
+         * @see _.range
+         */
+        range(
+            end: number,
+            step?: number
+        ): number[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.range
+         */
+        range(
+            end?: number,
+            step?: number
+        ): LoDashImplicitArrayWrapper<number>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.range
+         */
+        range(
+            end?: number,
+            step?: number
+        ): LoDashExplicitArrayWrapper<number>;
+    }
+
+    //_.runInContext
+    interface LoDashStatic {
+        /**
+         * Create a new pristine lodash function using the given context object.
+         *
+         * @param context The context object.
+         * @return Returns a new lodash function.
+         */
+        runInContext(context?: Object): typeof _;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.runInContext
+         */
+        runInContext(): typeof _;
+    }
+
+    //_.times
+    interface LoDashStatic {
+        /**
+         * Invokes the iteratee function n times, returning an array of the results of each invocation. The iteratee is
+         * bound to thisArg and invoked with one argument; (index).
+         *
+         * @param n The number of times to invoke iteratee.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg The this binding of iteratee.
+         * @return Returns the array of results.
+         */
+        times<TResult>(
+            n: number,
+            iteratee: (num: number) => TResult,
+            thisArg?: any
+        ): TResult[];
+
+        /**
+         * @see _.times
+         */
+        times(n: number): number[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.times
+         */
+        times<TResult>(
+            iteratee: (num: number) => TResult,
+            thisArgs?: any
+        ): LoDashImplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.times
+         */
+        times(): LoDashImplicitArrayWrapper<number>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.times
+         */
+        times<TResult>(
+            iteratee: (num: number) => TResult,
+            thisArgs?: any
+        ): LoDashExplicitArrayWrapper<TResult>;
+
+        /**
+         * @see _.times
+         */
+        times(): LoDashExplicitArrayWrapper<number>;
+    }
+
+    //_.uniqueId
+    interface LoDashStatic {
+        /**
+         * Generates a unique ID. If prefix is provided the ID is appended to it.
+         *
+         * @param prefix The value to prefix the ID with.
+         * @return Returns the unique ID.
+         */
+        uniqueId(prefix?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.uniqueId
+         */
+        uniqueId(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.uniqueId
+         */
+        uniqueId(): LoDashExplicitWrapper<string>;
+    }
+
+    interface ListIterator<T, TResult> {
+        (value: T, index: number, collection: List<T>): TResult;
+    }
+
+    interface DictionaryIterator<T, TResult> {
+        (value: T, key?: string, collection?: Dictionary<T>): TResult;
+    }
+
+    interface NumericDictionaryIterator<T, TResult> {
+        (value: T, key?: number, collection?: Dictionary<T>): TResult;
+    }
+
+    interface ObjectIterator<T, TResult> {
+        (element: T, key?: string, collection?: any): TResult;
+    }
+
+    interface StringIterator<TResult> {
+        (char: string, index?: number, string?: string): TResult;
+    }
+
+    interface MemoVoidIterator<T, TResult> {
+        (prev: TResult, curr: T, indexOrKey?: any, list?: T[]): void;
+    }
+    interface MemoIterator<T, TResult> {
+        (prev: TResult, curr: T, indexOrKey?: any, list?: T[]): TResult;
+    }
+
+    interface MemoVoidArrayIterator<T, TResult> {
+        (acc: TResult, curr: T, index?: number, arr?: T[]): void;
+    }
+    interface MemoVoidDictionaryIterator<T, TResult> {
+        (acc: TResult, curr: T, key?: string, dict?: Dictionary<T>): void;
+    }
+
+    //interface Collection<T> {}
+
+    // Common interface between Arrays and jQuery objects
+    interface List<T> {
+        [index: number]: T;
+        length: number;
+    }
+
+    interface Dictionary<T> {
+        [index: string]: T;
+    }
+
+    interface NumericDictionary<T> {
+        [index: number]: T;
+    }
+
+    interface StringRepresentable {
+        toString(): string;
+    }
+
+    interface Cancelable {
+        cancel(): void;
+    }
+}
+
+declare module "lodash" {
+    export = _;
+}
diff --git a/lodash/lodash-tests-3.10.ts b/lodash/lodash-tests-3.10.ts
new file mode 100644
index 000000000..efe2e1b3e
--- /dev/null
+++ b/lodash/lodash-tests-3.10.ts
@@ -0,0 +1,10016 @@
+/// <reference path='../lodash/lodash-3.10.d.ts' />
+
+declare var $: any, jQuery: any;
+
+interface IFoodOrganic {
+    name: string;
+    organic: boolean;
+}
+
+interface IFoodType {
+    name: string;
+    type: string;
+}
+
+interface IFoodCombined {
+    name: string;
+    organic: boolean;
+    type: string;
+}
+
+interface IStoogesQuote {
+    name: string;
+    quotes: string[];
+}
+
+interface IStoogesAge {
+    name: string;
+    age: number;
+}
+
+interface IStoogesCombined {
+    name: string;
+    age: number;
+    quotes: string[];
+}
+
+interface IKey {
+    dir: string;
+    code: number;
+}
+
+interface IDictionary<T> {
+    [index: string]: T;
+}
+
+var foodsOrganic: IFoodOrganic[] = [
+    { name: 'banana', organic: true },
+    { name: 'beet', organic: false },
+];
+var foodsType: IFoodType[] = [
+    { name: 'apple', type: 'fruit' },
+    { name: 'banana', type: 'fruit' },
+    { name: 'beet', type: 'vegetable' }
+];
+var foodsCombined: IFoodCombined[] = [
+    { 'name': 'apple', 'organic': false, 'type': 'fruit' },
+    { 'name': 'carrot', 'organic': true, 'type': 'vegetable' }
+];
+
+var stoogesQuotes: IStoogesQuote[] = [
+    { 'name': 'curly', 'quotes': ['Oh, a wise guy, eh?', 'Poifect!'] },
+    { 'name': 'moe', 'quotes': ['Spread out!', 'You knucklehead!'] }
+];
+var stoogesAges: IStoogesAge[] = [
+    { 'name': 'moe', 'age': 40 },
+    { 'name': 'larry', 'age': 50 }
+];
+var stoogesAgesDict: IDictionary<IStoogesAge> = {
+    first: { 'name': 'moe', 'age': 40 },
+    second: { 'name': 'larry', 'age': 50 }
+};
+var stoogesCombined: IStoogesCombined[] = [
+    { 'name': 'curly', 'age': 30, 'quotes': ['Oh, a wise guy, eh?', 'Poifect!'] },
+    { 'name': 'moe', 'age': 40, 'quotes': ['Spread out!', 'You knucklehead!'] }
+];
+
+var keys: IKey[] = [
+    { 'dir': 'left', 'code': 97 },
+    { 'dir': 'right', 'code': 100 }
+];
+
+class Dog {
+    constructor(public name: string) { }
+
+    public bark() {
+        console.log('Woof, woof!');
+    }
+}
+
+var result: any;
+
+var any: any;
+
+interface TResult {
+    a: number;
+    b: string;
+    c: boolean;
+}
+
+// _.MapCache
+var testMapCache: _.MapCache;
+result = <(key: string) => boolean>testMapCache.delete;
+result = <(key: string) => any>testMapCache.get;
+result = <(key: string) => boolean>testMapCache.has;
+result = <(key: string, value: any) => _.Dictionary<any>>testMapCache.set;
+
+// _
+module TestWrapper {
+    {
+        let result: _.LoDashImplicitWrapper<string>;
+        result = _('');
+    }
+
+    {
+        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 = <string>_([1, 2, 3, 4]).join(',');
+result = <number>_([1, 2, 3, 4]).pop();
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3, 4]).push(5, 6, 7);
+result = <number>_([1, 2, 3, 4]).shift();
+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);
+
+/*********
+ * Array *
+ *********/
+
+// _.chunk
+module TestChunk {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[][];
+
+        result = _.chunk<TResult>(array);
+        result = _.chunk<TResult>(array, 42);
+
+        result = _.chunk<TResult>(list);
+        result = _.chunk<TResult>(list, 42);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult[]>;
+
+        result = _(array).chunk();
+        result = _(array).chunk(42);
+
+        result = _(list).chunk<TResult>();
+        result = _(list).chunk<TResult>(42);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult[]>;
+
+        result = _(array).chain().chunk();
+        result = _(array).chain().chunk(42);
+
+        result = _(list).chain().chunk<TResult>();
+        result = _(list).chain().chunk<TResult>(42);
+    }
+}
+
+// _.compact
+module TestCompact {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.compact<TResult>();
+        result = _.compact<TResult>(array);
+        result = _.compact<TResult>(list);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _<TResult>(array).compact();
+        result = _(list).compact<TResult>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _<TResult>(array).chain().compact();
+        result = _(list).chain().compact<TResult>();
+    }
+}
+
+// _.difference
+module TestDifference {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.difference<TResult>(array);
+        result = _.difference<TResult>(array, array);
+        result = _.difference<TResult>(array, list, array);
+        result = _.difference<TResult>(array, array, list, array);
+
+        result = _.difference<TResult>(list);
+        result = _.difference<TResult>(list, list);
+        result = _.difference<TResult>(list, array, list);
+        result = _.difference<TResult>(list, list, array, list);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).difference();
+        result = _(array).difference(array);
+        result = _(array).difference(list, array);
+        result = _(array).difference(array, list, array);
+
+        result = _(list).difference<TResult>();
+        result = _(list).difference<TResult>(list);
+        result = _(list).difference<TResult>(array, list);
+        result = _(list).difference<TResult>(list, array, list);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().difference();
+        result = _(array).chain().difference(array);
+        result = _(array).chain().difference(list, array);
+        result = _(array).chain().difference(array, list, array);
+
+        result = _(list).chain().difference<TResult>();
+        result = _(list).chain().difference<TResult>(list);
+        result = _(list).chain().difference<TResult>(array, list);
+        result = _(list).chain().difference<TResult>(list, array, list);
+    }
+}
+
+// _.drop
+{
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+        result = _.drop<TResult>(array);
+        result = _.drop<TResult>(array, 42);
+
+        result = _.drop<TResult>(list);
+        result = _.drop<TResult>(list, 42);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).drop();
+        result = _(array).drop(42);
+
+        result = _(list).drop<TResult>();
+        result = _(list).drop<TResult>(42);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().drop();
+        result = _(array).chain().drop(42);
+
+        result = _(list).chain().drop<TResult>();
+        result = _(list).chain().drop<TResult>(42);
+    }
+}
+
+// _.dropRight
+module TestDropRight {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.dropRight<TResult>(array);
+        result = _.dropRight<TResult>(array, 42);
+
+        result = _.dropRight<TResult>(list);
+        result = _.dropRight<TResult>(list, 42);
+
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).dropRight();
+        result = _(array).dropRight(42);
+
+        result = _(list).dropRight<TResult>();
+        result = _(list).dropRight<TResult>(42);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().dropRight();
+        result = _(array).chain().dropRight(42);
+
+        result = _(list).chain().dropRight<TResult>();
+        result = _(list).chain().dropRight<TResult>(42);
+    }
+}
+
+// _.dropRightWhile
+module TestDropRightWhile {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let predicateFn: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
+
+    {
+        let result: TResult[];
+
+        result = _.dropRightWhile<TResult>(array);
+        result = _.dropRightWhile<TResult>(array, predicateFn);
+        result = _.dropRightWhile<TResult>(array, predicateFn, any);
+        result = _.dropRightWhile<TResult>(array, '');
+        result = _.dropRightWhile<TResult>(array, '', any);
+        result = _.dropRightWhile<{a: number;}, TResult>(array, {a: 42});
+
+        result = _.dropRightWhile<TResult>(list);
+        result = _.dropRightWhile<TResult>(list, predicateFn);
+        result = _.dropRightWhile<TResult>(list, predicateFn, any);
+        result = _.dropRightWhile<TResult>(list, '');
+        result = _.dropRightWhile<TResult>(list, '', any);
+        result = _.dropRightWhile<{a: number;}, TResult>(list, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).dropRightWhile();
+        result = _(array).dropRightWhile(predicateFn);
+        result = _(array).dropRightWhile(predicateFn, any);
+        result = _(array).dropRightWhile('');
+        result = _(array).dropRightWhile('', any);
+        result = _(array).dropRightWhile<{a: number;}>({a: 42});
+
+        result = _(list).dropRightWhile<TResult>();
+        result = _(list).dropRightWhile<TResult>(predicateFn);
+        result = _(list).dropRightWhile<TResult>(predicateFn, any);
+        result = _(list).dropRightWhile<TResult>('');
+        result = _(list).dropRightWhile<TResult>('', any);
+        result = _(list).dropRightWhile<{a: number;}, TResult>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().dropRightWhile();
+        result = _(array).chain().dropRightWhile(predicateFn);
+        result = _(array).chain().dropRightWhile(predicateFn, any);
+        result = _(array).chain().dropRightWhile('');
+        result = _(array).chain().dropRightWhile('', any);
+        result = _(array).chain().dropRightWhile<{a: number;}>({a: 42});
+
+        result = _(list).chain().dropRightWhile<TResult>();
+        result = _(list).chain().dropRightWhile<TResult>(predicateFn);
+        result = _(list).chain().dropRightWhile<TResult>(predicateFn, any);
+        result = _(list).chain().dropRightWhile<TResult>('');
+        result = _(list).chain().dropRightWhile<TResult>('', any);
+        result = _(list).chain().dropRightWhile<{a: number;}, TResult>({a: 42});
+    }
+}
+
+// _.dropWhile
+module TestDropWhile {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let predicateFn: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
+
+    {
+        let result: TResult[];
+
+        result = _.dropWhile<TResult>(array);
+        result = _.dropWhile<TResult>(array, predicateFn);
+        result = _.dropWhile<TResult>(array, predicateFn, any);
+        result = _.dropWhile<TResult>(array, '');
+        result = _.dropWhile<TResult>(array, '', any);
+        result = _.dropWhile<{a: number;}, TResult>(array, {a: 42});
+
+        result = _.dropWhile<TResult>(list);
+        result = _.dropWhile<TResult>(list, predicateFn);
+        result = _.dropWhile<TResult>(list, predicateFn, any);
+        result = _.dropWhile<TResult>(list, '');
+        result = _.dropWhile<TResult>(list, '', any);
+        result = _.dropWhile<{a: number;}, TResult>(list, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).dropWhile();
+        result = _(array).dropWhile(predicateFn);
+        result = _(array).dropWhile(predicateFn, any);
+        result = _(array).dropWhile('');
+        result = _(array).dropWhile('', any);
+        result = _(array).dropWhile<{a: number;}>({a: 42});
+
+        result = _(list).dropWhile<TResult>();
+        result = _(list).dropWhile<TResult>(predicateFn);
+        result = _(list).dropWhile<TResult>(predicateFn, any);
+        result = _(list).dropWhile<TResult>('');
+        result = _(list).dropWhile<TResult>('', any);
+        result = _(list).dropWhile<{a: number;}, TResult>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().dropWhile();
+        result = _(array).chain().dropWhile(predicateFn);
+        result = _(array).chain().dropWhile(predicateFn, any);
+        result = _(array).chain().dropWhile('');
+        result = _(array).chain().dropWhile('', any);
+        result = _(array).chain().dropWhile<{a: number;}>({a: 42});
+
+        result = _(list).chain().dropWhile<TResult>();
+        result = _(list).chain().dropWhile<TResult>(predicateFn);
+        result = _(list).chain().dropWhile<TResult>(predicateFn, any);
+        result = _(list).chain().dropWhile<TResult>('');
+        result = _(list).chain().dropWhile<TResult>('', any);
+        result = _(list).chain().dropWhile<{a: number;}, TResult>({a: 42});
+    }
+}
+
+// _.fill
+module TestFill {
+    let array: number[];
+    let list: _.List<number>;
+
+    {
+        let result: number[];
+
+        result = _.fill<number>(array, 42);
+        result = _.fill<number>(array, 42, 0);
+        result = _.fill<number>(array, 42, 0, 10);
+    }
+
+    {
+        let result: _.List<number>;
+
+        result = _.fill<number>(list, 42);
+        result = _.fill<number>(list, 42, 0);
+        result = _.fill<number>(list, 42, 0, 10);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<number>;
+
+        result = _(array).fill<number>(42);
+        result = _(array).fill<number>(42, 0);
+        result = _(array).fill<number>(42, 0, 10);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.List<number>>;
+
+        result = _(list).fill<number>(42);
+        result = _(list).fill<number>(42, 0);
+        result = _(list).fill<number>(42, 0, 10);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<number>;
+
+        result = _(array).chain().fill<number>(42);
+        result = _(array).chain().fill<number>(42, 0);
+        result = _(array).chain().fill<number>(42, 0, 10);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.List<number>>;
+
+        result = _(list).chain().fill<number>(42);
+        result = _(list).chain().fill<number>(42, 0);
+        result = _(list).chain().fill<number>(42, 0, 10);
+    }
+}
+
+// _.findIndex
+module TestFindIndex {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let predicateFn: (value: TResult, index?: number, collection?: _.List<TResult>) => boolean;
+
+    {
+        let result: number;
+
+        result = _.findIndex<TResult>(array);
+        result = _.findIndex<TResult>(array, predicateFn);
+        result = _.findIndex<TResult>(array, predicateFn, any);
+        result = _.findIndex<TResult>(array, '');
+        result = _.findIndex<TResult>(array, '', any);
+        result = _.findIndex<{a: number}, TResult>(array, {a: 42});
+
+        result = _.findIndex<TResult>(list);
+        result = _.findIndex<TResult>(list, predicateFn);
+        result = _.findIndex<TResult>(list, predicateFn, any);
+        result = _.findIndex<TResult>(list, '');
+        result = _.findIndex<TResult>(list, '', any);
+        result = _.findIndex<{a: number}, TResult>(list, {a: 42});
+
+        result = _<TResult>(array).findIndex();
+        result = _<TResult>(array).findIndex(predicateFn);
+        result = _<TResult>(array).findIndex(predicateFn, any);
+        result = _<TResult>(array).findIndex('');
+        result = _<TResult>(array).findIndex('', any);
+        result = _<TResult>(array).findIndex<{a: number}>({a: 42});
+
+        result = _(list).findIndex();
+        result = _(list).findIndex<TResult>(predicateFn);
+        result = _(list).findIndex<TResult>(predicateFn, any);
+        result = _(list).findIndex('');
+        result = _(list).findIndex('', any);
+        result = _(list).findIndex<{a: number}>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _<TResult>(array).chain().findIndex();
+        result = _<TResult>(array).chain().findIndex(predicateFn);
+        result = _<TResult>(array).chain().findIndex(predicateFn, any);
+        result = _<TResult>(array).chain().findIndex('');
+        result = _<TResult>(array).chain().findIndex('', any);
+        result = _<TResult>(array).chain().findIndex<{a: number}>({a: 42});
+
+        result = _(list).chain().findIndex();
+        result = _(list).chain().findIndex<TResult>(predicateFn);
+        result = _(list).chain().findIndex<TResult>(predicateFn, any);
+        result = _(list).chain().findIndex('');
+        result = _(list).chain().findIndex('', any);
+        result = _(list).chain().findIndex<{a: number}>({a: 42});
+    }
+}
+
+// _.findLastIndex
+module TestFindLastIndex {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    let predicateFn: (value: TResult, index?: number, collection?: _.List<TResult>) => boolean;
+
+    {
+        let result: number;
+
+        result = _.findLastIndex<TResult>(array);
+        result = _.findLastIndex<TResult>(array, predicateFn);
+        result = _.findLastIndex<TResult>(array, predicateFn, any);
+        result = _.findLastIndex<TResult>(array, '');
+        result = _.findLastIndex<TResult>(array, '', any);
+        result = _.findLastIndex<{a: number}, TResult>(array, {a: 42});
+
+        result = _.findLastIndex<TResult>(list);
+        result = _.findLastIndex<TResult>(list, predicateFn);
+        result = _.findLastIndex<TResult>(list, predicateFn, any);
+        result = _.findLastIndex<TResult>(list, '');
+        result = _.findLastIndex<TResult>(list, '', any);
+        result = _.findLastIndex<{a: number}, TResult>(list, {a: 42});
+
+        result = _<TResult>(array).findLastIndex();
+        result = _<TResult>(array).findLastIndex(predicateFn);
+        result = _<TResult>(array).findLastIndex(predicateFn, any);
+        result = _<TResult>(array).findLastIndex('');
+        result = _<TResult>(array).findLastIndex('', any);
+        result = _<TResult>(array).findLastIndex<{a: number}>({a: 42});
+
+        result = _(list).findLastIndex();
+        result = _(list).findLastIndex<TResult>(predicateFn);
+        result = _(list).findLastIndex<TResult>(predicateFn, any);
+        result = _(list).findLastIndex('');
+        result = _(list).findLastIndex('', any);
+        result = _(list).findLastIndex<{a: number}>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _<TResult>(array).chain().findLastIndex();
+        result = _<TResult>(array).chain().findLastIndex(predicateFn);
+        result = _<TResult>(array).chain().findLastIndex(predicateFn, any);
+        result = _<TResult>(array).chain().findLastIndex('');
+        result = _<TResult>(array).chain().findLastIndex('', any);
+        result = _<TResult>(array).chain().findLastIndex<{a: number}>({a: 42});
+
+        result = _(list).chain().findLastIndex();
+        result = _(list).chain().findLastIndex<TResult>(predicateFn);
+        result = _(list).chain().findLastIndex<TResult>(predicateFn, any);
+        result = _(list).chain().findLastIndex('');
+        result = _(list).chain().findLastIndex('', any);
+        result = _(list).chain().findLastIndex<{a: number}>({a: 42});
+    }
+}
+
+// _.first
+module TestFirst {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let result: TResult;
+    result = _.first<TResult>(array);
+    result = _.first<TResult>(list);
+    result = _(array).first();
+    result = _(list).first<TResult>();
+}
+
+// _.flatten
+module TestFlatten {
+    {
+        let result: string[];
+
+        result = _.flatten('abc');
+    }
+
+    {
+        let result: number[];
+
+        result = _.flatten<number>([1, 2, 3]);
+        result = _.flatten<number>([1, [2, 3]]);
+        result = _.flatten<number>([1, [2, [3]]], true);
+        result = _.flatten<number>([1, [2, [3]], [[4]]], true);
+
+        result = _.flatten<number>({0: 1, 1: 2, 2: 3, length: 3});
+        result = _.flatten<number>({0: 1, 1: [2, 3], length: 2});
+        result = _.flatten<number>({0: 1, 1: [2, [3]], length: 2}, true);
+        result = _.flatten<number>({0: 1, 1: [2, [3]], 2: [[4]], length: 3}, true);
+    }
+
+    {
+        let result: _.RecursiveArray<number>;
+
+        result = _.flatten<number>([1, [2, [3]]]);
+        result = _.flatten<number>([1, [2, [3]], [[4]]]);
+
+        result = _.flatten<number>({0: 1, 1: [2, [3]], length: 2});
+        result = _.flatten<number>({0: 1, 1: [2, [3]], 2: [[4]], length: 3});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('abc').flatten();
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<number>;
+
+        result = _([1, 2, 3]).flatten<number>();
+        result = _([1, [2, 3]]).flatten<number>();
+        result = _([1, [2, [3]]]).flatten<number>(true);
+        result = _([1, [2, [3]], [[4]]]).flatten<number>(true);
+
+        result = _({0: 1, 1: 2, 2: 3, length: 3}).flatten<number>();
+        result = _({0: 1, 1: [2, 3], length: 2}).flatten<number>();
+        result = _({0: 1, 1: [2, [3]], length: 2}).flatten<number>(true);
+        result = _({0: 1, 1: [2, [3]], 2: [[4]], length: 3}).flatten<number>(true);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<number|number[]>;
+
+        result = _([1, [2, [3]]]).flatten<number|number[]>();
+        result = _([1, [2, [3]], [[4]]]).flatten<number|number[]>();
+
+        result = _({0: 1, 1: [2, [3]], length: 2}).flatten<number|number[]>();
+        result = _({0: 1, 1: [2, [3]], 2: [[4]], length: 3}).flatten<number|number[]>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _('abc').chain().flatten();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<number>;
+
+        result = _([1, 2, 3]).chain().flatten<number>();
+        result = _([1, [2, 3]]).chain().flatten<number>();
+        result = _([1, [2, [3]]]).chain().flatten<number>(true);
+        result = _([1, [2, [3]], [[4]]]).chain().flatten<number>(true);
+
+        result = _({0: 1, 1: 2, 2: 3, length: 3}).chain().flatten<number>();
+        result = _({0: 1, 1: [2, 3], length: 2}).chain().flatten<number>();
+        result = _({0: 1, 1: [2, [3]], length: 2}).chain().flatten<number>(true);
+        result = _({0: 1, 1: [2, [3]], 2: [[4]], length: 3}).chain().flatten<number>(true);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<number|number[]>;
+
+        result = _([1, [2, [3]]]).chain().flatten<number|number[]>();
+        result = _([1, [2, [3]], [[4]]]).chain().flatten<number|number[]>();
+
+        result = _({0: 1, 1: [2, [3]], length: 2}).chain().flatten<number|number[]>();
+        result = _({0: 1, 1: [2, [3]], 2: [[4]], length: 3}).chain().flatten<number|number[]>();
+    }
+}
+
+// _.flattenDeep
+module TestFlattenDeep {
+    {
+        let result: string[];
+
+        result = _.flattenDeep('abc');
+    }
+
+    {
+        let result: number[];
+
+        result = _.flattenDeep<number>([1, 2, 3]);
+        result = _.flattenDeep<number>([1, [2, 3]]);
+        result = _.flattenDeep<number>([1, [2, [3]]]);
+        result = _.flattenDeep<number>([1, [2, [3]], [[4]]]);
+
+        result = _.flattenDeep<number>({0: 1, 1: 2, 2: 3, length: 3});
+        result = _.flattenDeep<number>({0: 1, 1: [2, 3], length: 2});
+        result = _.flattenDeep<number>({0: 1, 1: [2, [3]], length: 2});
+        result = _.flattenDeep<number>({0: 1, 1: [2, [3]], 2: [[4]], length: 3});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('abc').flattenDeep();
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<number>;
+
+        result = _([1, 2, 3]).flattenDeep<number>();
+        result = _([1, [2, 3]]).flattenDeep<number>();
+        result = _([1, [2, [3]]]).flattenDeep<number>();
+        result = _([1, [2, [3]], [[4]]]).flattenDeep<number>();
+
+        result = _({0: 1, 1: 2, 2: 3, length: 3}).flattenDeep<number>();
+        result = _({0: 1, 1: [2, 3], length: 2}).flattenDeep<number>();
+        result = _({0: 1, 1: [2, [3]], length: 2}).flattenDeep<number>();
+        result = _({0: 1, 1: [2, [3]], 2: [[4]], length: 3}).flattenDeep<number>();
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<number|number[]>;
+
+        result = _([1, [2, [3]]]).flattenDeep<number|number[]>();
+        result = _([1, [2, [3]], [[4]]]).flattenDeep<number|number[]>();
+
+        result = _({0: 1, 1: [2, [3]], length: 2}).flattenDeep<number|number[]>();
+        result = _({0: 1, 1: [2, [3]], 2: [[4]], length: 3}).flattenDeep<number|number[]>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _('abc').chain().flattenDeep();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<number>;
+
+        result = _([1, 2, 3]).chain().flattenDeep<number>();
+        result = _([1, [2, 3]]).chain().flattenDeep<number>();
+        result = _([1, [2, [3]]]).chain().flattenDeep<number>();
+        result = _([1, [2, [3]], [[4]]]).chain().flattenDeep<number>();
+
+        result = _({0: 1, 1: 2, 2: 3, length: 3}).chain().flattenDeep<number>();
+        result = _({0: 1, 1: [2, 3], length: 2}).chain().flattenDeep<number>();
+        result = _({0: 1, 1: [2, [3]], length: 2}).chain().flattenDeep<number>();
+        result = _({0: 1, 1: [2, [3]], 2: [[4]], length: 3}).chain().flattenDeep<number>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<number|number[]>;
+
+        result = _([1, [2, [3]]]).chain().flattenDeep<number|number[]>();
+        result = _([1, [2, [3]], [[4]]]).chain().flattenDeep<number|number[]>();
+
+        result = _({0: 1, 1: [2, [3]], length: 2}).chain().flattenDeep<number|number[]>();
+        result = _({0: 1, 1: [2, [3]], 2: [[4]], length: 3}).chain().flattenDeep<number|number[]>();
+    }
+}
+
+// _.head
+module TestHead {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let result: TResult;
+    result = _.head<TResult>(array);
+    result = _.head<TResult>(list);
+    result = _(array).head();
+    result = _(list).head<TResult>();
+}
+
+// _.indexOf
+module TestIndexOf {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let value: TResult;
+
+    {
+        let result: number;
+
+        result = _.indexOf<TResult>(array, value);
+        result = _.indexOf<TResult>(array, value, true);
+        result = _.indexOf<TResult>(array, value, 42);
+
+        result = _.indexOf<TResult>(list, value);
+        result = _.indexOf<TResult>(list, value, true);
+        result = _.indexOf<TResult>(list, value, 42);
+
+        result = _(array).indexOf(value);
+        result = _(array).indexOf(value, true);
+        result = _(array).indexOf(value, 42);
+
+        result = _(list).indexOf<TResult>(value);
+        result = _(list).indexOf<TResult>(value, true);
+        result = _(list).indexOf<TResult>(value, 42);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(array).chain().indexOf(value);
+        result = _(array).chain().indexOf(value, true);
+        result = _(array).chain().indexOf(value, 42);
+
+        result = _(list).chain().indexOf<TResult>(value);
+        result = _(list).chain().indexOf<TResult>(value, true);
+        result = _(list).chain().indexOf<TResult>(value, 42);
+    }
+}
+
+//_.initial
+module TestInitial {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.initial<TResult>(array);
+        result = _.initial<TResult>(list);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).initial();
+        result = _(list).initial<TResult>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().initial();
+        result = _(list).chain().initial<TResult>();
+    }
+}
+
+// _.intersection
+module TestIntersection {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.intersection<TResult>(array, list);
+        result = _.intersection<TResult>(list, array, list);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).intersection<TResult>(array);
+        result = _(array).intersection<TResult>(list, array);
+
+        result = _(list).intersection<TResult>(array);
+        result = _(list).intersection<TResult>(list, array);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().intersection<TResult>(array);
+        result = _(array).chain().intersection<TResult>(list, array);
+
+        result = _(list).chain().intersection<TResult>(array);
+        result = _(list).chain().intersection<TResult>(list, array);
+    }
+}
+
+// _.last
+module TestLast {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult;
+
+        result = _.last<TResult>(array);
+        result = _.last<TResult>(list);
+
+        result = _(array).last();
+        result = _(list).last<TResult>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().last();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.List<TResult>>;
+
+        result = _(list).chain().last<_.List<TResult>>();
+    }
+}
+
+// _.lastIndexOf
+module TestLastIndexOf {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let value: TResult;
+
+    {
+        let result: number;
+
+        result = _.lastIndexOf<TResult>(array, value);
+        result = _.lastIndexOf<TResult>(array, value, true);
+        result = _.lastIndexOf<TResult>(array, value, 42);
+
+        result = _.lastIndexOf<TResult>(list, value);
+        result = _.lastIndexOf<TResult>(list, value, true);
+        result = _.lastIndexOf<TResult>(list, value, 42);
+
+        result = _(array).lastIndexOf(value);
+        result = _(array).lastIndexOf(value, true);
+        result = _(array).lastIndexOf(value, 42);
+
+        result = _(list).lastIndexOf<TResult>(value);
+        result = _(list).lastIndexOf<TResult>(value, true);
+        result = _(list).lastIndexOf<TResult>(value, 42);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(array).chain().lastIndexOf(value);
+        result = _(array).chain().lastIndexOf(value, true);
+        result = _(array).chain().lastIndexOf(value, 42);
+
+        result = _(list).chain().lastIndexOf<TResult>(value);
+        result = _(list).chain().lastIndexOf<TResult>(value, true);
+        result = _(list).chain().lastIndexOf<TResult>(value, 42);
+    }
+}
+
+// _.object
+module TestObject {
+    let arrayOfKeys: string[];
+    let arrayOfValues: number[];
+    let arrayOfKeyValuePairs: (string|number)[][]
+
+    let listOfKeys: _.List<string>;
+    let listOfValues: _.List<number>;
+    let listOfKeyValuePairs: _.List<_.List<string|number>>;
+
+    {
+        let result: _.Dictionary<void>;
+
+        result = _.object<_.Dictionary<void>>(arrayOfKeys);
+        result = _.object<_.Dictionary<void>>(listOfKeys);
+    }
+
+    {
+        let result: _.Dictionary<number>;
+
+        result = _.object<_.Dictionary<number>>(arrayOfKeys, arrayOfValues);
+        result = _.object<_.Dictionary<number>>(arrayOfKeys, listOfValues);
+        result = _.object<_.Dictionary<number>>(listOfKeys, listOfValues);
+        result = _.object<_.Dictionary<number>>(listOfKeys, arrayOfValues);
+
+        result = _.object<number, _.Dictionary<number>>(arrayOfKeys, arrayOfValues);
+        result = _.object<number, _.Dictionary<number>>(arrayOfKeys, listOfValues);
+        result = _.object<number, _.Dictionary<number>>(listOfKeys, listOfValues);
+        result = _.object<number, _.Dictionary<number>>(listOfKeys, arrayOfValues);
+
+        result = _.object<_.Dictionary<number>>(arrayOfKeyValuePairs);
+        result = _.object<_.Dictionary<number>>(listOfKeyValuePairs);
+    }
+
+    {
+        let result: _.Dictionary<any>;
+
+        result = _.object(arrayOfKeys);
+        result = _.object(arrayOfKeys, arrayOfValues);
+        result = _.object(arrayOfKeys, listOfValues);
+
+        result = _.object(listOfKeys);
+        result = _.object(listOfKeys, listOfValues);
+        result = _.object(listOfKeys, arrayOfValues);
+
+        result = _.object<_.Dictionary<number>>(arrayOfKeyValuePairs);
+        result = _.object<_.Dictionary<number>>(listOfKeyValuePairs);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<void>>;
+
+        result = _(arrayOfKeys).object<_.Dictionary<void>>();
+        result = _(listOfKeys).object<_.Dictionary<void>>();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _(arrayOfKeys).object<_.Dictionary<number>>(arrayOfValues);
+        result = _(arrayOfKeys).object<_.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).object<_.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).object<_.Dictionary<number>>(arrayOfValues);
+
+        result = _(arrayOfKeys).object<number, _.Dictionary<number>>(arrayOfValues);
+        result = _(arrayOfKeys).object<number, _.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).object<number, _.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).object<number, _.Dictionary<number>>(arrayOfValues);
+
+        result = _(listOfKeys).object<_.Dictionary<number>>(arrayOfKeyValuePairs);
+        result = _(listOfKeys).object<_.Dictionary<number>>(listOfKeyValuePairs);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
+
+        result = _(arrayOfKeys).object();
+        result = _(arrayOfKeys).object(arrayOfValues);
+        result = _(arrayOfKeys).object(listOfValues);
+
+        result = _(listOfKeys).object();
+        result = _(listOfKeys).object(listOfValues);
+        result = _(listOfKeys).object(arrayOfValues);
+
+        result = _(listOfKeys).object(arrayOfKeyValuePairs);
+        result = _(listOfKeys).object(listOfKeyValuePairs);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<void>>;
+
+        result = _(arrayOfKeys).chain().object<_.Dictionary<void>>();
+        result = _(listOfKeys).chain().object<_.Dictionary<void>>();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _(arrayOfKeys).chain().object<_.Dictionary<number>>(arrayOfValues);
+        result = _(arrayOfKeys).chain().object<_.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).chain().object<_.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).chain().object<_.Dictionary<number>>(arrayOfValues);
+
+        result = _(arrayOfKeys).chain().object<number, _.Dictionary<number>>(arrayOfValues);
+        result = _(arrayOfKeys).chain().object<number, _.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).chain().object<number, _.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).chain().object<number, _.Dictionary<number>>(arrayOfValues);
+
+        result = _(listOfKeys).chain().object<_.Dictionary<number>>(arrayOfKeyValuePairs);
+        result = _(listOfKeys).chain().object<_.Dictionary<number>>(listOfKeyValuePairs);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<any>>;
+
+        result = _(arrayOfKeys).chain().object();
+        result = _(arrayOfKeys).chain().object(arrayOfValues);
+        result = _(arrayOfKeys).chain().object(listOfValues);
+
+        result = _(listOfKeys).chain().object();
+        result = _(listOfKeys).chain().object(listOfValues);
+        result = _(listOfKeys).chain().object(arrayOfValues);
+
+        result = _(listOfKeys).chain().object(arrayOfKeyValuePairs);
+        result = _(listOfKeys).chain().object(listOfKeyValuePairs);
+    }
+}
+
+// _.pull
+module TestPull {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let value: TResult;
+
+    {
+        let result: TResult[];
+
+        result = _.pull<TResult>(array);
+        result = _.pull<TResult>(array, value);
+        result = _.pull<TResult>(array, value, value);
+        result = _.pull<TResult>(array, value, value, value);
+    }
+
+    {
+        let result: _.List<TResult>;
+
+        result = _.pull<TResult>(list);
+        result = _.pull<TResult>(list, value);
+        result = _.pull<TResult>(list, value, value);
+        result = _.pull<TResult>(list, value, value, value);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).pull();
+        result = _(array).pull(value);
+        result = _(array).pull(value, value);
+        result = _(array).pull(value, value, value);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.List<TResult>>;
+
+        result = _(list).pull<TResult>();
+        result = _(list).pull<TResult>(value);
+        result = _(list).pull<TResult>(value, value);
+        result = _(list).pull<TResult>(value, value, value);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().pull();
+        result = _(array).chain().pull(value);
+        result = _(array).chain().pull(value, value);
+        result = _(array).chain().pull(value, value, value);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.List<TResult>>;
+
+        result = _(list).chain().pull<TResult>();
+        result = _(list).chain().pull<TResult>(value);
+        result = _(list).chain().pull<TResult>(value, value);
+        result = _(list).chain().pull<TResult>(value, value, value);
+    }
+}
+
+// _.pullAt
+module TestPullAt {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.pullAt<TResult>(array);
+        result = _.pullAt<TResult>(array, 1);
+        result = _.pullAt<TResult>(array, [2, 3], 1);
+        result = _.pullAt<TResult>(array, 4, [2, 3], 1);
+
+        result = _.pullAt<TResult>(list);
+        result = _.pullAt<TResult>(list, 1);
+        result = _.pullAt<TResult>(list, [2, 3], 1);
+        result = _.pullAt<TResult>(list, 4, [2, 3], 1);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).pullAt();
+        result = _(array).pullAt(1);
+        result = _(array).pullAt([2, 3], 1);
+        result = _(array).pullAt(4, [2, 3], 1);
+
+        result = _(list).pullAt<TResult>();
+        result = _(list).pullAt<TResult>(1);
+        result = _(list).pullAt<TResult>([2, 3], 1);
+        result = _(list).pullAt<TResult>(4, [2, 3], 1);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().pullAt();
+        result = _(array).chain().pullAt(1);
+        result = _(array).chain().pullAt([2, 3], 1);
+        result = _(array).chain().pullAt(4, [2, 3], 1);
+
+        result = _(list).chain().pullAt<TResult>();
+        result = _(list).chain().pullAt<TResult>(1);
+        result = _(list).chain().pullAt<TResult>([2, 3], 1);
+        result = _(list).chain().pullAt<TResult>(4, [2, 3], 1);
+    }
+}
+
+// _.remove
+module TestRemove {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let predicateFn: (value: TResult, index?: number, collection?: _.List<TResult>) => boolean;
+
+    {
+        let result: TResult[];
+
+        result = _.remove<TResult>(array);
+        result = _.remove<TResult>(array, predicateFn);
+        result = _.remove<TResult>(array, predicateFn, any);
+        result = _.remove<TResult>(array, '');
+        result = _.remove<TResult>(array, '', any);
+        result = _.remove<{a: number}, TResult>(array, {a: 42});
+
+        result = _.remove<TResult>(list);
+        result = _.remove<TResult>(list, predicateFn);
+        result = _.remove<TResult>(list, predicateFn, any);
+        result = _.remove<TResult>(list, '');
+        result = _.remove<TResult>(list, '', any);
+        result = _.remove<{a: number}, TResult>(list, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _<TResult>(array).remove();
+        result = _<TResult>(array).remove(predicateFn);
+        result = _<TResult>(array).remove(predicateFn, any);
+        result = _<TResult>(array).remove('');
+        result = _<TResult>(array).remove('', any);
+        result = _<TResult>(array).remove<{a: number}>({a: 42});
+
+        result = _(list).remove<TResult>();
+        result = _(list).remove<TResult>(predicateFn);
+        result = _(list).remove<TResult>(predicateFn, any);
+        result = _(list).remove<TResult>('');
+        result = _(list).remove<TResult>('', any);
+        result = _(list).remove<{a: number}, TResult>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _<TResult>(array).chain().remove();
+        result = _<TResult>(array).chain().remove(predicateFn);
+        result = _<TResult>(array).chain().remove(predicateFn, any);
+        result = _<TResult>(array).chain().remove('');
+        result = _<TResult>(array).chain().remove('', any);
+        result = _<TResult>(array).chain().remove<{a: number}>({a: 42});
+
+        result = _(list).chain().remove<TResult>();
+        result = _(list).chain().remove<TResult>(predicateFn);
+        result = _(list).chain().remove<TResult>(predicateFn, any);
+        result = _(list).chain().remove<TResult>('');
+        result = _(list).chain().remove<TResult>('', any);
+        result = _(list).chain().remove<{a: number}, TResult>({a: 42});
+    }
+}
+
+// _.rest
+module TestRest {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.rest<TResult>(array);
+        result = _.rest<TResult>(list);
+
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).rest();
+        result = _(list).rest<TResult>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().rest();
+        result = _(list).chain().rest<TResult>();
+    }
+}
+
+// _.slice
+module TestSlice {
+    let array: TResult[];
+
+    {
+        let result: TResult[];
+
+        result = _.slice(array);
+        result = _.slice(array, 42);
+        result = _.slice(array, 42, 42);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).slice();
+        result = _(array).slice(42);
+        result = _(array).slice(42, 42);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().slice();
+        result = _(array).chain().slice(42);
+        result = _(array).chain().slice(42, 42);
+    }
+}
+
+// _.sortedIndex
+module TestSortedIndex {
+    type SampleType = {a: number; b: string; c: boolean;};
+
+    let array: SampleType[];
+    let list: _.List<SampleType>;
+
+    let value: SampleType;
+
+    let stringIterator: (x: string) => number;
+    let arrayIterator: (x: SampleType) => number;
+    let listIterator: (x: SampleType) => number;
+
+    {
+        let result: number;
+
+        result = _.sortedIndex<string>('', '');
+        result = _.sortedIndex<string>('', '', stringIterator);
+        result = _.sortedIndex<string>('', '', stringIterator, any);
+        result = _.sortedIndex<string, number>('', '', stringIterator);
+        result = _.sortedIndex<string, number>('', '', stringIterator, any);
+
+        result = _.sortedIndex<SampleType>(array, value);
+        result = _.sortedIndex<SampleType>(array, value, arrayIterator);
+        result = _.sortedIndex<SampleType>(array, value, arrayIterator, any);
+        result = _.sortedIndex<SampleType>(array, value, '');
+        result = _.sortedIndex<SampleType>(array, value, {a: 42});
+        result = _.sortedIndex<SampleType, number>(array, value, arrayIterator);
+        result = _.sortedIndex<SampleType, number>(array, value, arrayIterator, any);
+        result = _.sortedIndex<{a: number}, SampleType>(array, value, {a: 42});
+
+        result = _.sortedIndex<SampleType>(list, value);
+        result = _.sortedIndex<SampleType>(list, value, listIterator);
+        result = _.sortedIndex<SampleType>(list, value, listIterator, any);
+        result = _.sortedIndex<SampleType>(list, value, '');
+        result = _.sortedIndex<SampleType>(list, value, {a: 42});
+        result = _.sortedIndex<SampleType, number>(list, value, listIterator);
+        result = _.sortedIndex<SampleType, number>(list, value, listIterator, any);
+        result = _.sortedIndex<{a: number}, SampleType>(list, value, {a: 42});
+
+        result = _('').sortedIndex('');
+        result = _('').sortedIndex<number>('', stringIterator);
+        result = _('').sortedIndex<number>('', stringIterator, any);
+
+        result = _(array).sortedIndex(value);
+        result = _(array).sortedIndex<number>(value, arrayIterator);
+        result = _(array).sortedIndex<number>(value, arrayIterator, any);
+        result = _(array).sortedIndex(value, '');
+        result = _(array).sortedIndex<{a: number}>(value, {a: 42});
+
+        result = _(list).sortedIndex<SampleType>(value);
+        result = _(list).sortedIndex<SampleType>(value, listIterator);
+        result = _(list).sortedIndex<SampleType>(value, listIterator, any);
+        result = _(list).sortedIndex<SampleType>(value, '');
+        result = _(list).sortedIndex<SampleType>(value, {a: 42});
+        result = _(list).sortedIndex<SampleType, number>(value, listIterator);
+        result = _(list).sortedIndex<SampleType, number>(value, listIterator, any);
+        result = _(list).sortedIndex<{a: number}, SampleType>(value, {a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _('').chain().sortedIndex('');
+        result = _('').chain().sortedIndex<number>('', stringIterator);
+        result = _('').chain().sortedIndex<number>('', stringIterator, any);
+
+        result = _(array).chain().sortedIndex(value);
+        result = _(array).chain().sortedIndex<number>(value, arrayIterator);
+        result = _(array).chain().sortedIndex<number>(value, arrayIterator, any);
+        result = _(array).chain().sortedIndex(value, '');
+        result = _(array).chain().sortedIndex<{a: number}>(value, {a: 42});
+
+        result = _(list).chain().sortedIndex<SampleType>(value);
+        result = _(list).chain().sortedIndex<SampleType>(value, listIterator);
+        result = _(list).chain().sortedIndex<SampleType>(value, listIterator, any);
+        result = _(list).chain().sortedIndex<SampleType>(value, '');
+        result = _(list).chain().sortedIndex<SampleType>(value, {a: 42});
+        result = _(list).chain().sortedIndex<SampleType, number>(value, listIterator);
+        result = _(list).chain().sortedIndex<SampleType, number>(value, listIterator, any);
+        result = _(list).chain().sortedIndex<{a: number}, SampleType>(value, {a: 42});
+    }
+}
+
+// _.sortedLastIndex
+module TestSortedLastIndex {
+    type SampleType = {a: number; b: string; c: boolean;};
+
+    let array: SampleType[];
+    let list: _.List<SampleType>;
+
+    let value: SampleType;
+
+    let stringIterator: (x: string) => number;
+    let arrayIterator: (x: SampleType) => number;
+    let listIterator: (x: SampleType) => number;
+
+    {
+        let result: number;
+
+        result = _.sortedLastIndex<string>('', '');
+        result = _.sortedLastIndex<string>('', '', stringIterator);
+        result = _.sortedLastIndex<string>('', '', stringIterator, any);
+        result = _.sortedLastIndex<string, number>('', '', stringIterator);
+        result = _.sortedLastIndex<string, number>('', '', stringIterator, any);
+
+        result = _.sortedLastIndex<SampleType>(array, value);
+        result = _.sortedLastIndex<SampleType>(array, value, arrayIterator);
+        result = _.sortedLastIndex<SampleType>(array, value, arrayIterator, any);
+        result = _.sortedLastIndex<SampleType>(array, value, '');
+        result = _.sortedLastIndex<SampleType>(array, value, {a: 42});
+        result = _.sortedLastIndex<SampleType, number>(array, value, arrayIterator);
+        result = _.sortedLastIndex<SampleType, number>(array, value, arrayIterator, any);
+        result = _.sortedLastIndex<{a: number}, SampleType>(array, value, {a: 42});
+
+        result = _.sortedLastIndex<SampleType>(list, value);
+        result = _.sortedLastIndex<SampleType>(list, value, listIterator);
+        result = _.sortedLastIndex<SampleType>(list, value, listIterator, any);
+        result = _.sortedLastIndex<SampleType>(list, value, '');
+        result = _.sortedLastIndex<SampleType>(list, value, {a: 42});
+        result = _.sortedLastIndex<SampleType, number>(list, value, listIterator);
+        result = _.sortedLastIndex<SampleType, number>(list, value, listIterator, any);
+        result = _.sortedLastIndex<{a: number}, SampleType>(list, value, {a: 42});
+
+        result = _('').sortedLastIndex('');
+        result = _('').sortedLastIndex<number>('', stringIterator);
+        result = _('').sortedLastIndex<number>('', stringIterator, any);
+
+        result = _(array).sortedLastIndex(value);
+        result = _(array).sortedLastIndex<number>(value, arrayIterator);
+        result = _(array).sortedLastIndex<number>(value, arrayIterator, any);
+        result = _(array).sortedLastIndex(value, '');
+        result = _(array).sortedLastIndex<{a: number}>(value, {a: 42});
+
+        result = _(list).sortedLastIndex<SampleType>(value);
+        result = _(list).sortedLastIndex<SampleType>(value, listIterator);
+        result = _(list).sortedLastIndex<SampleType>(value, listIterator, any);
+        result = _(list).sortedLastIndex<SampleType>(value, '');
+        result = _(list).sortedLastIndex<SampleType>(value, {a: 42});
+        result = _(list).sortedLastIndex<SampleType, number>(value, listIterator);
+        result = _(list).sortedLastIndex<SampleType, number>(value, listIterator, any);
+        result = _(list).sortedLastIndex<{a: number}, SampleType>(value, {a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _('').chain().sortedLastIndex('');
+        result = _('').chain().sortedLastIndex<number>('', stringIterator);
+        result = _('').chain().sortedLastIndex<number>('', stringIterator, any);
+
+        result = _(array).chain().sortedLastIndex(value);
+        result = _(array).chain().sortedLastIndex<number>(value, arrayIterator);
+        result = _(array).chain().sortedLastIndex<number>(value, arrayIterator, any);
+        result = _(array).chain().sortedLastIndex(value, '');
+        result = _(array).chain().sortedLastIndex<{a: number}>(value, {a: 42});
+
+        result = _(list).chain().sortedLastIndex<SampleType>(value);
+        result = _(list).chain().sortedLastIndex<SampleType>(value, listIterator);
+        result = _(list).chain().sortedLastIndex<SampleType>(value, listIterator, any);
+        result = _(list).chain().sortedLastIndex<SampleType>(value, '');
+        result = _(list).chain().sortedLastIndex<SampleType>(value, {a: 42});
+        result = _(list).chain().sortedLastIndex<SampleType, number>(value, listIterator);
+        result = _(list).chain().sortedLastIndex<SampleType, number>(value, listIterator, any);
+        result = _(list).chain().sortedLastIndex<{a: number}, SampleType>(value, {a: 42});
+    }
+}
+
+// _.tail
+module TestTail {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.tail<TResult>(array);
+        result = _.tail<TResult>(list);
+
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).tail();
+        result = _(list).tail<TResult>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().tail();
+        result = _(list).chain().tail<TResult>();
+    }
+}
+
+// _.take
+module TestTake {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.take<TResult>(array);
+        result = _.take<TResult>(array, 42);
+
+        result = _.take<TResult>(list);
+        result = _.take<TResult>(list, 42);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).take();
+        result = _(array).take(42);
+
+        result = _(list).take<TResult>();
+        result = _(list).take<TResult>(42);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().take();
+        result = _(array).chain().take(42);
+
+        result = _(list).chain().take<TResult>();
+        result = _(list).chain().take<TResult>(42);
+    }
+}
+
+// _.takeRight
+module TestTakeRight {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.takeRight<TResult>(array);
+        result = _.takeRight<TResult>(array, 42);
+
+        result = _.takeRight<TResult>(list);
+        result = _.takeRight<TResult>(list, 42);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).takeRight();
+        result = _(array).takeRight(42);
+
+        result = _(list).takeRight<TResult>();
+        result = _(list).takeRight<TResult>(42);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().takeRight();
+        result = _(array).chain().takeRight(42);
+
+        result = _(list).chain().takeRight<TResult>();
+        result = _(list).chain().takeRight<TResult>(42);
+    }
+}
+
+// _.takeRightWhile
+module TestTakeRightWhile {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let predicateFn: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
+
+    {
+        let result: TResult[];
+
+        result = _.takeRightWhile<TResult>(array);
+        result = _.takeRightWhile<TResult>(array, predicateFn);
+        result = _.takeRightWhile<TResult>(array, predicateFn, any);
+        result = _.takeRightWhile<TResult>(array, '');
+        result = _.takeRightWhile<TResult>(array, '', any);
+        result = _.takeRightWhile<{a: number;}, TResult>(array, {a: 42});
+
+        result = _.takeRightWhile<TResult>(list);
+        result = _.takeRightWhile<TResult>(list, predicateFn);
+        result = _.takeRightWhile<TResult>(list, predicateFn, any);
+        result = _.takeRightWhile<TResult>(list, '');
+        result = _.takeRightWhile<TResult>(list, '', any);
+        result = _.takeRightWhile<{a: number;}, TResult>(list, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).takeRightWhile();
+        result = _(array).takeRightWhile(predicateFn);
+        result = _(array).takeRightWhile(predicateFn, any);
+        result = _(array).takeRightWhile('');
+        result = _(array).takeRightWhile('', any);
+        result = _(array).takeRightWhile<{a: number;}>({a: 42});
+
+        result = _(list).takeRightWhile<TResult>();
+        result = _(list).takeRightWhile<TResult>(predicateFn);
+        result = _(list).takeRightWhile<TResult>(predicateFn, any);
+        result = _(list).takeRightWhile<TResult>('');
+        result = _(list).takeRightWhile<TResult>('', any);
+        result = _(list).takeRightWhile<{a: number;}, TResult>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().takeRightWhile();
+        result = _(array).chain().takeRightWhile(predicateFn);
+        result = _(array).chain().takeRightWhile(predicateFn, any);
+        result = _(array).chain().takeRightWhile('');
+        result = _(array).chain().takeRightWhile('', any);
+        result = _(array).chain().takeRightWhile<{a: number;}>({a: 42});
+
+        result = _(list).chain().takeRightWhile<TResult>();
+        result = _(list).chain().takeRightWhile<TResult>(predicateFn);
+        result = _(list).chain().takeRightWhile<TResult>(predicateFn, any);
+        result = _(list).chain().takeRightWhile<TResult>('');
+        result = _(list).chain().takeRightWhile<TResult>('', any);
+        result = _(list).chain().takeRightWhile<{a: number;}, TResult>({a: 42});
+    }
+}
+
+// _.takeWhile
+module TestTakeWhile {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let predicateFn: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
+
+    {
+        let result: TResult[];
+
+        result = _.takeWhile<TResult>(array);
+        result = _.takeWhile<TResult>(array, predicateFn);
+        result = _.takeWhile<TResult>(array, predicateFn, any);
+        result = _.takeWhile<TResult>(array, '');
+        result = _.takeWhile<TResult>(array, '', any);
+        result = _.takeWhile<{a: number;}, TResult>(array, {a: 42});
+
+        result = _.takeWhile<TResult>(list);
+        result = _.takeWhile<TResult>(list, predicateFn);
+        result = _.takeWhile<TResult>(list, predicateFn, any);
+        result = _.takeWhile<TResult>(list, '');
+        result = _.takeWhile<TResult>(list, '', any);
+        result = _.takeWhile<{a: number;}, TResult>(list, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).takeWhile();
+        result = _(array).takeWhile(predicateFn);
+        result = _(array).takeWhile(predicateFn, any);
+        result = _(array).takeWhile('');
+        result = _(array).takeWhile('', any);
+        result = _(array).takeWhile<{a: number;}>({a: 42});
+
+        result = _(list).takeWhile<TResult>();
+        result = _(list).takeWhile<TResult>(predicateFn);
+        result = _(list).takeWhile<TResult>(predicateFn, any);
+        result = _(list).takeWhile<TResult>('');
+        result = _(list).takeWhile<TResult>('', any);
+        result = _(list).takeWhile<{a: number;}, TResult>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().takeWhile();
+        result = _(array).chain().takeWhile(predicateFn);
+        result = _(array).chain().takeWhile(predicateFn, any);
+        result = _(array).chain().takeWhile('');
+        result = _(array).chain().takeWhile('', any);
+        result = _(array).chain().takeWhile<{a: number;}>({a: 42});
+
+        result = _(list).chain().takeWhile<TResult>();
+        result = _(list).chain().takeWhile<TResult>(predicateFn);
+        result = _(list).chain().takeWhile<TResult>(predicateFn, any);
+        result = _(list).chain().takeWhile<TResult>('');
+        result = _(list).chain().takeWhile<TResult>('', any);
+        result = _(list).chain().takeWhile<{a: number;}, TResult>({a: 42});
+    }
+}
+
+// _.union
+module TestUnion {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.union<TResult>();
+
+        result = _.union<TResult>(array);
+        result = _.union<TResult>(array, list);
+        result = _.union<TResult>(array, list, array);
+
+        result = _.union<TResult>(list);
+        result = _.union<TResult>(list, array);
+        result = _.union<TResult>(list, array, list);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).union();
+        result = _(array).union(list);
+        result = _(array).union(list, array);
+
+        result = _(array).union<TResult>();
+        result = _(array).union<TResult>(list);
+        result = _(array).union<TResult>(list, array);
+
+        result = _(list).union<TResult>();
+        result = _(list).union<TResult>(array);
+        result = _(list).union<TResult>(array, list);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().union();
+        result = _(array).chain().union(list);
+        result = _(array).chain().union(list, array);
+
+        result = _(array).chain().union<TResult>();
+        result = _(array).chain().union<TResult>(list);
+        result = _(array).chain().union<TResult>(list, array);
+
+        result = _(list).chain().union<TResult>();
+        result = _(list).chain().union<TResult>(array);
+        result = _(list).chain().union<TResult>(array, list);
+    }
+}
+
+// _.uniq
+module TestUniq {
+    type SampleObject = {a: number; b: string; c: boolean};
+
+    let array: SampleObject[];
+    let list: _.List<SampleObject>;
+
+    let stringIterator: (value: string, index: number, collection: string) => string;
+    let listIterator: (value: SampleObject, index: number, collection: _.List<SampleObject>) => number;
+
+    {
+        let result: string[];
+
+        result = _.uniq<string>('abc');
+        result = _.uniq<string>('abc', true);
+        result = _.uniq<string>('abc', true, stringIterator);
+        result = _.uniq<string>('abc', true, stringIterator, any);
+        result = _.uniq<string, string>('abc', true, stringIterator);
+        result = _.uniq<string, string>('abc', true, stringIterator, any);
+        result = _.uniq<string>('abc', stringIterator);
+        result = _.uniq<string>('abc', stringIterator, any);
+        result = _.uniq<string, string>('abc', stringIterator);
+        result = _.uniq<string, string>('abc', stringIterator, any);
+    }
+
+    {
+        let result: SampleObject[];
+
+        result = _.uniq<SampleObject>(array);
+        result = _.uniq<SampleObject>(array, true);
+        result = _.uniq<SampleObject>(array, true, listIterator);
+        result = _.uniq<SampleObject>(array, true, listIterator, any);
+        result = _.uniq<SampleObject, number>(array, true, listIterator);
+        result = _.uniq<SampleObject, number>(array, true, listIterator, any);
+        result = _.uniq<SampleObject>(array, listIterator);
+        result = _.uniq<SampleObject>(array, listIterator, any);
+        result = _.uniq<SampleObject, number>(array, listIterator);
+        result = _.uniq<SampleObject, number>(array, listIterator, any);
+        result = _.uniq<SampleObject>(array, true, 'a');
+        result = _.uniq<SampleObject>(array, true, 'a', any);
+        result = _.uniq<SampleObject>(array, 'a');
+        result = _.uniq<SampleObject>(array, 'a', any);
+        result = _.uniq<SampleObject>(array, true, {a: 42});
+        result = _.uniq<{a: number}, SampleObject>(array, true, {a: 42});
+        result = _.uniq<SampleObject>(array, {a: 42});
+        result = _.uniq<{a: number}, SampleObject>(array, {a: 42});
+
+        result = _.uniq<SampleObject>(list);
+        result = _.uniq<SampleObject>(list, true);
+        result = _.uniq<SampleObject>(list, true, listIterator);
+        result = _.uniq<SampleObject>(list, true, listIterator, any);
+        result = _.uniq<SampleObject, number>(list, true, listIterator);
+        result = _.uniq<SampleObject, number>(list, true, listIterator, any);
+        result = _.uniq<SampleObject>(list, listIterator);
+        result = _.uniq<SampleObject>(list, listIterator, any);
+        result = _.uniq<SampleObject, number>(list, listIterator);
+        result = _.uniq<SampleObject, number>(list, listIterator, any);
+        result = _.uniq<SampleObject>(list, true, 'a');
+        result = _.uniq<SampleObject>(list, true, 'a', any);
+        result = _.uniq<SampleObject>(list, 'a');
+        result = _.uniq<SampleObject>(list, 'a', any);
+        result = _.uniq<SampleObject>(list, true, {a: 42});
+        result = _.uniq<{a: number}, SampleObject>(list, true, {a: 42});
+        result = _.uniq<SampleObject>(list, {a: 42});
+        result = _.uniq<{a: number}, SampleObject>(list, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('abc').uniq();
+        result = _('abc').uniq(true);
+        result = _('abc').uniq<string>(true, stringIterator);
+        result = _('abc').uniq<string>(true, stringIterator, any);
+        result = _('abc').uniq<string>(stringIterator);
+        result = _('abc').uniq<string>(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<SampleObject>;
+
+        result = _(array).uniq();
+        result = _(array).uniq(true);
+        result = _(array).uniq<number>(true, listIterator);
+        result = _(array).uniq<number>(true, listIterator, any);
+        result = _(array).uniq<number>(listIterator);
+        result = _(array).uniq<number>(listIterator, any);
+        result = _(array).uniq(true, 'a');
+        result = _(array).uniq(true, 'a', any);
+        result = _(array).uniq('a');
+        result = _(array).uniq('a', any);
+        result = _(array).uniq<{a: number}>(true, {a: 42});
+        result = _(array).uniq<{a: number}>({a: 42});
+
+        result = _(list).uniq<SampleObject>();
+        result = _(list).uniq<SampleObject>(true);
+        result = _(list).uniq<SampleObject>(true, listIterator);
+        result = _(list).uniq<SampleObject>(true, listIterator, any);
+        result = _(list).uniq<SampleObject, number>(true, listIterator);
+        result = _(list).uniq<SampleObject, number>(true, listIterator, any);
+        result = _(list).uniq<SampleObject>(listIterator);
+        result = _(list).uniq<SampleObject>(listIterator, any);
+        result = _(list).uniq<SampleObject, number>(listIterator);
+        result = _(list).uniq<SampleObject, number>(listIterator, any);
+        result = _(list).uniq<SampleObject>(true, 'a');
+        result = _(list).uniq<SampleObject>(true, 'a', any);
+        result = _(list).uniq<SampleObject>('a');
+        result = _(list).uniq<SampleObject>('a', any);
+        result = _(list).uniq<SampleObject>(true, {a: 42});
+        result = _(list).uniq<{a: number}, SampleObject>(true, {a: 42});
+        result = _(list).uniq<SampleObject>({a: 42});
+        result = _(list).uniq<{a: number}, SampleObject>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _('abc').chain().uniq();
+        result = _('abc').chain().uniq(true);
+        result = _('abc').chain().uniq<string>(true, stringIterator);
+        result = _('abc').chain().uniq<string>(true, stringIterator, any);
+        result = _('abc').chain().uniq<string>(stringIterator);
+        result = _('abc').chain().uniq<string>(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<SampleObject>;
+
+        result = _(array).chain().uniq();
+        result = _(array).chain().uniq(true);
+        result = _(array).chain().uniq<number>(true, listIterator);
+        result = _(array).chain().uniq<number>(true, listIterator, any);
+        result = _(array).chain().uniq<number>(listIterator);
+        result = _(array).chain().uniq<number>(listIterator, any);
+        result = _(array).chain().uniq(true, 'a');
+        result = _(array).chain().uniq(true, 'a', any);
+        result = _(array).chain().uniq('a');
+        result = _(array).chain().uniq('a', any);
+        result = _(array).chain().uniq<{a: number}>(true, {a: 42});
+        result = _(array).chain().uniq<{a: number}>({a: 42});
+
+        result = _(list).chain().uniq<SampleObject>();
+        result = _(list).chain().uniq<SampleObject>(true);
+        result = _(list).chain().uniq<SampleObject>(true, listIterator);
+        result = _(list).chain().uniq<SampleObject>(true, listIterator, any);
+        result = _(list).chain().uniq<SampleObject, number>(true, listIterator);
+        result = _(list).chain().uniq<SampleObject, number>(true, listIterator, any);
+        result = _(list).chain().uniq<SampleObject>(listIterator);
+        result = _(list).chain().uniq<SampleObject>(listIterator, any);
+        result = _(list).chain().uniq<SampleObject, number>(listIterator);
+        result = _(list).chain().uniq<SampleObject, number>(listIterator, any);
+        result = _(list).chain().uniq<SampleObject>(true, 'a');
+        result = _(list).chain().uniq<SampleObject>(true, 'a', any);
+        result = _(list).chain().uniq<SampleObject>('a');
+        result = _(list).chain().uniq<SampleObject>('a', any);
+        result = _(list).chain().uniq<SampleObject>(true, {a: 42});
+        result = _(list).chain().uniq<{a: number}, SampleObject>(true, {a: 42});
+        result = _(list).chain().uniq<SampleObject>({a: 42});
+        result = _(list).chain().uniq<{a: number}, SampleObject>({a: 42});
+    }
+}
+
+// _.unique
+module TestUnique {
+    type SampleObject = {a: number; b: string; c: boolean};
+
+    let array: SampleObject[];
+    let list: _.List<SampleObject>;
+
+    let stringIterator: (value: string, index: number, collection: string) => string;
+    let listIterator: (value: SampleObject, index: number, collection: _.List<SampleObject>) => number;
+
+    {
+        let result: string[];
+
+        result = _.unique<string>('abc');
+        result = _.unique<string>('abc', true);
+        result = _.unique<string>('abc', true, stringIterator);
+        result = _.unique<string>('abc', true, stringIterator, any);
+        result = _.unique<string, string>('abc', true, stringIterator);
+        result = _.unique<string, string>('abc', true, stringIterator, any);
+        result = _.unique<string>('abc', stringIterator);
+        result = _.unique<string>('abc', stringIterator, any);
+        result = _.unique<string, string>('abc', stringIterator);
+        result = _.unique<string, string>('abc', stringIterator, any);
+    }
+
+    {
+        let result: SampleObject[];
+
+        result = _.unique<SampleObject>(array);
+        result = _.unique<SampleObject>(array, true);
+        result = _.unique<SampleObject>(array, true, listIterator);
+        result = _.unique<SampleObject>(array, true, listIterator, any);
+        result = _.unique<SampleObject, number>(array, true, listIterator);
+        result = _.unique<SampleObject, number>(array, true, listIterator, any);
+        result = _.unique<SampleObject>(array, listIterator);
+        result = _.unique<SampleObject>(array, listIterator, any);
+        result = _.unique<SampleObject, number>(array, listIterator);
+        result = _.unique<SampleObject, number>(array, listIterator, any);
+        result = _.unique<SampleObject>(array, true, 'a');
+        result = _.unique<SampleObject>(array, true, 'a', any);
+        result = _.unique<SampleObject>(array, 'a');
+        result = _.unique<SampleObject>(array, 'a', any);
+        result = _.unique<SampleObject>(array, true, {a: 42});
+        result = _.unique<{a: number}, SampleObject>(array, true, {a: 42});
+        result = _.unique<SampleObject>(array, {a: 42});
+        result = _.unique<{a: number}, SampleObject>(array, {a: 42});
+
+        result = _.unique<SampleObject>(list);
+        result = _.unique<SampleObject>(list, true);
+        result = _.unique<SampleObject>(list, true, listIterator);
+        result = _.unique<SampleObject>(list, true, listIterator, any);
+        result = _.unique<SampleObject, number>(list, true, listIterator);
+        result = _.unique<SampleObject, number>(list, true, listIterator, any);
+        result = _.unique<SampleObject>(list, listIterator);
+        result = _.unique<SampleObject>(list, listIterator, any);
+        result = _.unique<SampleObject, number>(list, listIterator);
+        result = _.unique<SampleObject, number>(list, listIterator, any);
+        result = _.unique<SampleObject>(list, true, 'a');
+        result = _.unique<SampleObject>(list, true, 'a', any);
+        result = _.unique<SampleObject>(list, 'a');
+        result = _.unique<SampleObject>(list, 'a', any);
+        result = _.unique<SampleObject>(list, true, {a: 42});
+        result = _.unique<{a: number}, SampleObject>(list, true, {a: 42});
+        result = _.unique<SampleObject>(list, {a: 42});
+        result = _.unique<{a: number}, SampleObject>(list, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('abc').unique();
+        result = _('abc').unique(true);
+        result = _('abc').unique<string>(true, stringIterator);
+        result = _('abc').unique<string>(true, stringIterator, any);
+        result = _('abc').unique<string>(stringIterator);
+        result = _('abc').unique<string>(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<SampleObject>;
+
+        result = _(array).unique();
+        result = _(array).unique(true);
+        result = _(array).unique<number>(true, listIterator);
+        result = _(array).unique<number>(true, listIterator, any);
+        result = _(array).unique<number>(listIterator);
+        result = _(array).unique<number>(listIterator, any);
+        result = _(array).unique(true, 'a');
+        result = _(array).unique(true, 'a', any);
+        result = _(array).unique('a');
+        result = _(array).unique('a', any);
+        result = _(array).unique<{a: number}>(true, {a: 42});
+        result = _(array).unique<{a: number}>({a: 42});
+
+        result = _(list).unique<SampleObject>();
+        result = _(list).unique<SampleObject>(true);
+        result = _(list).unique<SampleObject>(true, listIterator);
+        result = _(list).unique<SampleObject>(true, listIterator, any);
+        result = _(list).unique<SampleObject, number>(true, listIterator);
+        result = _(list).unique<SampleObject, number>(true, listIterator, any);
+        result = _(list).unique<SampleObject>(listIterator);
+        result = _(list).unique<SampleObject>(listIterator, any);
+        result = _(list).unique<SampleObject, number>(listIterator);
+        result = _(list).unique<SampleObject, number>(listIterator, any);
+        result = _(list).unique<SampleObject>(true, 'a');
+        result = _(list).unique<SampleObject>(true, 'a', any);
+        result = _(list).unique<SampleObject>('a');
+        result = _(list).unique<SampleObject>('a', any);
+        result = _(list).unique<SampleObject>(true, {a: 42});
+        result = _(list).unique<{a: number}, SampleObject>(true, {a: 42});
+        result = _(list).unique<SampleObject>({a: 42});
+        result = _(list).unique<{a: number}, SampleObject>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _('abc').chain().unique();
+        result = _('abc').chain().unique(true);
+        result = _('abc').chain().unique<string>(true, stringIterator);
+        result = _('abc').chain().unique<string>(true, stringIterator, any);
+        result = _('abc').chain().unique<string>(stringIterator);
+        result = _('abc').chain().unique<string>(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<SampleObject>;
+
+        result = _(array).chain().unique();
+        result = _(array).chain().unique(true);
+        result = _(array).chain().unique<number>(true, listIterator);
+        result = _(array).chain().unique<number>(true, listIterator, any);
+        result = _(array).chain().unique<number>(listIterator);
+        result = _(array).chain().unique<number>(listIterator, any);
+        result = _(array).chain().unique(true, 'a');
+        result = _(array).chain().unique(true, 'a', any);
+        result = _(array).chain().unique('a');
+        result = _(array).chain().unique('a', any);
+        result = _(array).chain().unique<{a: number}>(true, {a: 42});
+        result = _(array).chain().unique<{a: number}>({a: 42});
+
+        result = _(list).chain().unique<SampleObject>();
+        result = _(list).chain().unique<SampleObject>(true);
+        result = _(list).chain().unique<SampleObject>(true, listIterator);
+        result = _(list).chain().unique<SampleObject>(true, listIterator, any);
+        result = _(list).chain().unique<SampleObject, number>(true, listIterator);
+        result = _(list).chain().unique<SampleObject, number>(true, listIterator, any);
+        result = _(list).chain().unique<SampleObject>(listIterator);
+        result = _(list).chain().unique<SampleObject>(listIterator, any);
+        result = _(list).chain().unique<SampleObject, number>(listIterator);
+        result = _(list).chain().unique<SampleObject, number>(listIterator, any);
+        result = _(list).chain().unique<SampleObject>(true, 'a');
+        result = _(list).chain().unique<SampleObject>(true, 'a', any);
+        result = _(list).chain().unique<SampleObject>('a');
+        result = _(list).chain().unique<SampleObject>('a', any);
+        result = _(list).chain().unique<SampleObject>(true, {a: 42});
+        result = _(list).chain().unique<{a: number}, SampleObject>(true, {a: 42});
+        result = _(list).chain().unique<SampleObject>({a: 42});
+        result = _(list).chain().unique<{a: number}, SampleObject>({a: 42});
+    }
+}
+
+// _.upzip
+module TestUnzip {
+    let array = [['a', 'b'], [1, 2], [true, false]];
+
+    let list: _.List<_.List<string|number|boolean>> = {
+        0: {0: 'a', 1: 'b', length: 2},
+        1: {0: 1, 1: 2, length: 2},
+        2: {0: true, 1: false, length: 2},
+        length: 3
+    };
+
+    {
+        let result: (string|number|boolean)[][];
+
+        result = _.unzip<string|number|boolean>(array);
+        result = _.unzip<string|number|boolean>(list);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<(string|number|boolean)[]>;
+
+        result = _(array).unzip<string|number|boolean>();
+        result = _(list).unzip<string|number|boolean>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<(string|number|boolean)[]>;
+
+        result = _(array).chain().unzip<string|number|boolean>();
+        result = _(list).chain().unzip<string|number|boolean>();
+    }
+}
+
+// _.unzipWith
+{
+    let testUnzipWithArray: (number[]|_.List<number>)[];
+    let testUnzipWithList: _.List<number[]|_.List<number>>;
+    let testUnzipWithIterator: {(prev: TResult, curr: number, index?: number, list?: number[]): TResult};
+    let result: TResult[];
+    result = _.unzipWith<number, TResult>(testUnzipWithArray);
+    result = _.unzipWith<number, TResult>(testUnzipWithArray, testUnzipWithIterator);
+    result = _.unzipWith<number, TResult>(testUnzipWithArray, testUnzipWithIterator, any);
+    result = _.unzipWith<number, TResult>(testUnzipWithList);
+    result = _.unzipWith<number, TResult>(testUnzipWithList, testUnzipWithIterator);
+    result = _.unzipWith<number, TResult>(testUnzipWithList, testUnzipWithIterator, any);
+    result = _(testUnzipWithArray).unzipWith<number, TResult>(testUnzipWithIterator).value();
+    result = _(testUnzipWithArray).unzipWith<number, TResult>(testUnzipWithIterator, any).value();
+    result = _(testUnzipWithList).unzipWith<number, TResult>(testUnzipWithIterator).value();
+    result = _(testUnzipWithList).unzipWith<number, TResult>(testUnzipWithIterator, any).value();
+}
+
+// _.without
+module TestWithout {
+    let array: number[];
+    let list: _.List<number>;
+
+    {
+        let result: number[];
+
+        result = _.without<number>(array);
+        result = _.without<number>(array, 1);
+        result = _.without<number>(array, 1, 2);
+        result = _.without<number>(array, 1, 2, 3);
+
+        result = _.without<number>(list);
+        result = _.without<number>(list, 1);
+        result = _.without<number>(list, 1, 2);
+        result = _.without<number>(list, 1, 2, 3);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<number>;
+
+        result = _(array).without();
+        result = _(array).without(1);
+        result = _(array).without(1, 2);
+        result = _(array).without(1, 2, 3);
+        result = _(list).without<number>();
+        result = _(list).without<number>(1);
+        result = _(list).without<number>(1, 2);
+        result = _(list).without<number>(1, 2, 3);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<number>;
+
+        result = _(array).chain().without();
+        result = _(array).chain().without(1);
+        result = _(array).chain().without(1, 2);
+        result = _(array).chain().without(1, 2, 3);
+
+        result = _(list).chain().without<number>();
+        result = _(list).chain().without<number>(1);
+        result = _(list).chain().without<number>(1, 2);
+        result = _(list).chain().without<number>(1, 2, 3);
+    }
+}
+
+// _.xor
+module TestXor {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.xor<TResult>();
+
+        result = _.xor<TResult>(array);
+        result = _.xor<TResult>(array, list);
+        result = _.xor<TResult>(array, list, array);
+
+        result = _.xor<TResult>(list);
+        result = _.xor<TResult>(list, array);
+        result = _.xor<TResult>(list, array, list);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).xor();
+        result = _(array).xor(list);
+        result = _(array).xor(list, array);
+
+        result = _(list).xor<TResult>();
+        result = _(list).xor<TResult>(array);
+        result = _(list).xor<TResult>(array, list);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().xor();
+        result = _(array).chain().xor(list);
+        result = _(array).chain().xor(list, array);
+
+        result = _(list).chain().xor<TResult>();
+        result = _(list).chain().xor<TResult>(array);
+        result = _(list).chain().xor<TResult>(array, list);
+    }
+}
+
+// _.zip
+module TestZip {
+    let array: TResult[];
+    let list: _.List<TResult>;
+
+    {
+        let result: TResult[][];
+
+        result = _.zip<TResult>(array);
+        result = _.zip<TResult>(array, list);
+        result = _.zip<TResult>(array, list, array);
+
+        result = _.zip<TResult>(list);
+        result = _.zip<TResult>(list, array);
+        result = _.zip<TResult>(list, array, list);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult[]>;
+
+        result = _(array).zip<TResult>(list);
+        result = _(array).zip<TResult>(list, array);
+
+        result = _(list).zip<TResult>(array);
+        result = _(list).zip<TResult>(array, list);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult[]>;
+
+        result = _(array).chain().zip<TResult>(list);
+        result = _(array).chain().zip<TResult>(list, array);
+
+        result = _(list).chain().zip<TResult>(array);
+        result = _(list).chain().zip<TResult>(array, list);
+    }
+}
+
+// _.zipObject
+module TestZipObject {
+    let arrayOfKeys: string[];
+    let arrayOfValues: number[];
+    let arrayOfKeyValuePairs: (string|number)[][]
+
+    let listOfKeys: _.List<string>;
+    let listOfValues: _.List<number>;
+    let listOfKeyValuePairs: _.List<_.List<string|number>>;
+
+    {
+        let result: _.Dictionary<void>;
+
+        result = _.zipObject<_.Dictionary<void>>(arrayOfKeys);
+        result = _.zipObject<_.Dictionary<void>>(listOfKeys);
+    }
+
+    {
+        let result: _.Dictionary<number>;
+
+        result = _.zipObject<_.Dictionary<number>>(arrayOfKeys, arrayOfValues);
+        result = _.zipObject<_.Dictionary<number>>(arrayOfKeys, listOfValues);
+        result = _.zipObject<_.Dictionary<number>>(listOfKeys, listOfValues);
+        result = _.zipObject<_.Dictionary<number>>(listOfKeys, arrayOfValues);
+
+        result = _.zipObject<number, _.Dictionary<number>>(arrayOfKeys, arrayOfValues);
+        result = _.zipObject<number, _.Dictionary<number>>(arrayOfKeys, listOfValues);
+        result = _.zipObject<number, _.Dictionary<number>>(listOfKeys, listOfValues);
+        result = _.zipObject<number, _.Dictionary<number>>(listOfKeys, arrayOfValues);
+
+        result = _.zipObject<_.Dictionary<number>>(arrayOfKeyValuePairs);
+        result = _.zipObject<_.Dictionary<number>>(listOfKeyValuePairs);
+    }
+
+    {
+        let result: _.Dictionary<any>;
+
+        result = _.zipObject(arrayOfKeys);
+        result = _.zipObject(arrayOfKeys, arrayOfValues);
+        result = _.zipObject(arrayOfKeys, listOfValues);
+
+        result = _.zipObject(listOfKeys);
+        result = _.zipObject(listOfKeys, listOfValues);
+        result = _.zipObject(listOfKeys, arrayOfValues);
+
+        result = _.zipObject<_.Dictionary<number>>(arrayOfKeyValuePairs);
+        result = _.zipObject<_.Dictionary<number>>(listOfKeyValuePairs);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<void>>;
+
+        result = _(arrayOfKeys).zipObject<_.Dictionary<void>>();
+        result = _(listOfKeys).zipObject<_.Dictionary<void>>();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _(arrayOfKeys).zipObject<_.Dictionary<number>>(arrayOfValues);
+        result = _(arrayOfKeys).zipObject<_.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).zipObject<_.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).zipObject<_.Dictionary<number>>(arrayOfValues);
+
+        result = _(arrayOfKeys).zipObject<number, _.Dictionary<number>>(arrayOfValues);
+        result = _(arrayOfKeys).zipObject<number, _.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).zipObject<number, _.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).zipObject<number, _.Dictionary<number>>(arrayOfValues);
+
+        result = _(listOfKeys).zipObject<_.Dictionary<number>>(arrayOfKeyValuePairs);
+        result = _(listOfKeys).zipObject<_.Dictionary<number>>(listOfKeyValuePairs);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
+
+        result = _(arrayOfKeys).zipObject();
+        result = _(arrayOfKeys).zipObject(arrayOfValues);
+        result = _(arrayOfKeys).zipObject(listOfValues);
+
+        result = _(listOfKeys).zipObject();
+        result = _(listOfKeys).zipObject(listOfValues);
+        result = _(listOfKeys).zipObject(arrayOfValues);
+
+        result = _(listOfKeys).zipObject(arrayOfKeyValuePairs);
+        result = _(listOfKeys).zipObject(listOfKeyValuePairs);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<void>>;
+
+        result = _(arrayOfKeys).chain().zipObject<_.Dictionary<void>>();
+        result = _(listOfKeys).chain().zipObject<_.Dictionary<void>>();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _(arrayOfKeys).chain().zipObject<_.Dictionary<number>>(arrayOfValues);
+        result = _(arrayOfKeys).chain().zipObject<_.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).chain().zipObject<_.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).chain().zipObject<_.Dictionary<number>>(arrayOfValues);
+
+        result = _(arrayOfKeys).chain().zipObject<number, _.Dictionary<number>>(arrayOfValues);
+        result = _(arrayOfKeys).chain().zipObject<number, _.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).chain().zipObject<number, _.Dictionary<number>>(listOfValues);
+        result = _(listOfKeys).chain().zipObject<number, _.Dictionary<number>>(arrayOfValues);
+
+        result = _(listOfKeys).chain().zipObject<_.Dictionary<number>>(arrayOfKeyValuePairs);
+        result = _(listOfKeys).chain().zipObject<_.Dictionary<number>>(listOfKeyValuePairs);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<any>>;
+
+        result = _(arrayOfKeys).chain().zipObject();
+        result = _(arrayOfKeys).chain().zipObject(arrayOfValues);
+        result = _(arrayOfKeys).chain().zipObject(listOfValues);
+
+        result = _(listOfKeys).chain().zipObject();
+        result = _(listOfKeys).chain().zipObject(listOfValues);
+        result = _(listOfKeys).chain().zipObject(arrayOfValues);
+
+        result = _(listOfKeys).chain().zipObject(arrayOfKeyValuePairs);
+        result = _(listOfKeys).chain().zipObject(listOfKeyValuePairs);
+    }
+}
+
+// _.zipWith
+interface TestZipWithFn {
+    (a1: number, a2: number): number;
+}
+var testZipWithFn: TestZipWithFn;
+result = <number[]>_.zipWith<number>([1, 2]);
+result = <number[]>_.zipWith<number>([1, 2], testZipWithFn);
+result = <number[]>_.zipWith<number>([1, 2], testZipWithFn, any);
+result = <number[]>_.zipWith<number>([1, 2], [1, 2], testZipWithFn, any);
+result = <number[]>_.zipWith<number>([1, 2], [1, 2], [1, 2], [1, 2], [1, 2], [1, 2], testZipWithFn, any);
+result = <number[]>_([1, 2]).zipWith<number>().value();
+result = <number[]>_([1, 2]).zipWith<number>(testZipWithFn).value();
+result = <number[]>_([1, 2]).zipWith<number>(testZipWithFn, any).value();
+result = <number[]>_([1, 2]).zipWith<number>([1, 2], testZipWithFn, any).value();
+result = <number[]>_([1, 2]).zipWith<number>([1, 2], [1, 2], [1, 2], [1, 2], [1, 2], testZipWithFn, any).value();
+
+/*********
+ * 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
+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
+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();
+    }
+}
+
+// _.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
+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<{}>({});
+    }
+}
+
+// _.prototype.reverse
+module TestReverse {
+    {
+        let result: _.LoDashImplicitArrayWrapper<number>;
+        result: _([42]).reverse();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<number>;
+        result: _([42]).chain().reverse();
+    }
+}
+
+// _.prototype.run
+module TestRun {
+    {
+        let result: string;
+
+        result = _('').run();
+        result = _('').chain().run();
+    }
+
+    {
+        let result: number;
+
+        result = _(42).run();
+        result = _(42).chain().run();
+    }
+
+    {
+        let result: boolean;
+
+        result = _(true).run();
+        result = _(true).chain().run();
+    }
+
+    {
+        let result: string[];
+
+        result = _<string>([]).run();
+        result = _<string>([]).chain().run();
+    }
+
+    {
+        let result: {a: string};
+
+        result = _({a: ''}).run();
+        result = _({a: ''}).chain().run();
+    }
+}
+
+// _.prototype.toJSON
+module TestToJSON {
+    {
+        let result: string;
+
+        result = _('').toJSON();
+        result = _('').chain().toJSON();
+    }
+
+    {
+        let result: number;
+
+        result = _(42).toJSON();
+        result = _(42).chain().toJSON();
+    }
+
+    {
+        let result: boolean;
+
+        result = _(true).toJSON();
+        result = _(true).chain().toJSON();
+    }
+
+    {
+        let result: string[];
+
+        result = _<string>([]).toJSON();
+        result = _<string>([]).chain().toJSON();
+    }
+
+    {
+        let result: {a: string};
+
+        result = _({a: ''}).toJSON();
+        result = _({a: ''}).chain().toJSON();
+    }
+}
+
+// _.prototype.toString
+module TestToString {
+    let result: string;
+
+    result = _('').toString();
+    result = _(42).toString();
+    result = _(true).toString();
+    result = _<string>(['']).toString();
+    result = _({}).toString();
+
+    result = _('').chain().toString();
+    result = _(42).chain().toString();
+    result = _(true).chain().toString();
+    result = _<string>(['']).chain().toString();
+    result = _({}).chain().toString();
+}
+
+// _.prototype.value
+module TestValue {
+    {
+        let result: string;
+
+        result = _('').value();
+        result = _('').chain().value();
+    }
+
+    {
+        let result: number;
+
+        result = _(42).value();
+        result = _(42).chain().value();
+    }
+
+    {
+        let result: boolean;
+
+        result = _(true).value();
+        result = _(true).chain().value();
+    }
+
+    {
+        let result: string[];
+
+        result = _<string>([]).value();
+        result = _<string>([]).chain().value();
+    }
+
+    {
+        let result: {a: string};
+
+        result = _({a: ''}).value();
+        result = _({a: ''}).chain().value();
+    }
+}
+
+// _.prototype.valueOf
+module TestValueOf {
+    {
+        let result: string;
+
+        result = _('').valueOf();
+        result = _('').chain().valueOf();
+    }
+
+    {
+        let result: number;
+
+        result = _(42).valueOf();
+        result = _(42).chain().valueOf();
+    }
+
+    {
+        let result: boolean;
+
+        result = _(true).valueOf();
+        result = _(true).chain().valueOf();
+    }
+
+    {
+        let result: string[];
+
+        result = _<string>([]).valueOf();
+        result = _<string>([]).chain().valueOf();
+    }
+
+    {
+        let result: {a: string};
+
+        result = _({a: ''}).valueOf();
+        result = _({a: ''}).chain().valueOf();
+    }
+}
+
+/**************
+ * Collection *
+ **************/
+
+// _.all
+module TestAll {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => boolean;
+
+    {
+        let result: boolean;
+
+        result = _.all<TResult>(array);
+        result = _.all<TResult>(array, listIterator);
+        result = _.all<TResult>(array, listIterator, any);
+        result = _.all<TResult>(array, '');
+        result = _.all<{a: number}, TResult>(array, {a: 42});
+
+        result = _.all<TResult>(list);
+        result = _.all<TResult>(list, listIterator);
+        result = _.all<TResult>(list, listIterator, any);
+        result = _.all<TResult>(list, '');
+        result = _.all<{a: number}, TResult>(list, {a: 42});
+
+        result = _.all<TResult>(dictionary);
+        result = _.all<TResult>(dictionary, dictionaryIterator);
+        result = _.all<TResult>(dictionary, dictionaryIterator, any);
+        result = _.all<TResult>(dictionary, '');
+        result = _.all<{a: number}, TResult>(dictionary, {a: 42});
+
+        result = _(array).all();
+        result = _(array).all(listIterator);
+        result = _(array).all(listIterator, any);
+        result = _(array).all('');
+        result = _(array).all<{a: number}>({a: 42});
+
+        result = _(list).all<TResult>();
+        result = _(list).all<TResult>(listIterator);
+        result = _(list).all<TResult>(listIterator, any);
+        result = _(list).all('');
+        result = _(list).all<{a: number}>({a: 42});
+
+        result = _(dictionary).all<TResult>();
+        result = _(dictionary).all<TResult>(dictionaryIterator);
+        result = _(dictionary).all<TResult>(dictionaryIterator, any);
+        result = _(dictionary).all('');
+        result = _(dictionary).all<{a: number}>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(array).chain().all();
+        result = _(array).chain().all(listIterator);
+        result = _(array).chain().all(listIterator, any);
+        result = _(array).chain().all('');
+        result = _(array).chain().all<{a: number}>({a: 42});
+
+        result = _(list).chain().all<TResult>();
+        result = _(list).chain().all<TResult>(listIterator);
+        result = _(list).chain().all<TResult>(listIterator, any);
+        result = _(list).chain().all('');
+        result = _(list).chain().all<{a: number}>({a: 42});
+
+        result = _(dictionary).chain().all<TResult>();
+        result = _(dictionary).chain().all<TResult>(dictionaryIterator);
+        result = _(dictionary).chain().all<TResult>(dictionaryIterator, any);
+        result = _(dictionary).chain().all('');
+        result = _(dictionary).chain().all<{a: number}>({a: 42});
+    }
+}
+
+// _.any
+module TestAny {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+    let numericDictionary: _.NumericDictionary<TResult>;
+
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => boolean;
+    let numericDictionaryIterator: (value: TResult, key: number, collection: _.NumericDictionary<TResult>) => boolean;
+
+    {
+        let result: boolean;
+
+        result = _.any<TResult>(array);
+        result = _.any<TResult>(array, listIterator);
+        result = _.any<TResult>(array, listIterator, any);
+        result = _.any<TResult>(array, '');
+        result = _.any<{a: number}, TResult>(array, {a: 42});
+
+        result = _.any<TResult>(list);
+        result = _.any<TResult>(list, listIterator);
+        result = _.any<TResult>(list, listIterator, any);
+        result = _.any<TResult>(list, '');
+        result = _.any<{a: number}, TResult>(list, {a: 42});
+
+        result = _.any<TResult>(dictionary);
+        result = _.any<TResult>(dictionary, dictionaryIterator);
+        result = _.any<TResult>(dictionary, dictionaryIterator, any);
+        result = _.any<TResult>(dictionary, '');
+        result = _.any<{a: number}, TResult>(dictionary, {a: 42});
+
+        result = _.any<TResult>(numericDictionary);
+        result = _.any<TResult>(numericDictionary, numericDictionaryIterator);
+        result = _.any<TResult>(numericDictionary, numericDictionaryIterator, any);
+        result = _.any<TResult>(numericDictionary, '');
+        result = _.any<{a: number}, TResult>(numericDictionary, {a: 42});
+
+        result = _(array).any();
+        result = _(array).any(listIterator);
+        result = _(array).any(listIterator, any);
+        result = _(array).any('');
+        result = _(array).any<{a: number}>({a: 42});
+
+        result = _(list).any<TResult>();
+        result = _(list).any<TResult>(listIterator);
+        result = _(list).any<TResult>(listIterator, any);
+        result = _(list).any('');
+        result = _(list).any<{a: number}>({a: 42});
+
+        result = _(dictionary).any<TResult>();
+        result = _(dictionary).any<TResult>(dictionaryIterator);
+        result = _(dictionary).any<TResult>(dictionaryIterator, any);
+        result = _(dictionary).any('');
+        result = _(dictionary).any<{a: number}>({a: 42});
+
+        result = _(numericDictionary).any<TResult>();
+        result = _(numericDictionary).any<TResult>(numericDictionaryIterator);
+        result = _(numericDictionary).any<TResult>(numericDictionaryIterator, any);
+        result = _(numericDictionary).any('');
+        result = _(numericDictionary).any<{a: number}>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(array).chain().any();
+        result = _(array).chain().any(listIterator);
+        result = _(array).chain().any(listIterator, any);
+        result = _(array).chain().any('');
+        result = _(array).chain().any<{a: number}>({a: 42});
+
+        result = _(list).chain().any<TResult>();
+        result = _(list).chain().any<TResult>(listIterator);
+        result = _(list).chain().any<TResult>(listIterator, any);
+        result = _(list).chain().any('');
+        result = _(list).chain().any<{a: number}>({a: 42});
+
+        result = _(dictionary).chain().any<TResult>();
+        result = _(dictionary).chain().any<TResult>(dictionaryIterator);
+        result = _(dictionary).chain().any<TResult>(dictionaryIterator, any);
+        result = _(dictionary).chain().any('');
+        result = _(dictionary).chain().any<{a: number}>({a: 42});
+
+        result = _(numericDictionary).chain().any<TResult>();
+        result = _(numericDictionary).chain().any<TResult>(numericDictionaryIterator);
+        result = _(numericDictionary).chain().any<TResult>(numericDictionaryIterator, any);
+        result = _(numericDictionary).chain().any('');
+        result = _(numericDictionary).chain().any<{a: number}>({a: 42});
+    }
+}
+
+// _.at
+module TestAt {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.at<TResult>(array, 0, '1', [2], ['3'], [4, '5']);
+        result = _.at<TResult>(list, 0, '1', [2], ['3'], [4, '5']);
+        result = _.at<TResult>(dictionary, 0, '1', [2], ['3'], [4, '5']);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).at(0, '1', [2], ['3'], [4, '5']);
+        result = _(list).at<TResult>(0, '1', [2], ['3'], [4, '5']);
+        result = _(dictionary).at<TResult>(0, '1', [2], ['3'], [4, '5']);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().at(0, '1', [2], ['3'], [4, '5']);
+        result = _(list).chain().at<TResult>(0, '1', [2], ['3'], [4, '5']);
+        result = _(dictionary).chain().at<TResult>(0, '1', [2], ['3'], [4, '5']);
+    }
+}
+
+// _.collect
+module TestCollect {
+    let array: number[];
+    let list: _.List<number>;
+    let dictionary: _.Dictionary<number>;
+
+    let listIterator: (value: number, index: number, collection: _.List<number>) => TResult;
+    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => TResult;
+
+    {
+        let result: TResult[];
+
+        result = _.collect<number, TResult>(array);
+        result = _.collect<number, TResult>(array, listIterator);
+        result = _.collect<number, TResult>(array, listIterator, any);
+        result = _.collect<number, TResult>(array, '');
+
+        result = _.collect<number, TResult>(list);
+        result = _.collect<number, TResult>(list, listIterator);
+        result = _.collect<number, TResult>(list, listIterator, any);
+        result = _.collect<number, TResult>(list, '');
+
+        result = _.collect<number, TResult>(dictionary);
+        result = _.collect<number, TResult>(dictionary, dictionaryIterator);
+        result = _.collect<number, TResult>(dictionary, dictionaryIterator, any);
+        result = _.collect<number, TResult>(dictionary, '');
+    }
+
+    {
+        let result: boolean[];
+
+        result = _.collect<number, {}>(array, {});
+        result = _.collect<number, {}>(list, {});
+        result = _.collect<number, {}>(dictionary, {});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _<number>(array).collect<TResult>();
+        result = _<number>(array).collect<TResult>(listIterator);
+        result = _<number>(array).collect<TResult>(listIterator, any);
+        result = _<number>(array).collect<TResult>('');
+
+        result = _(list).collect<number, TResult>();
+        result = _(list).collect<number, TResult>(listIterator);
+        result = _(list).collect<number, TResult>(listIterator, any);
+        result = _(list).collect<number, TResult>('');
+
+        result = _(dictionary).collect<number, TResult>();
+        result = _(dictionary).collect<number, TResult>(dictionaryIterator);
+        result = _(dictionary).collect<number, TResult>(dictionaryIterator, any);
+        result = _(dictionary).collect<number, TResult>('');
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<boolean>;
+
+        result = _<number>(array).collect<{}>({});
+        result = _(list).collect<{}>({});
+        result = _(dictionary).collect<{}>({});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _<number>(array).chain().collect<TResult>();
+        result = _<number>(array).chain().collect<TResult>(listIterator);
+        result = _<number>(array).chain().collect<TResult>(listIterator, any);
+        result = _<number>(array).chain().collect<TResult>('');
+
+        result = _(list).chain().collect<number, TResult>();
+        result = _(list).chain().collect<number, TResult>(listIterator);
+        result = _(list).chain().collect<number, TResult>(listIterator, any);
+        result = _(list).chain().collect<number, TResult>('');
+
+        result = _(dictionary).chain().collect<number, TResult>();
+        result = _(dictionary).chain().collect<number, TResult>(dictionaryIterator);
+        result = _(dictionary).chain().collect<number, TResult>(dictionaryIterator, any);
+        result = _(dictionary).chain().collect<number, TResult>('');
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<boolean>;
+
+        result = _<number>(array).chain().collect<{}>({});
+        result = _(list).chain().collect<{}>({});
+        result = _(dictionary).chain().collect<{}>({});
+    }
+}
+
+// _.contains
+module TestContains {
+    type SampleType = {a: string; b: number; c: boolean;};
+
+    let array: SampleType[];
+    let list: _.List<SampleType>;
+    let dictionary: _.Dictionary<SampleType>;
+
+    let target: SampleType;
+
+    {
+        let result: boolean;
+
+        result = _.contains<SampleType>(array, target);
+        result = _.contains<SampleType>(array, target, 42);
+
+        result = _.contains<SampleType>(list, target);
+        result = _.contains<SampleType>(list, target, 42);
+
+        result = _.contains<SampleType>(dictionary, target);
+        result = _.contains<SampleType>(dictionary, target, 42);
+
+        result = _(array).contains(target);
+        result = _(array).contains(target, 42);
+
+        result = _(list).contains<SampleType>(target);
+        result = _(list).contains<SampleType>(target, 42);
+
+        result = _(dictionary).contains<SampleType>(target);
+        result = _(dictionary).contains<SampleType>(target, 42);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(array).chain().contains(target);
+        result = _(array).chain().contains(target, 42);
+
+        result = _(list).chain().contains<SampleType>(target);
+        result = _(list).chain().contains<SampleType>(target, 42);
+
+        result = _(dictionary).chain().contains<SampleType>(target);
+        result = _(dictionary).chain().contains<SampleType>(target, 42);
+    }
+}
+
+// _.countBy
+module TestCountBy {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+    let numericDictionary: _.NumericDictionary<TResult>;
+
+    let stringIterator: (value: string, index: number, collection: string) => any;
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => any;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => any;
+    let numericDictionaryIterator: (value: TResult, key: number, collection: _.NumericDictionary<TResult>) => any;
+
+    {
+        let result: _.Dictionary<number>;
+
+        result = _.countBy<string>('');
+        result = _.countBy<string>('', stringIterator);
+        result = _.countBy<string>('', stringIterator, any);
+
+        result = _.countBy<TResult>(array);
+        result = _.countBy<TResult>(array, listIterator);
+        result = _.countBy<TResult>(array, listIterator, any);
+        result = _.countBy<TResult>(array, '');
+        result = _.countBy<TResult>(array, '', any);
+        result = _.countBy<{a: number}, TResult>(array, {a: 42});
+        result = _.countBy<TResult>(array, {a: 42});
+
+        result = _.countBy<TResult>(list);
+        result = _.countBy<TResult>(list, listIterator);
+        result = _.countBy<TResult>(list, listIterator, any);
+        result = _.countBy<TResult>(list, '');
+        result = _.countBy<TResult>(list, '', any);
+        result = _.countBy<{a: number}, TResult>(list, {a: 42});
+        result = _.countBy<TResult>(list, {a: 42});
+
+        result = _.countBy<TResult>(dictionary);
+        result = _.countBy<TResult>(dictionary, dictionaryIterator);
+        result = _.countBy<TResult>(dictionary, dictionaryIterator, any);
+        result = _.countBy<TResult>(dictionary, '');
+        result = _.countBy<TResult>(dictionary, '', any);
+        result = _.countBy<{a: number}, TResult>(dictionary, {a: 42});
+        result = _.countBy<TResult>(dictionary, {a: 42});
+
+        result = _.countBy<TResult>(numericDictionary);
+        result = _.countBy<TResult>(numericDictionary, numericDictionaryIterator);
+        result = _.countBy<TResult>(numericDictionary, numericDictionaryIterator, any);
+        result = _.countBy<TResult>(numericDictionary, '');
+        result = _.countBy<TResult>(numericDictionary, '', any);
+        result = _.countBy<{a: number}, TResult>(numericDictionary, {a: 42});
+        result = _.countBy<TResult>(numericDictionary, {a: 42});
+    }
+
+    {
+        let resutl: _.LoDashImplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _('').countBy();
+        result = _('').countBy(stringIterator);
+        result = _('').countBy(stringIterator, any);
+
+        result = _(array).countBy();
+        result = _(array).countBy(listIterator);
+        result = _(array).countBy(listIterator, any);
+        result = _(array).countBy('');
+        result = _(array).countBy('', any);
+        result = _(array).countBy<{a: number}>({a: 42});
+        result = _(array).countBy({a: 42});
+
+        result = _(list).countBy();
+        result = _(list).countBy<TResult>(listIterator);
+        result = _(list).countBy<TResult>(listIterator, any);
+        result = _(list).countBy('');
+        result = _(list).countBy('', any);
+        result = _(list).countBy<{a: number}>({a: 42});
+        result = _(list).countBy({a: 42});
+
+        result = _(dictionary).countBy();
+        result = _(dictionary).countBy<TResult>(dictionaryIterator);
+        result = _(dictionary).countBy<TResult>(dictionaryIterator, any);
+        result = _(dictionary).countBy('');
+        result = _(dictionary).countBy('', any);
+        result = _(dictionary).countBy<{a: number}>({a: 42});
+        result = _(dictionary).countBy({a: 42});
+
+        result = _(numericDictionary).countBy();
+        result = _(numericDictionary).countBy<TResult>(numericDictionaryIterator);
+        result = _(numericDictionary).countBy<TResult>(numericDictionaryIterator, any);
+        result = _(numericDictionary).countBy('');
+        result = _(numericDictionary).countBy('', any);
+        result = _(numericDictionary).countBy<{a: number}>({a: 42});
+        result = _(numericDictionary).countBy({a: 42});
+    }
+
+    {
+        let resutl: _.LoDashExplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _('').chain().countBy();
+        result = _('').chain().countBy(stringIterator);
+        result = _('').chain().countBy(stringIterator, any);
+
+        result = _(array).chain().countBy();
+        result = _(array).chain().countBy(listIterator);
+        result = _(array).chain().countBy(listIterator, any);
+        result = _(array).chain().countBy('');
+        result = _(array).chain().countBy('', any);
+        result = _(array).chain().countBy<{a: number}>({a: 42});
+        result = _(array).chain().countBy({a: 42});
+
+        result = _(list).chain().countBy();
+        result = _(list).chain().countBy<TResult>(listIterator);
+        result = _(list).chain().countBy<TResult>(listIterator, any);
+        result = _(list).chain().countBy('');
+        result = _(list).chain().countBy('', any);
+        result = _(list).chain().countBy<{a: number}>({a: 42});
+        result = _(list).chain().countBy({a: 42});
+
+        result = _(dictionary).chain().countBy();
+        result = _(dictionary).chain().countBy<TResult>(dictionaryIterator);
+        result = _(dictionary).chain().countBy<TResult>(dictionaryIterator, any);
+        result = _(dictionary).chain().countBy('');
+        result = _(dictionary).chain().countBy('', any);
+        result = _(dictionary).chain().countBy<{a: number}>({a: 42});
+        result = _(dictionary).chain().countBy({a: 42});
+
+        result = _(numericDictionary).chain().countBy();
+        result = _(numericDictionary).chain().countBy<TResult>(numericDictionaryIterator);
+        result = _(numericDictionary).chain().countBy<TResult>(numericDictionaryIterator, any);
+        result = _(numericDictionary).chain().countBy('');
+        result = _(numericDictionary).chain().countBy('', any);
+        result = _(numericDictionary).chain().countBy<{a: number}>({a: 42});
+        result = _(numericDictionary).chain().countBy({a: 42});
+    }
+}
+
+// _.detect
+module TestDetect {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => boolean;
+
+    let result: TResult;
+
+    result = _.detect<TResult>(array);
+    result = _.detect<TResult>(array, listIterator);
+    result = _.detect<TResult>(array, listIterator, any);
+    result = _.detect<TResult>(array, '');
+    result = _.detect<{a: number}, TResult>(array, {a: 42});
+
+    result = _.detect<TResult>(list);
+    result = _.detect<TResult>(list, listIterator);
+    result = _.detect<TResult>(list, listIterator, any);
+    result = _.detect<TResult>(list, '');
+    result = _.detect<{a: number}, TResult>(list, {a: 42});
+
+    result = _.detect<TResult>(dictionary);
+    result = _.detect<TResult>(dictionary, dictionaryIterator);
+    result = _.detect<TResult>(dictionary, dictionaryIterator, any);
+    result = _.detect<TResult>(dictionary, '');
+    result = _.detect<{a: number}, TResult>(dictionary, {a: 42});
+
+    result = _(array).detect();
+    result = _(array).detect(listIterator);
+    result = _(array).detect(listIterator, any);
+    result = _(array).detect('');
+    result = _(array).detect<{a: number}>({a: 42});
+
+    result = _(list).detect<TResult>();
+    result = _(list).detect<TResult>(listIterator);
+    result = _(list).detect<TResult>(listIterator, any);
+    result = _(list).detect<TResult>('');
+    result = _(list).detect<{a: number}, TResult>({a: 42});
+
+    result = _(dictionary).detect<TResult>();
+    result = _(dictionary).detect<TResult>(dictionaryIterator);
+    result = _(dictionary).detect<TResult>(dictionaryIterator, any);
+    result = _(dictionary).detect<TResult>('');
+    result = _(dictionary).detect<{a: number}, TResult>({a: 42});
+}
+
+// _.each
+module TestEach {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let stringIterator: (char: string, index: number, string: string) => any;
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => any;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => any;
+
+    {
+        let result: string;
+
+        _.each('', stringIterator);
+        _.each('', stringIterator, any);
+    }
+
+    {
+        let result: TResult[];
+
+        _.each<TResult>(array, listIterator);
+        _.each<TResult>(array, listIterator, any);
+    }
+
+    {
+        let result: _.List<TResult>;
+
+        _.each<TResult>(list, listIterator);
+        _.each<TResult>(list, listIterator, any);
+    }
+
+    {
+        let result: _.Dictionary<TResult>;
+
+        _.each<TResult>(dictionary, dictionaryIterator);
+        _.each<TResult>(dictionary, dictionaryIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitWrapper<string>;
+
+        _('').each(stringIterator);
+        _('').each(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        _(array).each(listIterator);
+        _(array).each(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.List<TResult>>;
+
+        _(list).each<TResult>(listIterator);
+        _(list).each<TResult>(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<TResult>>;
+
+        _(dictionary).each<TResult>(dictionaryIterator);
+        _(dictionary).each<TResult>(dictionaryIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        _('').chain().each(stringIterator);
+        _('').chain().each(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        _(array).chain().each(listIterator);
+        _(array).chain().each(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.List<TResult>>;
+
+        _(list).chain().each<TResult>(listIterator);
+        _(list).chain().each<TResult>(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<TResult>>;
+
+        _(dictionary).chain().each<TResult>(dictionaryIterator);
+        _(dictionary).chain().each<TResult>(dictionaryIterator, any);
+    }
+}
+
+// _.eachRight
+module TestEachRight {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let stringIterator: (char: string, index: number, string: string) => any;
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => any;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => any;
+
+    {
+        let result: string;
+
+        _.eachRight('', stringIterator);
+        _.eachRight('', stringIterator, any);
+    }
+
+    {
+        let result: TResult[];
+
+        _.eachRight<TResult>(array, listIterator);
+        _.eachRight<TResult>(array, listIterator, any);
+    }
+
+    {
+        let result: _.List<TResult>;
+
+        _.eachRight<TResult>(list, listIterator);
+        _.eachRight<TResult>(list, listIterator, any);
+    }
+
+    {
+        let result: _.Dictionary<TResult>;
+
+        _.eachRight<TResult>(dictionary, dictionaryIterator);
+        _.eachRight<TResult>(dictionary, dictionaryIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitWrapper<string>;
+
+        _('').eachRight(stringIterator);
+        _('').eachRight(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        _(array).eachRight(listIterator);
+        _(array).eachRight(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.List<TResult>>;
+
+        _(list).eachRight<TResult>(listIterator);
+        _(list).eachRight<TResult>(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<TResult>>;
+
+        _(dictionary).eachRight<TResult>(dictionaryIterator);
+        _(dictionary).eachRight<TResult>(dictionaryIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        _('').chain().eachRight(stringIterator);
+        _('').chain().eachRight(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        _(array).chain().eachRight(listIterator);
+        _(array).chain().eachRight(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.List<TResult>>;
+
+        _(list).chain().eachRight<TResult>(listIterator);
+        _(list).chain().eachRight<TResult>(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<TResult>>;
+
+        _(dictionary).chain().eachRight<TResult>(dictionaryIterator);
+        _(dictionary).chain().eachRight<TResult>(dictionaryIterator, any);
+    }
+}
+
+// _.every
+module TestEvery {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => boolean;
+
+    {
+        let result: boolean;
+
+        result = _.every<TResult>(array);
+        result = _.every<TResult>(array, listIterator);
+        result = _.every<TResult>(array, listIterator, any);
+        result = _.every<TResult>(array, '');
+        result = _.every<{a: number}, TResult>(array, {a: 42});
+
+        result = _.every<TResult>(list);
+        result = _.every<TResult>(list, listIterator);
+        result = _.every<TResult>(list, listIterator, any);
+        result = _.every<TResult>(list, '');
+        result = _.every<{a: number}, TResult>(list, {a: 42});
+
+        result = _.every<TResult>(dictionary);
+        result = _.every<TResult>(dictionary, dictionaryIterator);
+        result = _.every<TResult>(dictionary, dictionaryIterator, any);
+        result = _.every<TResult>(dictionary, '');
+        result = _.every<{a: number}, TResult>(dictionary, {a: 42});
+
+        result = _(array).every();
+        result = _(array).every(listIterator);
+        result = _(array).every(listIterator, any);
+        result = _(array).every('');
+        result = _(array).every<{a: number}>({a: 42});
+
+        result = _(list).every<TResult>();
+        result = _(list).every<TResult>(listIterator);
+        result = _(list).every<TResult>(listIterator, any);
+        result = _(list).every('');
+        result = _(list).every<{a: number}>({a: 42});
+
+        result = _(dictionary).every<TResult>();
+        result = _(dictionary).every<TResult>(dictionaryIterator);
+        result = _(dictionary).every<TResult>(dictionaryIterator, any);
+        result = _(dictionary).every('');
+        result = _(dictionary).every<{a: number}>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(array).chain().every();
+        result = _(array).chain().every(listIterator);
+        result = _(array).chain().every(listIterator, any);
+        result = _(array).chain().every('');
+        result = _(array).chain().every<{a: number}>({a: 42});
+
+        result = _(list).chain().every<TResult>();
+        result = _(list).chain().every<TResult>(listIterator);
+        result = _(list).chain().every<TResult>(listIterator, any);
+        result = _(list).chain().every('');
+        result = _(list).chain().every<{a: number}>({a: 42});
+
+        result = _(dictionary).chain().every<TResult>();
+        result = _(dictionary).chain().every<TResult>(dictionaryIterator);
+        result = _(dictionary).chain().every<TResult>(dictionaryIterator, any);
+        result = _(dictionary).chain().every('');
+        result = _(dictionary).chain().every<{a: number}>({a: 42});
+    }
+}
+
+// _.filter
+module TestFilter {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let stringIterator: (char: string, index: number, string: string) => any;
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => any;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => any;
+
+    {
+        let result: string[];
+
+        result = _.filter('', stringIterator);
+        result = _.filter('', stringIterator, any);
+    }
+
+    {
+        let result: TResult[];
+
+        result = _.filter<TResult>(array, listIterator);
+        result = _.filter<TResult>(array, listIterator, any);
+        result = _.filter<TResult>(array, '');
+        result = _.filter<TResult>(array, '', any);
+        result = _.filter<{a: number}, TResult>(array, {a: 42});
+
+        result = _.filter<TResult>(list, listIterator);
+        result = _.filter<TResult>(list, listIterator, any);
+        result = _.filter<TResult>(list, '');
+        result = _.filter<TResult>(list, '', any);
+        result = _.filter<{a: number}, TResult>(list, {a: 42});
+
+        result = _.filter<TResult>(dictionary, dictionaryIterator);
+        result = _.filter<TResult>(dictionary, dictionaryIterator, any);
+        result = _.filter<TResult>(dictionary, '');
+        result = _.filter<TResult>(dictionary, '', any);
+        result = _.filter<{a: number}, TResult>(dictionary, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('').filter(stringIterator);
+        result = _('').filter(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).filter(listIterator);
+        result = _(array).filter(listIterator, any);
+        result = _(array).filter('');
+        result = _(array).filter('', any);
+        result = _(array).filter<{a: number}>({a: 42});
+
+        result = _(list).filter<TResult>(listIterator);
+        result = _(list).filter<TResult>(listIterator, any);
+        result = _(list).filter<TResult>('');
+        result = _(list).filter<TResult>('', any);
+        result = _(list).filter<{a: number}, TResult>({a: 42});
+
+        result = _(dictionary).filter<TResult>(dictionaryIterator);
+        result = _(dictionary).filter<TResult>(dictionaryIterator, any);
+        result = _(dictionary).filter<TResult>('');
+        result = _(dictionary).filter<TResult>('', any);
+        result = _(dictionary).filter<{a: number}, TResult>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _('').chain().filter(stringIterator);
+        result = _('').chain().filter(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().filter(listIterator);
+        result = _(array).chain().filter(listIterator, any);
+        result = _(array).chain().filter('');
+        result = _(array).chain().filter('', any);
+        result = _(array).chain().filter<{a: number}>({a: 42});
+
+        result = _(list).chain().filter<TResult>(listIterator);
+        result = _(list).chain().filter<TResult>(listIterator, any);
+        result = _(list).chain().filter<TResult>('');
+        result = _(list).chain().filter<TResult>('', any);
+        result = _(list).chain().filter<{a: number}, TResult>({a: 42});
+
+        result = _(dictionary).chain().filter<TResult>(dictionaryIterator);
+        result = _(dictionary).chain().filter<TResult>(dictionaryIterator, any);
+        result = _(dictionary).chain().filter<TResult>('');
+        result = _(dictionary).chain().filter<TResult>('', any);
+        result = _(dictionary).chain().filter<{a: number}, TResult>({a: 42});
+    }
+}
+
+// _.find
+module TestFind {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => boolean;
+
+    let result: TResult;
+
+    result = _.find<TResult>(array);
+    result = _.find<TResult>(array, listIterator);
+    result = _.find<TResult>(array, listIterator, any);
+    result = _.find<TResult>(array, '');
+    result = _.find<{a: number}, TResult>(array, {a: 42});
+
+    result = _.find<TResult>(list);
+    result = _.find<TResult>(list, listIterator);
+    result = _.find<TResult>(list, listIterator, any);
+    result = _.find<TResult>(list, '');
+    result = _.find<{a: number}, TResult>(list, {a: 42});
+
+    result = _.find<TResult>(dictionary);
+    result = _.find<TResult>(dictionary, dictionaryIterator);
+    result = _.find<TResult>(dictionary, dictionaryIterator, any);
+    result = _.find<TResult>(dictionary, '');
+    result = _.find<{a: number}, TResult>(dictionary, {a: 42});
+
+    result = _(array).find();
+    result = _(array).find(listIterator);
+    result = _(array).find(listIterator, any);
+    result = _(array).find('');
+    result = _(array).find<{a: number}>({a: 42});
+
+    result = _(list).find<TResult>();
+    result = _(list).find<TResult>(listIterator);
+    result = _(list).find<TResult>(listIterator, any);
+    result = _(list).find<TResult>('');
+    result = _(list).find<{a: number}, TResult>({a: 42});
+
+    result = _(dictionary).find<TResult>();
+    result = _(dictionary).find<TResult>(dictionaryIterator);
+    result = _(dictionary).find<TResult>(dictionaryIterator, any);
+    result = _(dictionary).find<TResult>('');
+    result = _(dictionary).find<{a: number}, TResult>({a: 42});
+}
+
+result = <number>_.findWhere([1, 2, 3, 4], function (num) {
+    return num % 2 == 0;
+});
+result = <IFoodCombined>_.findWhere(foodsCombined, { 'type': 'vegetable' });
+result = <IFoodCombined>_.findWhere(foodsCombined, 'organic');
+
+result = <number>_.findLast([1, 2, 3, 4], function (num) {
+    return num % 2 == 0;
+});
+result = <IFoodCombined>_.findLast(foodsCombined, { 'type': 'vegetable' });
+result = <IFoodCombined>_.findLast(foodsCombined, 'organic');
+
+result = <number>_([1, 2, 3, 4]).findLast(function (num) {
+    return num % 2 == 0;
+});
+result = <IFoodCombined>_(foodsCombined).findLast({ 'type': 'vegetable' });
+result = <IFoodCombined>_(foodsCombined).findLast('organic');
+
+// _.forEach
+module TestForEach {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let stringIterator: (char: string, index: number, string: string) => any;
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => any;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => any;
+
+    {
+        let result: string;
+
+        _.forEach('', stringIterator);
+        _.forEach('', stringIterator, any);
+    }
+
+    {
+        let result: TResult[];
+
+        _.forEach<TResult>(array, listIterator);
+        _.forEach<TResult>(array, listIterator, any);
+    }
+
+    {
+        let result: _.List<TResult>;
+
+        _.forEach<TResult>(list, listIterator);
+        _.forEach<TResult>(list, listIterator, any);
+    }
+
+    {
+        let result: _.Dictionary<TResult>;
+
+        _.forEach<TResult>(dictionary, dictionaryIterator);
+        _.forEach<TResult>(dictionary, dictionaryIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitWrapper<string>;
+
+        _('').forEach(stringIterator);
+        _('').forEach(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        _(array).forEach(listIterator);
+        _(array).forEach(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.List<TResult>>;
+
+        _(list).forEach<TResult>(listIterator);
+        _(list).forEach<TResult>(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<TResult>>;
+
+        _(dictionary).forEach<TResult>(dictionaryIterator);
+        _(dictionary).forEach<TResult>(dictionaryIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        _('').chain().forEach(stringIterator);
+        _('').chain().forEach(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        _(array).chain().forEach(listIterator);
+        _(array).chain().forEach(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.List<TResult>>;
+
+        _(list).chain().forEach<TResult>(listIterator);
+        _(list).chain().forEach<TResult>(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<TResult>>;
+
+        _(dictionary).chain().forEach<TResult>(dictionaryIterator);
+        _(dictionary).chain().forEach<TResult>(dictionaryIterator, any);
+    }
+}
+
+// _.forEachRight
+module TestForEachRight {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let stringIterator: (char: string, index: number, string: string) => any;
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => any;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => any;
+
+    {
+        let result: string;
+
+        _.forEachRight('', stringIterator);
+        _.forEachRight('', stringIterator, any);
+    }
+
+    {
+        let result: TResult[];
+
+        _.forEachRight<TResult>(array, listIterator);
+        _.forEachRight<TResult>(array, listIterator, any);
+    }
+
+    {
+        let result: _.List<TResult>;
+
+        _.forEachRight<TResult>(list, listIterator);
+        _.forEachRight<TResult>(list, listIterator, any);
+    }
+
+    {
+        let result: _.Dictionary<TResult>;
+
+        _.forEachRight<TResult>(dictionary, dictionaryIterator);
+        _.forEachRight<TResult>(dictionary, dictionaryIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitWrapper<string>;
+
+        _('').forEachRight(stringIterator);
+        _('').forEachRight(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        _(array).forEachRight(listIterator);
+        _(array).forEachRight(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.List<TResult>>;
+
+        _(list).forEachRight<TResult>(listIterator);
+        _(list).forEachRight<TResult>(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<TResult>>;
+
+        _(dictionary).forEachRight<TResult>(dictionaryIterator);
+        _(dictionary).forEachRight<TResult>(dictionaryIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        _('').chain().forEachRight(stringIterator);
+        _('').chain().forEachRight(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        _(array).chain().forEachRight(listIterator);
+        _(array).chain().forEachRight(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.List<TResult>>;
+
+        _(list).chain().forEachRight<TResult>(listIterator);
+        _(list).chain().forEachRight<TResult>(listIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<TResult>>;
+
+        _(dictionary).chain().forEachRight<TResult>(dictionaryIterator);
+        _(dictionary).chain().forEachRight<TResult>(dictionaryIterator, any);
+    }
+}
+
+// _.groupBy
+module TestGroupBy {
+    type SampleType = {a: number; b: string; c: boolean;};
+
+    let array: SampleType[];
+    let list: _.List<SampleType>;
+    let dictionary: _.Dictionary<SampleType>;
+
+    let stringIterator: (char: string, index: number, string: string) => number;
+    let listIterator: (value: SampleType, index: number, collection: _.List<SampleType>) => number;
+    let dictionaryIterator: (value: SampleType, key: string, collection: _.Dictionary<SampleType>) => number;
+
+    {
+        let result: _.Dictionary<string[]>;
+
+        result = _.groupBy<string>('');
+        result = _.groupBy<string>('', stringIterator);
+        result = _.groupBy<string>('', stringIterator, any);
+        result = _.groupBy<string, number>('', stringIterator);
+        result = _.groupBy<string, number>('', stringIterator, any);
+    }
+
+    {
+        let result: _.Dictionary<SampleType[]>;
+
+        result = _.groupBy<SampleType>(array);
+        result = _.groupBy<SampleType>(array, listIterator);
+        result = _.groupBy<SampleType>(array, listIterator, any);
+        result = _.groupBy<SampleType>(array, '');
+        result = _.groupBy<SampleType>(array, '', any);
+        result = _.groupBy<SampleType>(array, {a: 42});
+
+        result = _.groupBy<SampleType, number>(array, listIterator);
+        result = _.groupBy<SampleType, number>(array, listIterator, any);
+        result = _.groupBy<SampleType, boolean>(array, '', true);
+        result = _.groupBy<{a: number}, SampleType>(array, {a: 42});
+
+        result = _.groupBy<SampleType>(list);
+        result = _.groupBy<SampleType>(list, listIterator);
+        result = _.groupBy<SampleType>(list, listIterator, any);
+        result = _.groupBy<SampleType>(list, '');
+        result = _.groupBy<SampleType>(list, '', any);
+        result = _.groupBy<SampleType>(list, {a: 42});
+
+        result = _.groupBy<SampleType, number>(list, listIterator);
+        result = _.groupBy<SampleType, number>(list, listIterator, any);
+        result = _.groupBy<SampleType, boolean>(list, '', true);
+        result = _.groupBy<{a: number}, SampleType>(list, {a: 42});
+
+        result = _.groupBy<SampleType>(dictionary);
+        result = _.groupBy<SampleType>(dictionary, dictionaryIterator);
+        result = _.groupBy<SampleType>(dictionary, dictionaryIterator, any);
+        result = _.groupBy<SampleType>(dictionary, '');
+        result = _.groupBy<SampleType>(dictionary, '', any);
+        result = _.groupBy<SampleType>(dictionary, {a: 42});
+
+        result = _.groupBy<SampleType, number>(dictionary, dictionaryIterator);
+        result = _.groupBy<SampleType, number>(dictionary, dictionaryIterator, any);
+        result = _.groupBy<SampleType, boolean>(dictionary, '', true);
+        result = _.groupBy<{a: number}, SampleType>(dictionary, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<string[]>>;
+
+        result = _('').groupBy();
+        result = _('').groupBy<number>(stringIterator);
+        result = _('').groupBy<number>(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<SampleType[]>>;
+
+        result = _(array).groupBy();
+        result = _(array).groupBy<number>(listIterator);
+        result = _(array).groupBy<number>(listIterator, any);
+        result = _(array).groupBy('');
+        result = _(array).groupBy<boolean>('', true);
+        result = _(array).groupBy<{a: number}>({a: 42});
+
+        result = _(list).groupBy<SampleType>();
+        result = _(list).groupBy<SampleType>(listIterator);
+        result = _(list).groupBy<SampleType>(listIterator, any);
+        result = _(list).groupBy<SampleType>('');
+        result = _(list).groupBy<SampleType>('', any);
+        result = _(list).groupBy<SampleType>({a: 42});
+
+        result = _(list).groupBy<SampleType, number>(listIterator);
+        result = _(list).groupBy<SampleType, number>(listIterator, any);
+        result = _(list).groupBy<SampleType, boolean>('', true);
+        result = _(list).groupBy<{a: number}, SampleType>({a: 42});
+
+        result = _(dictionary).groupBy<SampleType>();
+        result = _(dictionary).groupBy<SampleType>(dictionaryIterator);
+        result = _(dictionary).groupBy<SampleType>(dictionaryIterator, any);
+        result = _(dictionary).groupBy<SampleType>('');
+        result = _(dictionary).groupBy<SampleType>('', any);
+        result = _(dictionary).groupBy<SampleType>({a: 42});
+
+        result = _(dictionary).groupBy<SampleType, number>(dictionaryIterator);
+        result = _(dictionary).groupBy<SampleType, number>(dictionaryIterator, any);
+        result = _(dictionary).groupBy<SampleType, boolean>('', true);
+        result = _(dictionary).groupBy<{a: number}, SampleType>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<string[]>>;
+
+        result = _('').chain().groupBy();
+        result = _('').chain().groupBy<number>(stringIterator);
+        result = _('').chain().groupBy<number>(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<SampleType[]>>;
+
+        result = _(array).chain().groupBy();
+        result = _(array).chain().groupBy<number>(listIterator);
+        result = _(array).chain().groupBy<number>(listIterator, any);
+        result = _(array).chain().groupBy('');
+        result = _(array).chain().groupBy<boolean>('', true);
+        result = _(array).chain().groupBy<{a: number}>({a: 42});
+
+        result = _(list).chain().groupBy<SampleType>();
+        result = _(list).chain().groupBy<SampleType>(listIterator);
+        result = _(list).chain().groupBy<SampleType>(listIterator, any);
+        result = _(list).chain().groupBy<SampleType>('');
+        result = _(list).chain().groupBy<SampleType>('', any);
+        result = _(list).chain().groupBy<SampleType>({a: 42});
+
+        result = _(list).chain().groupBy<SampleType, number>(listIterator);
+        result = _(list).chain().groupBy<SampleType, number>(listIterator, any);
+        result = _(list).chain().groupBy<SampleType, boolean>('', true);
+        result = _(list).chain().groupBy<{a: number}, SampleType>({a: 42});
+
+        result = _(dictionary).chain().groupBy<SampleType>();
+        result = _(dictionary).chain().groupBy<SampleType>(dictionaryIterator);
+        result = _(dictionary).chain().groupBy<SampleType>(dictionaryIterator, any);
+        result = _(dictionary).chain().groupBy<SampleType>('');
+        result = _(dictionary).chain().groupBy<SampleType>('', any);
+        result = _(dictionary).chain().groupBy<SampleType>({a: 42});
+
+        result = _(dictionary).chain().groupBy<SampleType, number>(dictionaryIterator);
+        result = _(dictionary).chain().groupBy<SampleType, number>(dictionaryIterator, any);
+        result = _(dictionary).chain().groupBy<SampleType, boolean>('', true);
+        result = _(dictionary).chain().groupBy<{a: number}, SampleType>({a: 42});
+    }
+}
+
+// _.include
+module TestInclude {
+    type SampleType = {a: string; b: number; c: boolean;};
+
+    let array: SampleType[];
+    let list: _.List<SampleType>;
+    let dictionary: _.Dictionary<SampleType>;
+
+    let target: SampleType;
+
+    {
+        let result: boolean;
+
+        result = _.include<SampleType>(array, target);
+        result = _.include<SampleType>(array, target, 42);
+
+        result = _.include<SampleType>(list, target);
+        result = _.include<SampleType>(list, target, 42);
+
+        result = _.include<SampleType>(dictionary, target);
+        result = _.include<SampleType>(dictionary, target, 42);
+
+        result = _(array).include(target);
+        result = _(array).include(target, 42);
+
+        result = _(list).include<SampleType>(target);
+        result = _(list).include<SampleType>(target, 42);
+
+        result = _(dictionary).include<SampleType>(target);
+        result = _(dictionary).include<SampleType>(target, 42);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(array).chain().include(target);
+        result = _(array).chain().include(target, 42);
+
+        result = _(list).chain().include<SampleType>(target);
+        result = _(list).chain().include<SampleType>(target, 42);
+
+        result = _(dictionary).chain().include<SampleType>(target);
+        result = _(dictionary).chain().include<SampleType>(target, 42);
+    }
+}
+
+// _.includes
+module TestIncludes {
+    type SampleType = {a: string; b: number; c: boolean;};
+
+    let array: SampleType[];
+    let list: _.List<SampleType>;
+    let dictionary: _.Dictionary<SampleType>;
+
+    let target: SampleType;
+
+    {
+        let result: boolean;
+
+        result = _.includes<SampleType>(array, target);
+        result = _.includes<SampleType>(array, target, 42);
+
+        result = _.includes<SampleType>(list, target);
+        result = _.includes<SampleType>(list, target, 42);
+
+        result = _.includes<SampleType>(dictionary, target);
+        result = _.includes<SampleType>(dictionary, target, 42);
+
+        result = _(array).includes(target);
+        result = _(array).includes(target, 42);
+
+        result = _(list).includes<SampleType>(target);
+        result = _(list).includes<SampleType>(target, 42);
+
+        result = _(dictionary).includes<SampleType>(target);
+        result = _(dictionary).includes<SampleType>(target, 42);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(array).chain().includes(target);
+        result = _(array).chain().includes(target, 42);
+
+        result = _(list).chain().includes<SampleType>(target);
+        result = _(list).chain().includes<SampleType>(target, 42);
+
+        result = _(dictionary).chain().includes<SampleType>(target);
+        result = _(dictionary).chain().includes<SampleType>(target, 42);
+    }
+}
+
+// _.indexBy
+module TestIndexBy {
+    type SampleObject = {a: number; b: string; c: boolean;};
+
+    let array: SampleObject[];
+    let list: _.List<SampleObject>;
+    let dictionary: _.Dictionary<SampleObject>;
+    let numericDictionary: _.NumericDictionary<SampleObject>;
+
+    let stringIterator: (value: string, index: number, collection: string) => any;
+    let listIterator: (value: SampleObject, index: number, collection: _.List<SampleObject>) => any;
+    let dictionaryIterator: (value: SampleObject, key: string, collection: _.Dictionary<SampleObject>) => any;
+    let numericDictionaryIterator: (value: SampleObject, key: number, collection: _.NumericDictionary<SampleObject>) => any;
+
+    {
+        let result: _.Dictionary<string>;
+
+        result = _.indexBy<string>('abcd');
+        result = _.indexBy<string>('abcd', stringIterator);
+        result = _.indexBy<string>('abcd', stringIterator, any);
+    }
+
+    {
+        let result: _.Dictionary<SampleObject>;
+
+        result = _.indexBy<SampleObject>(array);
+        result = _.indexBy<SampleObject>(array, listIterator);
+        result = _.indexBy<SampleObject>(array, listIterator, any);
+        result = _.indexBy<SampleObject>(array, 'a');
+        result = _.indexBy<SampleObject>(array, 'a', any);
+        result = _.indexBy<{a: number}, SampleObject>(array, {a: 42});
+        result = _.indexBy<SampleObject>(array, {a: 42});
+
+        result = _.indexBy<SampleObject>(list);
+        result = _.indexBy<SampleObject>(list, listIterator);
+        result = _.indexBy<SampleObject>(list, listIterator, any);
+        result = _.indexBy<SampleObject>(list, 'a');
+        result = _.indexBy<SampleObject>(list, 'a', any);
+        result = _.indexBy<{a: number}, SampleObject>(list, {a: 42});
+        result = _.indexBy<SampleObject>(list, {a: 42});
+
+        result = _.indexBy<SampleObject>(numericDictionary);
+        result = _.indexBy<SampleObject>(numericDictionary, numericDictionaryIterator);
+        result = _.indexBy<SampleObject>(numericDictionary, numericDictionaryIterator, any);
+        result = _.indexBy<SampleObject>(numericDictionary, 'a');
+        result = _.indexBy<SampleObject>(numericDictionary, 'a', any);
+        result = _.indexBy<{a: number}, SampleObject>(numericDictionary, {a: 42});
+        result = _.indexBy<SampleObject>(numericDictionary, {a: 42});
+
+        result = _.indexBy<SampleObject>(dictionary);
+        result = _.indexBy<SampleObject>(dictionary, dictionaryIterator);
+        result = _.indexBy<SampleObject>(dictionary, dictionaryIterator, any);
+        result = _.indexBy<SampleObject>(dictionary, 'a');
+        result = _.indexBy<SampleObject>(dictionary, 'a', any);
+        result = _.indexBy<{a: number}, SampleObject>(dictionary, {a: 42});
+        result = _.indexBy<SampleObject>(dictionary, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<string>>;
+
+        result = _('abcd').indexBy();
+        result = _('abcd').indexBy(stringIterator);
+        result = _('abcd').indexBy(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<SampleObject>>;
+
+        result = _(array).indexBy();
+        result = _(array).indexBy(listIterator);
+        result = _(array).indexBy(listIterator, any);
+        result = _(array).indexBy('a');
+        result = _(array).indexBy('a', any);
+        result = _(array).indexBy<{a: number}>({a: 42});
+
+        result = _(list).indexBy<SampleObject>();
+        result = _(list).indexBy<SampleObject>(listIterator);
+        result = _(list).indexBy<SampleObject>(listIterator, any);
+        result = _(list).indexBy<SampleObject>('a');
+        result = _(list).indexBy<SampleObject>('a', any);
+        result = _(list).indexBy<{a: number}, SampleObject>({a: 42});
+        result = _(list).indexBy<SampleObject>({a: 42});
+
+        result = _(numericDictionary).indexBy<SampleObject>();
+        result = _(numericDictionary).indexBy<SampleObject>(numericDictionaryIterator);
+        result = _(numericDictionary).indexBy<SampleObject>(numericDictionaryIterator, any);
+        result = _(numericDictionary).indexBy<SampleObject>('a');
+        result = _(numericDictionary).indexBy<SampleObject>('a', any);
+        result = _(numericDictionary).indexBy<{a: number}, SampleObject>({a: 42});
+        result = _(numericDictionary).indexBy<SampleObject>({a: 42});
+
+        result = _(dictionary).indexBy<SampleObject>();
+        result = _(dictionary).indexBy<SampleObject>(dictionaryIterator);
+        result = _(dictionary).indexBy<SampleObject>(dictionaryIterator, any);
+        result = _(dictionary).indexBy<SampleObject>('a');
+        result = _(dictionary).indexBy<SampleObject>('a', any);
+        result = _(dictionary).indexBy<{a: number}, SampleObject>({a: 42});
+        result = _(dictionary).indexBy<SampleObject>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<string>>;
+
+        result = _('abcd').chain().indexBy();
+        result = _('abcd').chain().indexBy(stringIterator);
+        result = _('abcd').chain().indexBy(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<SampleObject>>;
+
+        result = _(array).chain().indexBy();
+        result = _(array).chain().indexBy(listIterator);
+        result = _(array).chain().indexBy(listIterator, any);
+        result = _(array).chain().indexBy('a');
+        result = _(array).chain().indexBy('a', any);
+        result = _(array).chain().indexBy<{a: number}>({a: 42});
+
+        result = _(list).chain().indexBy<SampleObject>();
+        result = _(list).chain().indexBy<SampleObject>(listIterator);
+        result = _(list).chain().indexBy<SampleObject>(listIterator, any);
+        result = _(list).chain().indexBy<SampleObject>('a');
+        result = _(list).chain().indexBy<SampleObject>('a', any);
+        result = _(list).chain().indexBy<{a: number}, SampleObject>({a: 42});
+        result = _(list).chain().indexBy<SampleObject>({a: 42});
+
+        result = _(numericDictionary).chain().indexBy<SampleObject>();
+        result = _(numericDictionary).chain().indexBy<SampleObject>(numericDictionaryIterator);
+        result = _(numericDictionary).chain().indexBy<SampleObject>(numericDictionaryIterator, any);
+        result = _(numericDictionary).chain().indexBy<SampleObject>('a');
+        result = _(numericDictionary).chain().indexBy<SampleObject>('a', any);
+        result = _(numericDictionary).chain().indexBy<{a: number}, SampleObject>({a: 42});
+        result = _(numericDictionary).chain().indexBy<SampleObject>({a: 42});
+
+        result = _(dictionary).chain().indexBy<SampleObject>();
+        result = _(dictionary).chain().indexBy<SampleObject>(dictionaryIterator);
+        result = _(dictionary).chain().indexBy<SampleObject>(dictionaryIterator, any);
+        result = _(dictionary).chain().indexBy<SampleObject>('a');
+        result = _(dictionary).chain().indexBy<SampleObject>('a', any);
+        result = _(dictionary).chain().indexBy<{a: number}, SampleObject>({a: 42});
+        result = _(dictionary).chain().indexBy<SampleObject>({a: 42});
+    }
+}
+
+result = <number[][]>_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+result = <string[][]>_.invoke([123, 456], String.prototype.split, '');
+
+// _.map
+module TestMap {
+    let array: number[];
+    let list: _.List<number>;
+    let dictionary: _.Dictionary<number>;
+
+    let listIterator: (value: number, index: number, collection: _.List<number>) => TResult;
+    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => TResult;
+
+    {
+        let result: TResult[];
+
+        result = _.map<number, TResult>(array);
+        result = _.map<number, TResult>(array, listIterator);
+        result = _.map<number, TResult>(array, listIterator, any);
+        result = _.map<number, TResult>(array, '');
+
+        result = _.map<number, TResult>(list);
+        result = _.map<number, TResult>(list, listIterator);
+        result = _.map<number, TResult>(list, listIterator, any);
+        result = _.map<number, TResult>(list, '');
+
+        result = _.map<number, TResult>(dictionary);
+        result = _.map<number, TResult>(dictionary, dictionaryIterator);
+        result = _.map<number, TResult>(dictionary, dictionaryIterator, any);
+        result = _.map<number, TResult>(dictionary, '');
+    }
+
+    {
+        let result: boolean[];
+
+        result = _.map<number, {}>(array, {});
+        result = _.map<number, {}>(list, {});
+        result = _.map<number, {}>(dictionary, {});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _<number>(array).map<TResult>();
+        result = _<number>(array).map<TResult>(listIterator);
+        result = _<number>(array).map<TResult>(listIterator, any);
+        result = _<number>(array).map<TResult>('');
+
+        result = _(list).map<number, TResult>();
+        result = _(list).map<number, TResult>(listIterator);
+        result = _(list).map<number, TResult>(listIterator, any);
+        result = _(list).map<number, TResult>('');
+
+        result = _(dictionary).map<number, TResult>();
+        result = _(dictionary).map<number, TResult>(dictionaryIterator);
+        result = _(dictionary).map<number, TResult>(dictionaryIterator, any);
+        result = _(dictionary).map<number, TResult>('');
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<boolean>;
+
+        result = _<number>(array).map<{}>({});
+        result = _(list).map<{}>({});
+        result = _(dictionary).map<{}>({});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _<number>(array).chain().map<TResult>();
+        result = _<number>(array).chain().map<TResult>(listIterator);
+        result = _<number>(array).chain().map<TResult>(listIterator, any);
+        result = _<number>(array).chain().map<TResult>('');
+
+        result = _(list).chain().map<number, TResult>();
+        result = _(list).chain().map<number, TResult>(listIterator);
+        result = _(list).chain().map<number, TResult>(listIterator, any);
+        result = _(list).chain().map<number, TResult>('');
+
+        result = _(dictionary).chain().map<number, TResult>();
+        result = _(dictionary).chain().map<number, TResult>(dictionaryIterator);
+        result = _(dictionary).chain().map<number, TResult>(dictionaryIterator, any);
+        result = _(dictionary).chain().map<number, TResult>('');
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<boolean>;
+
+        result = _<number>(array).chain().map<{}>({});
+        result = _(list).chain().map<{}>({});
+        result = _(dictionary).chain().map<{}>({});
+    }
+}
+
+// _.partition
+result = <string[][]>_.partition<string>('abcd', (n) => n < 'c');
+result = <string[][]>_.partition<string>(['a', 'b', 'c', 'd'], (n) => n < 'c');
+result = <number[][]>_.partition<number>([1, 2, 3, 4], (n) => n < 3);
+result = <number[][]>_.partition<number>({0: 1, 1: 2, 2: 3, 3: 4, length: 4}, (n) => n < 3);
+result = <number[][]>_.partition<number>({a: 1, b: 2, c: 3, d: 4}, (n) => n < 3);
+result = <{a: number}[][]>_.partition<{a: number}, {a: number}>([{a: 1}, {a: 2}], {a: 2});
+result = <{a: number}[][]>_.partition<{a: number}, {a: number}>({0: {a: 1}, 1: {a: 2}, length: 2}, {a: 2});
+result = <{a: number}[][]>_.partition<{a: number}, {a: number}>({0: {a: 1}, 1: {a: 2}}, {a: 2});
+result = <{a: number}[][]>_.partition<{a: number}>([{a: 1}, {a: 2}], 'a');
+result = <{a: number}[][]>_.partition<{a: number}>([{a: 1}, {a: 2}], 'a', 2);
+result = <{a: number}[][]>_.partition<{a: number}>({0: {a: 1}, 1: {a: 2}, length: 2}, 'a');
+result = <{a: number}[][]>_.partition<{a: number}>({0: {a: 1}, 1: {a: 2}, length: 2}, 'a', 2);
+result = <{a: number}[][]>_.partition<{a: number}>({0: {a: 1}, 1: {a: 2}}, 'a');
+result = <{a: number}[][]>_.partition<{a: number}>({0: {a: 1}, 1: {a: 2}}, 'a', 2);
+result = <string[][]>_('abcd').partition((n) => n < 'c').value();
+result = <string[][]>_(['a', 'b', 'c', 'd']).partition((n) => n < 'c').value();
+result = <number[][]>_([1, 2, 3, 4]).partition((n) => n < 3).value();
+result = <number[][]>_({0: 1, 1: 2, 2: 3, 3: 4, length: 4}).partition<number>((n) => n < 3).value();
+result = <number[][]>_({a: 1, b: 2, c: 3, d: 4}).partition<number>((n) => n < 3).value();
+result = <{a: number}[][]>_([{a: 1}, {a: 2}]).partition<{a: number}>({a: 2}).value();
+result = <{a: number}[][]>_({0: {a: 1}, 1: {a: 2}, length: 2}).partition<{a: number}, {a: number}>({a: 2}).value();
+result = <{a: number}[][]>_({0: {a: 1}, 1: {a: 2}}).partition<{a: number}, {a: number}>({a: 2}).value();
+result = <{a: number}[][]>_([{a: 1}, {a: 2}]).partition('a').value();
+result = <{a: number}[][]>_([{a: 1}, {a: 2}]).partition('a', 2).value();
+result = <{a: number}[][]>_({0: {a: 1}, 1: {a: 2}}).partition<{a: number}>('a').value();
+result = <{a: number}[][]>_({0: {a: 1}, 1: {a: 2}}).partition<{a: number}>('a', 2).value();
+
+// _.pluck
+module TestPluck {
+    interface SampleObject {
+        d: {b: TResult}[];
+    }
+
+    let array: SampleObject[];
+    let list: _.List<SampleObject>;
+    let dictionary: _.Dictionary<SampleObject>;
+
+    {
+        let result: any[];
+
+        result = _.pluck<SampleObject>(array, 'd.0.b');
+        result = _.pluck<SampleObject>(array, ['d', 0, 'b']);
+
+        result = _.pluck<SampleObject>(list, 'd.0.b');
+        result = _.pluck<SampleObject>(list, ['d', 0, 'b']);
+
+        result = _.pluck<SampleObject>(dictionary, 'd.0.b');
+        result = _.pluck<SampleObject>(dictionary, ['d', 0, 'b']);
+    }
+
+    {
+        let result: TResult[];
+
+        result = _.pluck<SampleObject, TResult>(array, 'd.0.b');
+        result = _.pluck<SampleObject, TResult>(array, ['d', 0, 'b']);
+
+        result = _.pluck<SampleObject, TResult>(list, 'd.0.b');
+        result = _.pluck<SampleObject, TResult>(list, ['d', 0, 'b']);
+
+        result = _.pluck<SampleObject, TResult>(dictionary, 'd.0.b');
+        result = _.pluck<SampleObject, TResult>(dictionary, ['d', 0, 'b']);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).pluck<TResult>('d.0.b');
+        result = _(array).pluck<TResult>(['d', 0, 'b']);
+
+        result = _(list).pluck<TResult>('d.0.b');
+        result = _(list).pluck<TResult>(['d', 0, 'b']);
+
+        result = _(dictionary).pluck<TResult>('d.0.b');
+        result = _(dictionary).pluck<TResult>(['d', 0, 'b']);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().pluck<TResult>('d.0.b');
+        result = _(array).chain().pluck<TResult>(['d', 0, 'b']);
+
+        result = _(list).chain().pluck<TResult>('d.0.b');
+        result = _(list).chain().pluck<TResult>(['d', 0, 'b']);
+
+        result = _(dictionary).chain().pluck<TResult>('d.0.b');
+        result = _(dictionary).chain().pluck<TResult>(['d', 0, 'b']);
+    }
+}
+
+interface ABC {
+    [index: string]: number;
+    a: number;
+    b: number;
+    c: number;
+}
+
+result = <number>_.reduce<number, number>([1, 2, 3], function (sum: number, num: number) {
+    return sum + num;
+});
+result = <ABC>_.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function (r: ABC, num: number, key: string) {
+    r[key] = num * 3;
+    return r;
+}, {});
+
+result = <number>_.foldl([1, 2, 3], function (sum: number, num: number) {
+    return sum + num;
+});
+result = <ABC>_.foldl({ 'a': 1, 'b': 2, 'c': 3 }, function (r: ABC, num: number, key: string) {
+    r[key] = num * 3;
+    return r;
+}, {});
+
+result = <number>_.inject([1, 2, 3], function (sum: number, num: number) {
+    return sum + num;
+});
+result = <ABC>_.inject({ 'a': 1, 'b': 2, 'c': 3 }, function (r: ABC, num: number, key: string) {
+    r[key] = num * 3;
+    return r;
+}, {});
+
+result = <number>_([1, 2, 3]).reduce<number>(function (sum: number, num: number) {
+    return sum + num;
+});
+result = <ABC>_({ 'a': 1, 'b': 2, 'c': 3 }).reduce<number, ABC>(function (r: ABC, num: number, key: string) {
+    r[key] = num * 3;
+    return r;
+}, {});
+
+result = <number>_([1, 2, 3]).foldl<number>(function (sum: number, num: number) {
+    return sum + num;
+});
+result = <ABC>_({ 'a': 1, 'b': 2, 'c': 3 }).foldl<number, ABC>(function (r: ABC, num: number, key: string) {
+    r[key] = num * 3;
+    return r;
+}, {});
+
+result = <number>_([1, 2, 3]).inject<number>(function (sum: number, num: number) {
+    return sum + num;
+});
+result = <ABC>_({ 'a': 1, 'b': 2, 'c': 3 }).inject<number, ABC>(function (r: ABC, num: number, key: string) {
+    r[key] = num * 3;
+    return r;
+}, {});
+
+result = <number[]>_.reduceRight([[0, 1], [2, 3], [4, 5]], function (a: number[], b: number[]) { return a.concat(b); }, <number[]>[]);
+result = <number[]>_.foldr([[0, 1], [2, 3], [4, 5]], function (a: number[], b: number[]) { return a.concat(b); }, <number[]>[]);
+
+// _.reject
+module TestReject {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let stringIterator: (char: string, index: number, string: string) => any;
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => any;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => any;
+
+    {
+        let result: string[];
+
+        result = _.reject('', stringIterator);
+        result = _.reject('', stringIterator, any);
+    }
+
+    {
+        let result: TResult[];
+
+        result = _.reject<TResult>(array, listIterator);
+        result = _.reject<TResult>(array, listIterator, any);
+        result = _.reject<TResult>(array, '');
+        result = _.reject<TResult>(array, '', any);
+        result = _.reject<{a: number}, TResult>(array, {a: 42});
+
+        result = _.reject<TResult>(list, listIterator);
+        result = _.reject<TResult>(list, listIterator, any);
+        result = _.reject<TResult>(list, '');
+        result = _.reject<TResult>(list, '', any);
+        result = _.reject<{a: number}, TResult>(list, {a: 42});
+
+        result = _.reject<TResult>(dictionary, dictionaryIterator);
+        result = _.reject<TResult>(dictionary, dictionaryIterator, any);
+        result = _.reject<TResult>(dictionary, '');
+        result = _.reject<TResult>(dictionary, '', any);
+        result = _.reject<{a: number}, TResult>(dictionary, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('').reject(stringIterator);
+        result = _('').reject(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).reject(listIterator);
+        result = _(array).reject(listIterator, any);
+        result = _(array).reject('');
+        result = _(array).reject('', any);
+        result = _(array).reject<{a: number}>({a: 42});
+
+        result = _(list).reject<TResult>(listIterator);
+        result = _(list).reject<TResult>(listIterator, any);
+        result = _(list).reject<TResult>('');
+        result = _(list).reject<TResult>('', any);
+        result = _(list).reject<{a: number}, TResult>({a: 42});
+
+        result = _(dictionary).reject<TResult>(dictionaryIterator);
+        result = _(dictionary).reject<TResult>(dictionaryIterator, any);
+        result = _(dictionary).reject<TResult>('');
+        result = _(dictionary).reject<TResult>('', any);
+        result = _(dictionary).reject<{a: number}, TResult>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _('').chain().reject(stringIterator);
+        result = _('').chain().reject(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().reject(listIterator);
+        result = _(array).chain().reject(listIterator, any);
+        result = _(array).chain().reject('');
+        result = _(array).chain().reject('', any);
+        result = _(array).chain().reject<{a: number}>({a: 42});
+
+        result = _(list).chain().reject<TResult>(listIterator);
+        result = _(list).chain().reject<TResult>(listIterator, any);
+        result = _(list).chain().reject<TResult>('');
+        result = _(list).chain().reject<TResult>('', any);
+        result = _(list).chain().reject<{a: number}, TResult>({a: 42});
+
+        result = _(dictionary).chain().reject<TResult>(dictionaryIterator);
+        result = _(dictionary).chain().reject<TResult>(dictionaryIterator, any);
+        result = _(dictionary).chain().reject<TResult>('');
+        result = _(dictionary).chain().reject<TResult>('', any);
+        result = _(dictionary).chain().reject<{a: number}, TResult>({a: 42});
+    }
+}
+
+result = <number>_.sample([1, 2, 3, 4]);
+result = <number[]>_.sample([1, 2, 3, 4], 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();
+
+// _.select
+module TestSelect {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let stringIterator: (char: string, index: number, string: string) => any;
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => any;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => any;
+
+    {
+        let result: string[];
+
+        result = _.select('', stringIterator);
+        result = _.select('', stringIterator, any);
+    }
+
+    {
+        let result: TResult[];
+
+        result = _.select<TResult>(array, listIterator);
+        result = _.select<TResult>(array, listIterator, any);
+        result = _.select<TResult>(array, '');
+        result = _.select<TResult>(array, '', any);
+        result = _.select<{a: number}, TResult>(array, {a: 42});
+
+        result = _.select<TResult>(list, listIterator);
+        result = _.select<TResult>(list, listIterator, any);
+        result = _.select<TResult>(list, '');
+        result = _.select<TResult>(list, '', any);
+        result = _.select<{a: number}, TResult>(list, {a: 42});
+
+        result = _.select<TResult>(dictionary, dictionaryIterator);
+        result = _.select<TResult>(dictionary, dictionaryIterator, any);
+        result = _.select<TResult>(dictionary, '');
+        result = _.select<TResult>(dictionary, '', any);
+        result = _.select<{a: number}, TResult>(dictionary, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('').select(stringIterator);
+        result = _('').select(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).select(listIterator);
+        result = _(array).select(listIterator, any);
+        result = _(array).select('');
+        result = _(array).select('', any);
+        result = _(array).select<{a: number}>({a: 42});
+
+        result = _(list).select<TResult>(listIterator);
+        result = _(list).select<TResult>(listIterator, any);
+        result = _(list).select<TResult>('');
+        result = _(list).select<TResult>('', any);
+        result = _(list).select<{a: number}, TResult>({a: 42});
+
+        result = _(dictionary).select<TResult>(dictionaryIterator);
+        result = _(dictionary).select<TResult>(dictionaryIterator, any);
+        result = _(dictionary).select<TResult>('');
+        result = _(dictionary).select<TResult>('', any);
+        result = _(dictionary).select<{a: number}, TResult>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _('').chain().select(stringIterator);
+        result = _('').chain().select(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().select(listIterator);
+        result = _(array).chain().select(listIterator, any);
+        result = _(array).chain().select('');
+        result = _(array).chain().select('', any);
+        result = _(array).chain().select<{a: number}>({a: 42});
+
+        result = _(list).chain().select<TResult>(listIterator);
+        result = _(list).chain().select<TResult>(listIterator, any);
+        result = _(list).chain().select<TResult>('');
+        result = _(list).chain().select<TResult>('', any);
+        result = _(list).chain().select<{a: number}, TResult>({a: 42});
+
+        result = _(dictionary).chain().select<TResult>(dictionaryIterator);
+        result = _(dictionary).chain().select<TResult>(dictionaryIterator, any);
+        result = _(dictionary).chain().select<TResult>('');
+        result = _(dictionary).chain().select<TResult>('', any);
+        result = _(dictionary).chain().select<{a: number}, TResult>({a: 42});
+    }
+}
+
+// _.shuffle
+module TestShuffle {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    {
+        let result: string[];
+
+        result = _.shuffle('abc');
+    }
+
+    {
+        let result: TResult[];
+
+        result = _.shuffle<TResult>(array);
+        result = _.shuffle<TResult>(list);
+        result = _.shuffle<TResult>(dictionary);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('abc').shuffle();
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).shuffle();
+        result = _(list).shuffle<TResult>();
+        result = _(dictionary).shuffle<TResult>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _('abc').chain().shuffle();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().shuffle();
+        result = _(list).chain().shuffle<TResult>();
+        result = _(dictionary).chain().shuffle<TResult>();
+    }
+}
+
+// _.size
+module TestSize {
+    type SampleType = {a: string; b: number; c: boolean;};
+
+    let array: SampleType[];
+    let list: _.List<SampleType>;
+    let dictionary: _.Dictionary<SampleType>;
+
+    {
+        let result: number;
+
+        result = _.size<SampleType>(array);
+        result = _.size<SampleType>(list);
+        result = _.size<SampleType>(dictionary);
+        result = _.size('');
+
+        result = _(array).size();
+        result = _(list).size();
+        result = _(dictionary).size();
+        result = _('').size();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(array).chain().size();
+        result = _(list).chain().size();
+        result = _(dictionary).chain().size();
+        result = _('').chain().size();
+    }
+}
+
+// _.some
+module TestSome {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+    let numericDictionary: _.NumericDictionary<TResult>;
+
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => boolean;
+    let numericDictionaryIterator: (value: TResult, key: number, collection: _.NumericDictionary<TResult>) => boolean;
+
+    {
+        let result: boolean;
+
+        result = _.some<TResult>(array);
+        result = _.some<TResult>(array, listIterator);
+        result = _.some<TResult>(array, listIterator, any);
+        result = _.some<TResult>(array, '');
+        result = _.some<{a: number}, TResult>(array, {a: 42});
+
+        result = _.some<TResult>(list);
+        result = _.some<TResult>(list, listIterator);
+        result = _.some<TResult>(list, listIterator, any);
+        result = _.some<TResult>(list, '');
+        result = _.some<{a: number}, TResult>(list, {a: 42});
+
+        result = _.some<TResult>(dictionary);
+        result = _.some<TResult>(dictionary, dictionaryIterator);
+        result = _.some<TResult>(dictionary, dictionaryIterator, any);
+        result = _.some<TResult>(dictionary, '');
+        result = _.some<{a: number}, TResult>(dictionary, {a: 42});
+
+        result = _.some<TResult>(numericDictionary);
+        result = _.some<TResult>(numericDictionary, numericDictionaryIterator);
+        result = _.some<TResult>(numericDictionary, numericDictionaryIterator, any);
+        result = _.some<TResult>(numericDictionary, '');
+        result = _.some<{a: number}, TResult>(numericDictionary, {a: 42});
+
+        result = _(array).some();
+        result = _(array).some(listIterator);
+        result = _(array).some(listIterator, any);
+        result = _(array).some('');
+        result = _(array).some<{a: number}>({a: 42});
+
+        result = _(list).some<TResult>();
+        result = _(list).some<TResult>(listIterator);
+        result = _(list).some<TResult>(listIterator, any);
+        result = _(list).some('');
+        result = _(list).some<{a: number}>({a: 42});
+
+        result = _(dictionary).some<TResult>();
+        result = _(dictionary).some<TResult>(dictionaryIterator);
+        result = _(dictionary).some<TResult>(dictionaryIterator, any);
+        result = _(dictionary).some('');
+        result = _(dictionary).some<{a: number}>({a: 42});
+
+        result = _(numericDictionary).some<TResult>();
+        result = _(numericDictionary).some<TResult>(numericDictionaryIterator);
+        result = _(numericDictionary).some<TResult>(numericDictionaryIterator, any);
+        result = _(numericDictionary).some('');
+        result = _(numericDictionary).some<{a: number}>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(array).chain().some();
+        result = _(array).chain().some(listIterator);
+        result = _(array).chain().some(listIterator, any);
+        result = _(array).chain().some('');
+        result = _(array).chain().some<{a: number}>({a: 42});
+
+        result = _(list).chain().some<TResult>();
+        result = _(list).chain().some<TResult>(listIterator);
+        result = _(list).chain().some<TResult>(listIterator, any);
+        result = _(list).chain().some('');
+        result = _(list).chain().some<{a: number}>({a: 42});
+
+        result = _(dictionary).chain().some<TResult>();
+        result = _(dictionary).chain().some<TResult>(dictionaryIterator);
+        result = _(dictionary).chain().some<TResult>(dictionaryIterator, any);
+        result = _(dictionary).chain().some('');
+        result = _(dictionary).chain().some<{a: number}>({a: 42});
+
+        result = _(numericDictionary).chain().some<TResult>();
+        result = _(numericDictionary).chain().some<TResult>(numericDictionaryIterator);
+        result = _(numericDictionary).chain().some<TResult>(numericDictionaryIterator, any);
+        result = _(numericDictionary).chain().some('');
+        result = _(numericDictionary).chain().some<{a: number}>({a: 42});
+    }
+}
+
+// _.sortBy
+module TestSortBy {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => number;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => number;
+
+    {
+        let result: TResult[];
+
+        result = _.sortBy<TResult>(array);
+        result = _.sortBy<TResult, number>(array, listIterator);
+        result = _.sortBy<TResult, number>(array, listIterator, any);
+        result = _.sortBy<TResult>(array, '');
+        result = _.sortBy<{a: number}, TResult>(array, {a: 42});
+
+        result = _.sortBy<TResult>(list);
+        result = _.sortBy<TResult, number>(list, listIterator);
+        result = _.sortBy<TResult, number>(list, listIterator, any);
+        result = _.sortBy<TResult>(list, '');
+        result = _.sortBy<{a: number}, TResult>(list, {a: 42});
+
+        result = _.sortBy<TResult>(dictionary);
+        result = _.sortBy<TResult, number>(dictionary, dictionaryIterator);
+        result = _.sortBy<TResult, number>(dictionary, dictionaryIterator, any);
+        result = _.sortBy<TResult>(dictionary, '');
+        result = _.sortBy<{a: number}, TResult>(dictionary, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).sortBy();
+        result = _(array).sortBy<number>(listIterator);
+        result = _(array).sortBy<number>(listIterator, any);
+        result = _(array).sortBy('');
+        result = _(array).sortBy<{a: number}>({a: 42});
+
+        result = _(list).sortBy<TResult>();
+        result = _(list).sortBy<TResult, number>(listIterator);
+        result = _(list).sortBy<TResult, number>(listIterator, any);
+        result = _(list).sortBy<TResult>('');
+        result = _(list).sortBy<{a: number}, TResult>({a: 42});
+
+        result = _(dictionary).sortBy<TResult>();
+        result = _(dictionary).sortBy<TResult, number>(dictionaryIterator);
+        result = _(dictionary).sortBy<TResult, number>(dictionaryIterator, any);
+        result = _(dictionary).sortBy<TResult>('');
+        result = _(dictionary).sortBy<{a: number}, TResult>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().sortBy();
+        result = _(array).chain().sortBy<number>(listIterator);
+        result = _(array).chain().sortBy<number>(listIterator, any);
+        result = _(array).chain().sortBy('');
+        result = _(array).chain().sortBy<{a: number}>({a: 42});
+
+        result = _(list).chain().sortBy<TResult>();
+        result = _(list).chain().sortBy<TResult, number>(listIterator);
+        result = _(list).chain().sortBy<TResult, number>(listIterator, any);
+        result = _(list).chain().sortBy<TResult>('');
+        result = _(list).chain().sortBy<{a: number}, TResult>({a: 42});
+
+        result = _(dictionary).chain().sortBy<TResult>();
+        result = _(dictionary).chain().sortBy<TResult, number>(dictionaryIterator);
+        result = _(dictionary).chain().sortBy<TResult, number>(dictionaryIterator, any);
+        result = _(dictionary).chain().sortBy<TResult>('');
+        result = _(dictionary).chain().sortBy<{a: number}, TResult>({a: 42});
+    }
+}
+
+result = <IStoogesAge[]>_.sortByAll(stoogesAges, function(stooge) { return Math.sin(stooge.age); }, function(stooge) { return stooge.name.slice(1); });
+result = <IStoogesAge[]>_.sortByAll(stoogesAges, ['name', 'age']);
+result = <IStoogesAge[]>_.sortByAll(stoogesAges, 'name', function(stooge) { return Math.sin(stooge.age); });
+
+result = <IFoodOrganic[]>_(foodsOrganic).sortByAll('organic', (food) => food.name, { organic: true }).value();
+
+// _.sortByOrder
+module TestSortByOrder {
+    type SampleObject = {a: number; b: string; c: boolean};
+
+    let array: SampleObject[];
+    let list: _.List<SampleObject>;
+    let numericDictionary: _.NumericDictionary<SampleObject>;
+    let dictionary: _.Dictionary<SampleObject>;
+    let orders: boolean|string|(boolean|string)[];
+
+    {
+        let iteratees: (value: string) => any|((value: string) => any)[];
+        let result: string[];
+
+        result = _.sortByOrder<string>('acbd', iteratees);
+        result = _.sortByOrder<string>('acbd', iteratees, orders);
+    }
+
+    {
+        let iteratees: (value: SampleObject) => any|string|{a: number}|((value: SampleObject) => any|string|{a: number})[];
+        let result: SampleObject[];
+
+        result = _.sortByOrder<{a: number}, SampleObject>(array, iteratees);
+        result = _.sortByOrder<{a: number}, SampleObject>(array, iteratees, orders);
+        result = _.sortByOrder<SampleObject>(array, iteratees);
+        result = _.sortByOrder<SampleObject>(array, iteratees, orders);
+
+        result = _.sortByOrder<{a: number}, SampleObject>(list, iteratees);
+        result = _.sortByOrder<{a: number}, SampleObject>(list, iteratees, orders);
+        result = _.sortByOrder<SampleObject>(list, iteratees);
+        result = _.sortByOrder<SampleObject>(list, iteratees, orders);
+
+        result = _.sortByOrder<{a: number}, SampleObject>(numericDictionary, iteratees);
+        result = _.sortByOrder<{a: number}, SampleObject>(numericDictionary, iteratees, orders);
+        result = _.sortByOrder<SampleObject>(numericDictionary, iteratees);
+        result = _.sortByOrder<SampleObject>(numericDictionary, iteratees, orders);
+
+        result = _.sortByOrder<{a: number}, SampleObject>(dictionary, iteratees);
+        result = _.sortByOrder<{a: number}, SampleObject>(dictionary, iteratees, orders);
+        result = _.sortByOrder<SampleObject>(dictionary, iteratees);
+        result = _.sortByOrder<SampleObject>(dictionary, iteratees, orders);
+    }
+
+    {
+        let iteratees: (value: SampleObject) => any|string|{a: number}|((value: SampleObject) => any|string|{a: number})[];
+        let result: _.LoDashImplicitArrayWrapper<SampleObject>;
+
+        result = _(array).sortByOrder<{a: number}>(iteratees);
+        result = _(array).sortByOrder<{a: number}>(iteratees, orders);
+
+        result = _(list).sortByOrder<{a: number}, SampleObject>(iteratees);
+        result = _(list).sortByOrder<{a: number}, SampleObject>(iteratees, orders);
+        result = _(list).sortByOrder<SampleObject>(iteratees);
+        result = _(list).sortByOrder<SampleObject>(iteratees, orders);
+
+        result = _(numericDictionary).sortByOrder<{a: number}, SampleObject>(iteratees);
+        result = _(numericDictionary).sortByOrder<{a: number}, SampleObject>(iteratees, orders);
+        result = _(numericDictionary).sortByOrder<SampleObject>(iteratees);
+        result = _(numericDictionary).sortByOrder<SampleObject>(iteratees, orders);
+
+        result = _(dictionary).sortByOrder<{a: number}, SampleObject>(iteratees);
+        result = _(dictionary).sortByOrder<{a: number}, SampleObject>(iteratees, orders);
+        result = _(dictionary).sortByOrder<SampleObject>(iteratees);
+        result = _(dictionary).sortByOrder<SampleObject>(iteratees, orders);
+    }
+
+    {
+        let iteratees: (value: SampleObject) => any|string|{a: number}|((value: SampleObject) => any|string|{a: number})[];
+        let result: _.LoDashExplicitArrayWrapper<SampleObject>;
+
+        result = _(array).chain().sortByOrder<{a: number}>(iteratees);
+        result = _(array).chain().sortByOrder<{a: number}>(iteratees, orders);
+
+        result = _(list).chain().sortByOrder<{a: number}, SampleObject>(iteratees);
+        result = _(list).chain().sortByOrder<{a: number}, SampleObject>(iteratees, orders);
+        result = _(list).chain().sortByOrder<SampleObject>(iteratees);
+        result = _(list).chain().sortByOrder<SampleObject>(iteratees, orders);
+
+        result = _(numericDictionary).chain().sortByOrder<{a: number}, SampleObject>(iteratees);
+        result = _(numericDictionary).chain().sortByOrder<{a: number}, SampleObject>(iteratees, orders);
+        result = _(numericDictionary).chain().sortByOrder<SampleObject>(iteratees);
+        result = _(numericDictionary).chain().sortByOrder<SampleObject>(iteratees, orders);
+
+        result = _(dictionary).chain().sortByOrder<{a: number}, SampleObject>(iteratees);
+        result = _(dictionary).chain().sortByOrder<{a: number}, SampleObject>(iteratees, orders);
+        result = _(dictionary).chain().sortByOrder<SampleObject>(iteratees);
+        result = _(dictionary).chain().sortByOrder<SampleObject>(iteratees, orders);
+    }
+}
+
+result = <IStoogesCombined[]>_.where(stoogesCombined, { 'age': 40 });
+result = <IStoogesCombined[]>_.where(stoogesCombined, { 'quotes': ['Poifect!'] });
+
+result = <IStoogesCombined[]>_(stoogesCombined).where({ 'age': 40 }).value();
+result = <IStoogesCombined[]>_(stoogesCombined).where({ 'quotes': ['Poifect!'] }).value();
+
+/********
+ * Date *
+ ********/
+
+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 *
+ *************/
+
+// _after
+module TestAfter {
+    interface Func {
+        (a: string, b: number): boolean;
+    }
+
+    let func: Func;
+
+    {
+        let result: Func;
+
+        _.after(42, func);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<Func>;
+
+        _(42).after(func);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<Func>;
+
+        _(42).chain().after(func);
+    }
+}
+
+// _.ary
+module TestAry {
+    type SampleFunc = (a: number, b: string) => boolean;
+
+    let func: SampleFunc;
+
+    {
+        let result: SampleFunc;
+
+        result = _.ary<SampleFunc>(func);
+        result = _.ary<SampleFunc>(func, 2);
+        result = _.ary<SampleFunc, SampleFunc>(func);
+        result = _.ary<SampleFunc, SampleFunc>(func, 2);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<SampleFunc>;
+
+        result = _(func).ary<SampleFunc>();
+        result = _(func).ary<SampleFunc>(2);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<SampleFunc>;
+
+        result = _(func).chain().ary<SampleFunc>();
+        result = _(func).chain().ary<SampleFunc>(2);
+    }
+}
+
+// _.backflow
+module TestBackflow {
+    let Fn1: (n: number) => number;
+    let Fn2: (m: number, n: number) => number;
+
+    {
+        let result: (m: number, n: number) => number;
+
+        result = _.backflow<(m: number, n: number) => number>(Fn1, Fn2);
+        result = _.backflow<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
+        result = _.backflow<(m: number, n: number) => number>(Fn1, Fn1, Fn1, Fn2);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(m: number, n: number) => number>;
+
+        result = _(Fn1).backflow<(m: number, n: number) => number>(Fn2);
+        result = _(Fn1).backflow<(m: number, n: number) => number>(Fn1, Fn2);
+        result = _(Fn1).backflow<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(m: number, n: number) => number>;
+
+        result = _(Fn1).chain().backflow<(m: number, n: number) => number>(Fn2);
+        result = _(Fn1).chain().backflow<(m: number, n: number) => number>(Fn1, Fn2);
+        result = _(Fn1).chain().backflow<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
+    }
+}
+
+// _.before
+module TestBefore {
+    interface Func {
+        (a: string, b: number): boolean;
+    }
+
+    let func: Func;
+
+    {
+        let result: Func;
+
+        _.before(42, func);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<Func>;
+
+        _(42).before(func);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<Func>;
+
+        _(42).chain().before(func);
+    }
+}
+
+// _.bind
+module TestBind {
+    type SampleFunc = (a: number, b: string) => boolean;
+
+    let func: SampleFunc
+
+    {
+        type SampleResult = (a: number, b: string) => boolean;
+
+        let result: SampleResult;
+
+        result = _.bind<SampleFunc, SampleResult>(func, any);
+        result = _.bind<SampleResult>(func, any);
+    }
+
+    {
+        type SampleResult = (b: string) => boolean;
+
+        let result: SampleResult;
+
+        result = _.bind<SampleFunc, SampleResult>(func, any, 42);
+        result = _.bind<SampleResult>(func, any, 42);
+    }
+
+    {
+        type SampleResult = () => boolean;
+
+        let result: SampleResult;
+
+        result = _.bind<SampleFunc, SampleResult>(func, any, 42, '');
+        result = _.bind<SampleResult>(func, any, 42, '');
+    }
+
+    {
+        type SampleResult = (a: number, b: string) => boolean;
+
+        let result: _.LoDashImplicitObjectWrapper<SampleResult>;
+
+        result = _(func).bind<SampleResult>(any);
+    }
+
+    {
+        type SampleResult = (b: string) => boolean;
+
+        let result: _.LoDashImplicitObjectWrapper<SampleResult>;
+
+        result = _(func).bind<SampleResult>(any, 42);
+    }
+
+    {
+        type SampleResult = () => boolean;
+
+        let result: _.LoDashImplicitObjectWrapper<SampleResult>;
+
+        result = _(func).bind<SampleResult>(any, 42, '');
+    }
+
+    {
+        type SampleResult = (a: number, b: string) => boolean;
+
+        let result: _.LoDashExplicitObjectWrapper<SampleResult>;
+
+        result = _(func).chain().bind<SampleResult>(any);
+    }
+
+    {
+        type SampleResult = (b: string) => boolean;
+
+        let result: _.LoDashExplicitObjectWrapper<SampleResult>;
+
+        result = _(func).chain().bind<SampleResult>(any, 42);
+    }
+
+    {
+        type SampleResult = () => boolean;
+
+        let result: _.LoDashExplicitObjectWrapper<SampleResult>;
+
+        result = _(func).chain().bind<SampleResult>(any, 42, '');
+    }
+}
+
+// _.bindAll
+module TestBindAll {
+    interface SampleObject {
+        a: Function;
+        b: Function;
+        c: Function;
+    }
+
+    let object: SampleObject;
+
+    {
+        let result: SampleObject;
+
+        result = _.bindAll<SampleObject>(object);
+        result = _.bindAll<SampleObject>(object, 'c');
+        result = _.bindAll<SampleObject>(object, ['b'], 'c');
+        result = _.bindAll<SampleObject>(object, 'a', ['b'], 'c');
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<SampleObject>;
+
+        result = _(object).bindAll();
+        result = _(object).bindAll('c');
+        result = _(object).bindAll(['b'], 'c');
+        result = _(object).bindAll('a', ['b'], 'c');
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<SampleObject>;
+
+        result = _(object).chain().bindAll();
+        result = _(object).chain().bindAll('c');
+        result = _(object).chain().bindAll(['b'], 'c');
+        result = _(object).chain().bindAll('a', ['b'], 'c');
+    }
+}
+
+// _.bindKey
+module TestBindKey {
+    let object: {
+        foo: (a: number, b: string) => boolean;
+    }
+
+    {
+        type SampleResult = (a: number, b: string) => boolean;
+
+        let result: SampleResult;
+
+        result = _.bindKey<Object, SampleResult>(object, 'foo');
+        result = _.bindKey<SampleResult>(object, 'foo');
+    }
+
+    {
+        type SampleResult = (b: string) => boolean;
+
+        let result: SampleResult;
+
+        result = _.bindKey<Object, SampleResult>(object, 'foo', 42);
+        result = _.bindKey<SampleResult>(object, 'foo', 42);
+    }
+
+    {
+        type SampleResult = () => boolean;
+
+        let result: SampleResult;
+
+        result = _.bindKey<Object, SampleResult>(object, 'foo', 42, '');
+        result = _.bindKey<SampleResult>(object, 'foo', 42, '');
+    }
+
+    {
+        type SampleResult = (a: number, b: string) => boolean;
+
+        let result: _.LoDashImplicitObjectWrapper<SampleResult>;
+
+        result = _(object).bindKey<SampleResult>('foo');
+    }
+
+    {
+        type SampleResult = (b: string) => boolean;
+
+        let result: _.LoDashImplicitObjectWrapper<SampleResult>;
+
+        result = _(object).bindKey<SampleResult>('foo', 42);
+    }
+
+    {
+        type SampleResult = () => boolean;
+
+        let result: _.LoDashImplicitObjectWrapper<SampleResult>;
+
+        result = _(object).bindKey<SampleResult>('foo', 42, '');
+    }
+
+    {
+        type SampleResult = (a: number, b: string) => boolean;
+
+        let result: _.LoDashExplicitObjectWrapper<SampleResult>;
+
+        result = _(object).chain().bindKey<SampleResult>('foo');
+    }
+
+    {
+        type SampleResult = (b: string) => boolean;
+
+        let result: _.LoDashExplicitObjectWrapper<SampleResult>;
+
+        result = _(object).chain().bindKey<SampleResult>('foo', 42);
+    }
+
+    {
+        type SampleResult = () => boolean;
+
+        let result: _.LoDashExplicitObjectWrapper<SampleResult>;
+
+        result = _(object).chain().bindKey<SampleResult>('foo', 42, '');
+    }
+}
+
+// _.compose
+module TestCompose {
+    let Fn1: (n: number) => number;
+    let Fn2: (m: number, n: number) => number;
+
+    {
+        let result: (m: number, n: number) => number;
+
+        result = _.compose<(m: number, n: number) => number>(Fn1, Fn2);
+        result = _.compose<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
+        result = _.compose<(m: number, n: number) => number>(Fn1, Fn1, Fn1, Fn2);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(m: number, n: number) => number>;
+
+        result = _(Fn1).compose<(m: number, n: number) => number>(Fn2);
+        result = _(Fn1).compose<(m: number, n: number) => number>(Fn1, Fn2);
+        result = _(Fn1).compose<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(m: number, n: number) => number>;
+
+        result = _(Fn1).chain().compose<(m: number, n: number) => number>(Fn2);
+        result = _(Fn1).chain().compose<(m: number, n: number) => number>(Fn1, Fn2);
+        result = _(Fn1).chain().compose<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
+    }
+}
+
+var createCallbackObj: { [index: string]: string; } = { name: 'Joe' };
+result = <() => any>_.createCallback('name');
+result = <() => boolean>_.createCallback(createCallbackObj);
+result = <_.LoDashImplicitObjectWrapper<() => any>>_('name').createCallback();
+result = <_.LoDashImplicitObjectWrapper<() => boolean>>_(createCallbackObj).createCallback();
+
+// _.curry
+var testCurryFn = (a: number, b: number, c: number) => [a, b, c];
+let curryResult0: number[]
+let curryResult1: _.CurriedFunction1<number, number[]>
+let curryResult2: _.CurriedFunction2<number, number, number[]>
+
+curryResult0 = _.curry(testCurryFn)(1, 2, 3);
+curryResult1 = _.curry(testCurryFn)(1, 2);
+curryResult0 = _.curry(testCurryFn)(1, 2)(3);
+curryResult0 = _.curry(testCurryFn)(1)(2)(3);
+curryResult2 = _.curry(testCurryFn)(1);
+curryResult1 = _.curry(testCurryFn)(1)(2);
+curryResult0 = _.curry(testCurryFn)(1)(2)(3);
+curryResult0 = _.curry(testCurryFn)(1)(2, 3);
+curryResult0 = _(testCurryFn).curry().value()(1, 2, 3);
+curryResult2 = _(testCurryFn).curry().value()(1);
+
+declare function testCurry2(a: string, b: number, c: boolean): [string, number, boolean];
+let curryResult3: [string, number, boolean];
+let curryResult4: _.CurriedFunction1<boolean, [string, number, boolean]>;
+let curryResult5: _.CurriedFunction2<number, boolean, [string, number, boolean]>;
+let curryResult6: _.CurriedFunction3<string, number, boolean, [string, number, boolean]>;
+curryResult3 = _.curry(testCurry2)("1", 2, true);
+curryResult3 = _.curry(testCurry2)("1", 2)(true);
+curryResult3 = _.curry(testCurry2)("1")(2, true);
+curryResult3 = _.curry(testCurry2)("1")(2)(true);
+curryResult4 = _.curry(testCurry2)("1", 2);
+curryResult4 = _.curry(testCurry2)("1")(2);
+curryResult5 = _.curry(testCurry2)("1");
+curryResult6 = _.curry(testCurry2);
+
+// _.curryRight
+var testCurryRightFn = (a: number, b: number, c: number) => [a, b, c];
+curryResult0 = _.curryRight(testCurryRightFn)(1, 2, 3);
+curryResult2 = _.curryRight(testCurryRightFn)(1);
+curryResult0 = _(testCurryRightFn).curryRight().value()(1, 2, 3);
+curryResult2 = _(testCurryRightFn).curryRight().value()(1);
+
+let curryResult7: _.CurriedFunction1<string, [string, number, boolean]>;
+let curryResult8: _.CurriedFunction2<number, string, [string, number, boolean]>;
+let curryResult9: _.CurriedFunction3<boolean, number, string, [string, number, boolean]>;
+curryResult3 = _.curryRight(testCurry2)(true, 2, "1");
+curryResult3 = _.curryRight(testCurry2)(true, 2)("1");
+curryResult3 = _.curryRight(testCurry2)(true)(2, "1");
+curryResult3 = _.curryRight(testCurry2)(true)(2)("1");
+curryResult7 = _.curryRight(testCurry2)(true, 2);
+curryResult7 = _.curryRight(testCurry2)(true)(2);
+curryResult8 = _.curryRight(testCurry2)(true);
+curryResult9 = _.curryRight(testCurry2);
+
+// _.debounce
+module TestDebounce {
+    interface SampleFunc {
+        (n: number, s: string): boolean;
+    }
+
+    interface Options {
+        leading?: boolean;
+        maxWait?: number;
+        trailing?: boolean;
+    }
+
+    interface ResultFunc {
+        (n: number, s: string): boolean;
+        cancel(): void;
+    }
+
+    let func: SampleFunc;
+    let options: Options;
+
+    {
+        let result: ResultFunc;
+
+        result = _.debounce<SampleFunc>(func);
+        result = _.debounce<SampleFunc>(func, 42);
+        result = _.debounce<SampleFunc>(func, 42, options);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<ResultFunc>;
+
+        result = _(func).debounce();
+        result = _(func).debounce(42);
+        result = _(func).debounce(42, options);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<ResultFunc>;
+
+        result = _(func).chain().debounce();
+        result = _(func).chain().debounce(42);
+        result = _(func).chain().debounce(42, options);
+    }
+}
+
+// _.defer
+module TestDefer {
+    type SampleFunc = (a: number, b: string) => boolean;
+
+    let func: SampleFunc;
+
+    {
+        let result: number;
+
+        result = _.defer<SampleFunc>(func);
+        result = _.defer<SampleFunc>(func, any);
+        result = _.defer<SampleFunc>(func, any, any);
+        result = _.defer<SampleFunc>(func, any, any, any);
+    }
+
+    {
+        let result: _.LoDashImplicitWrapper<number>;
+
+        result = _(func).defer();
+        result = _(func).defer(any);
+        result = _(func).defer(any, any);
+        result = _(func).defer(any, any, any);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(func).chain().defer();
+        result = _(func).chain().defer(any);
+        result = _(func).chain().defer(any, any);
+        result = _(func).chain().defer(any, any, any);
+    }
+}
+
+// _.delay
+module TestDelay {
+    type SampleFunc = (a: number, b: string) => boolean;
+
+    let func: SampleFunc;
+
+    {
+        let result: number;
+
+        result = _.delay<SampleFunc>(func, 1);
+        result = _.delay<SampleFunc>(func, 1, 2);
+        result = _.delay<SampleFunc>(func, 1, 2, '');
+    }
+
+    {
+        let result: _.LoDashImplicitWrapper<number>;
+
+        result = _(func).delay(1);
+        result = _(func).delay(1, 2);
+        result = _(func).delay(1, 2, '');
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(func).chain().delay(1);
+        result = _(func).chain().delay(1, 2);
+        result = _(func).chain().delay(1, 2, '');
+    }
+}
+
+// _.flow
+module TestFlow {
+    let Fn1: (n: number) => number;
+    let Fn2: (m: number, n: number) => number;
+
+    {
+        let result: (m: number, n: number) => number;
+
+        result = _.flow<(m: number, n: number) => number>(Fn1, Fn2);
+        result = _.flow<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
+        result = _.flow<(m: number, n: number) => number>(Fn1, Fn1, Fn1, Fn2);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(m: number, n: number) => number>;
+
+        result = _(Fn1).flow<(m: number, n: number) => number>(Fn2);
+        result = _(Fn1).flow<(m: number, n: number) => number>(Fn1, Fn2);
+        result = _(Fn1).flow<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(m: number, n: number) => number>;
+
+        result = _(Fn1).chain().flow<(m: number, n: number) => number>(Fn2);
+        result = _(Fn1).chain().flow<(m: number, n: number) => number>(Fn1, Fn2);
+        result = _(Fn1).chain().flow<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
+    }
+}
+
+// _.flowRight
+module TestFlowRight {
+    let Fn1: (n: number) => number;
+    let Fn2: (m: number, n: number) => number;
+
+    {
+        let result: (m: number, n: number) => number;
+
+        result = _.flowRight<(m: number, n: number) => number>(Fn1, Fn2);
+        result = _.flowRight<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
+        result = _.flowRight<(m: number, n: number) => number>(Fn1, Fn1, Fn1, Fn2);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(m: number, n: number) => number>;
+
+        result = _(Fn1).flowRight<(m: number, n: number) => number>(Fn2);
+        result = _(Fn1).flowRight<(m: number, n: number) => number>(Fn1, Fn2);
+        result = _(Fn1).flowRight<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(m: number, n: number) => number>;
+
+        result = _(Fn1).chain().flowRight<(m: number, n: number) => number>(Fn2);
+        result = _(Fn1).chain().flowRight<(m: number, n: number) => number>(Fn1, Fn2);
+        result = _(Fn1).chain().flowRight<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
+    }
+}
+
+// _.memoize
+var testMemoizedFunction: _.MemoizedFunction;
+result = <_.MapCache>testMemoizedFunction.cache;
+interface TestMemoizedResultFn extends _.MemoizedFunction {
+    (...args: any[]): any;
+}
+var testMemoizeFn: (...args: any[]) => any;
+var testMemoizeResolverFn: (...args: any[]) => any;
+result = <TestMemoizedResultFn>_.memoize<TestMemoizedResultFn>(testMemoizeFn);
+result = <TestMemoizedResultFn>_.memoize<TestMemoizedResultFn>(testMemoizeFn, testMemoizeResolverFn);
+result = <TestMemoizedResultFn>(_(testMemoizeFn).memoize<TestMemoizedResultFn>().value());
+result = <TestMemoizedResultFn>(_(testMemoizeFn).memoize<TestMemoizedResultFn>(testMemoizeResolverFn).value());
+
+// _.modArgs
+module TestModArgs {
+    type Func1 = (a: boolean) => boolean;
+    type Func2 = (a: boolean, b: boolean) => boolean;
+
+    let func1: Func1;
+    let func2: Func2;
+
+    let transform1: (a: string) => boolean;
+    let transform2: (b: number) => boolean;
+
+    {
+        let result: (a: string) => boolean;
+
+        result = _.modArgs<Func1, (a: string) => boolean>(func1, transform1);
+        result = _.modArgs<Func1, (a: string) => boolean>(func1, [transform1]);
+    }
+
+    {
+        let result: (a: string, b: number) => boolean;
+
+        result = _.modArgs<Func2, (a: string, b: number) => boolean>(func2, transform1, transform2);
+        result = _.modArgs<Func2, (a: string, b: number) => boolean>(func2, [transform1, transform2]);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(a: string) => boolean>;
+
+        result = _(func1).modArgs<(a: string) => boolean>(transform1);
+        result = _(func1).modArgs<(a: string) => boolean>([transform1]);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(a: string, b: number) => boolean>;
+
+        result = _(func2).modArgs<(a: string, b: number) => boolean>(transform1, transform2);
+        result = _(func2).modArgs<(a: string, b: number) => boolean>([transform1, transform2]);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(a: string) => boolean>;
+
+        result = _(func1).chain().modArgs<(a: string) => boolean>(transform1);
+        result = _(func1).chain().modArgs<(a: string) => boolean>([transform1]);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(a: string, b: number) => boolean>;
+
+        result = _(func2).chain().modArgs<(a: string, b: number) => boolean>(transform1, transform2);
+        result = _(func2).chain().modArgs<(a: string, b: number) => boolean>([transform1, transform2]);
+    }
+}
+
+// _.negate
+module TestNegate {
+    interface PredicateFn {
+        (a1: number, a2: number): boolean;
+    }
+
+    interface ResultFn {
+        (a1: number, a2: number): boolean;
+    }
+
+    var predicate = (a1: number, a2: number) => a1 > a2;
+
+    {
+        let result: ResultFn;
+
+        result = _.negate<PredicateFn>(predicate);
+        result = _.negate<PredicateFn, ResultFn>(predicate);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<ResultFn>;
+
+        result = _(predicate).negate();
+        result = _(predicate).negate<ResultFn>();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<ResultFn>;
+
+        result = _(predicate).chain().negate();
+        result = _(predicate).chain().negate<ResultFn>();
+    }
+}
+
+// _.once
+module TestOnce {
+    interface Func {
+        (a: number, b: string): boolean;
+    }
+
+    let func: Func;
+
+    {
+        let result: Func;
+
+        result = _.once(func);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<Func>;
+
+        result = _(func).once();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<Func>;
+
+        result = _(func).chain().once();
+    }
+}
+
+var greetPartial = function (greeting: string, name: string) { return greeting + ' ' + name; };
+var hi = _.partial(greetPartial, 'hi');
+hi('moe');
+
+
+var defaultsDeep = <Function>_.partialRight(_.merge, _.defaults);
+
+var optionsPartialRight = {
+    'variable': 'data',
+    'imports': { 'jq': $ }
+};
+
+defaultsDeep(optionsPartialRight, _.templateSettings);
+
+//_.rearg
+var testReargFn = (a: string, b: string, c: string) => [a, b, c];
+interface TestReargResultFn {
+    (b: string, c: string, a: string): string[];
+}
+result = <string[]>(_.rearg<TestReargResultFn>(testReargFn, 2, 0, 1))('b', 'c', 'a');
+result = <string[]>(_.rearg<TestReargResultFn>(testReargFn, [2, 0, 1]))('b', 'c', 'a');
+result = <string[]>(_(testReargFn).rearg<TestReargResultFn>(2, 0, 1).value())('b', 'c', 'a');
+result = <string[]>(_(testReargFn).rearg<TestReargResultFn>([2, 0, 1]).value())('b', 'c', 'a');
+
+// _.restParam
+module TestRestParam {
+    type Func = (a: string, b: number[]) => boolean;
+    type ResultFunc = (a: string, ...b: number[]) => boolean;
+
+    let func: Func;
+
+    {
+        let result: ResultFunc;
+
+        result = _.restParam<ResultFunc>(func);
+        result = _.restParam<ResultFunc>(func, 1);
+
+        result = _.restParam<ResultFunc, Func>(func);
+        result = _.restParam<ResultFunc, Func>(func, 1);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<ResultFunc>;
+
+        result = _(func).restParam<ResultFunc>();
+        result = _(func).restParam<ResultFunc>(1);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<ResultFunc>;
+
+        result = _(func).chain().restParam<ResultFunc>();
+        result = _(func).chain().restParam<ResultFunc>(1);
+    }
+}
+
+//_.spread
+module TestSpread {
+    type SampleFunc = (args: (number|string)[]) => boolean;
+    type SampleResult = (a: number, b: string) => boolean;
+
+    let func: SampleFunc;
+
+    {
+        let result: SampleResult;
+
+        result = _.spread<SampleFunc, SampleResult>(func);
+        result = _.spread<SampleResult>(func);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<SampleResult>;
+
+        result = _(func).spread<SampleResult>();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<SampleResult>;
+
+        result = _(func).chain().spread<SampleResult>();
+    }
+}
+
+// _.throttle
+module TestThrottle {
+    interface SampleFunc {
+        (n: number, s: string): boolean;
+    }
+
+    interface Options {
+        leading?: boolean;
+        trailing?: boolean;
+    }
+
+    interface ResultFunc {
+        (n: number, s: string): boolean;
+        cancel(): void;
+    }
+
+    let func: SampleFunc;
+    let options: Options;
+
+    {
+        let result: ResultFunc;
+
+        result = _.throttle<SampleFunc>(func);
+        result = _.throttle<SampleFunc>(func, 42);
+        result = _.throttle<SampleFunc>(func, 42, options);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<ResultFunc>;
+
+        result = _(func).throttle();
+        result = _(func).throttle(42);
+        result = _(func).throttle(42, options);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<ResultFunc>;
+
+        result = _(func).chain().throttle();
+        result = _(func).chain().throttle(42);
+        result = _(func).chain().throttle(42, options);
+    }
+}
+
+// _.wrap
+module TestWrap {
+    type SampleValue = {a: number; b: string; c: boolean}
+    type SampleResult = (arg2: number, arg3: string) => boolean;
+
+    {
+        type SampleWrapper = (arg1: SampleValue, arg2: number, arg3: string) => boolean;
+
+        let value: SampleValue;
+        let wrapper: SampleWrapper;
+        let result: SampleResult;
+
+        result = _.wrap<SampleValue, SampleWrapper, SampleResult>(value, wrapper);
+        result = _.wrap<SampleValue, SampleResult>(value, wrapper);
+        result = _.wrap<SampleResult>(value, wrapper);
+    }
+
+    {
+        type SampleWrapper = (arg1: number, arg2: number, arg3: string) => boolean;
+
+        let value: number;
+        let wrapper: SampleWrapper;
+        let result: _.LoDashImplicitObjectWrapper<SampleResult>;
+
+        result = _(value).wrap<SampleWrapper, SampleResult>(wrapper);
+        result = _(value).wrap<SampleResult>(wrapper);
+    }
+
+    {
+        type SampleWrapper = (arg1: number[], arg2: number, arg3: string) => boolean;
+
+        let value: number[];
+        let wrapper: SampleWrapper;
+        let result: _.LoDashImplicitObjectWrapper<SampleResult>;
+
+        result = _(value).wrap<SampleWrapper, SampleResult>(wrapper);
+        result = _(value).wrap<SampleResult>(wrapper);
+    }
+
+    {
+        type SampleWrapper = (arg1: SampleValue, arg2: number, arg3: string) => boolean;
+
+        let value: SampleValue;
+        let wrapper: SampleWrapper;
+        let result: _.LoDashImplicitObjectWrapper<SampleResult>;
+
+        result = _(value).wrap<SampleWrapper, SampleResult>(wrapper);
+        result = _(value).wrap<SampleResult>(wrapper);
+    }
+
+    {
+        type SampleWrapper = (arg1: number, arg2: number, arg3: string) => boolean;
+
+        let value: number;
+        let wrapper: SampleWrapper;
+        let result: _.LoDashExplicitObjectWrapper<SampleResult>;
+
+        result = _(value).chain().wrap<SampleWrapper, SampleResult>(wrapper);
+        result = _(value).chain().wrap<SampleResult>(wrapper);
+    }
+
+    {
+        type SampleWrapper = (arg1: number[], arg2: number, arg3: string) => boolean;
+
+        let value: number[];
+        let wrapper: SampleWrapper;
+        let result: _.LoDashExplicitObjectWrapper<SampleResult>;
+
+        result = _(value).chain().wrap<SampleWrapper, SampleResult>(wrapper);
+        result = _(value).chain().wrap<SampleResult>(wrapper);
+    }
+
+    {
+        type SampleWrapper = (arg1: SampleValue, arg2: number, arg3: string) => boolean;
+
+        let value: SampleValue;
+        let wrapper: SampleWrapper;
+        let result: _.LoDashExplicitObjectWrapper<SampleResult>;
+
+        result = _(value).chain().wrap<SampleWrapper, SampleResult>(wrapper);
+        result = _(value).chain().wrap<SampleResult>(wrapper);
+    }
+}
+
+/********
+ * Lang *
+ ********/
+
+// _.clone
+interface TestCloneCustomizerFn {
+    (value: any): any;
+}
+var testCloneCustomizerFn: TestCloneCustomizerFn;
+{
+    let result: number;
+    result = _.clone<number>(42);
+    result = _.clone<number>(42, false);
+    result = _.clone<number>(42, false, testCloneCustomizerFn);
+    result = _.clone<number>(42, false, testCloneCustomizerFn, any);
+    result = _.clone<number>(42, testCloneCustomizerFn);
+    result = _.clone<number>(42, testCloneCustomizerFn, any);
+    result = _(42).clone();
+    result = _(42).clone(false);
+    result = _(42).clone(false, testCloneCustomizerFn);
+    result = _(42).clone(false, testCloneCustomizerFn, any);
+    result = _(42).clone(testCloneCustomizerFn);
+    result = _(42).clone(testCloneCustomizerFn, any);
+}
+{
+    let result: string[];
+    result = _.clone<string[]>([]);
+    result = _.clone<string[]>([], false);
+    result = _.clone<string[]>([], false, testCloneCustomizerFn);
+    result = _.clone<string[]>([], false, testCloneCustomizerFn, any);
+    result = _.clone<string[]>([], testCloneCustomizerFn);
+    result = _.clone<string[]>([], testCloneCustomizerFn, any);
+    result = _<string>([]).clone();
+    result = _<string>([]).clone(false);
+    result = _<string>([]).clone(false, testCloneCustomizerFn);
+    result = _<string>([]).clone(false, testCloneCustomizerFn, any);
+    result = _<string>([]).clone(testCloneCustomizerFn);
+    result = _<string>([]).clone(testCloneCustomizerFn, any);
+}
+{
+    let result: {a: {b: number;}};
+    result = _.clone<{a: {b: number;}}>({a: {b: 2}});
+    result = _.clone<{a: {b: number;}}>({a: {b: 2}}, false);
+    result = _.clone<{a: {b: number;}}>({a: {b: 2}}, false, testCloneCustomizerFn);
+    result = _.clone<{a: {b: number;}}>({a: {b: 2}}, false, testCloneCustomizerFn, any);
+    result = _.clone<{a: {b: number;}}>({a: {b: 2}}, testCloneCustomizerFn);
+    result = _.clone<{a: {b: number;}}>({a: {b: 2}}, testCloneCustomizerFn, any);
+    result = _({a: {b: 2}}).clone();
+    result = _({a: {b: 2}}).clone(false);
+    result = _({a: {b: 2}}).clone(false, testCloneCustomizerFn);
+    result = _({a: {b: 2}}).clone(false, testCloneCustomizerFn, any);
+    result = _({a: {b: 2}}).clone(testCloneCustomizerFn);
+    result = _({a: {b: 2}}).clone(testCloneCustomizerFn, any);
+}
+
+// _.cloneDeep
+interface TestCloneDeepCustomizerFn {
+    (value: any): any;
+}
+var testCloneDeepCustomizerFn: TestCloneDeepCustomizerFn;
+{
+    let result: number;
+    result = _.cloneDeep<number>(42);
+    result = _.cloneDeep<number>(42, testCloneDeepCustomizerFn);
+    result = _.cloneDeep<number>(42, testCloneDeepCustomizerFn, any);
+    result = _(42).cloneDeep();
+    result = _(42).cloneDeep(testCloneDeepCustomizerFn);
+    result = _(42).cloneDeep(testCloneDeepCustomizerFn, any);
+}
+{
+    let result: string[];
+    result = _.cloneDeep<string[]>([]);
+    result = _.cloneDeep<string[]>([], testCloneDeepCustomizerFn);
+    result = _.cloneDeep<string[]>([], testCloneDeepCustomizerFn, any);
+    result = _<string>([]).cloneDeep();
+    result = _<string>([]).cloneDeep(testCloneDeepCustomizerFn);
+    result = _<string>([]).cloneDeep(testCloneDeepCustomizerFn, any);
+}
+{
+    let result: {a: {b: number;}};
+    result = _.cloneDeep<{a: {b: number;}}>({a: {b: 2}});
+    result = _.cloneDeep<{a: {b: number;}}>({a: {b: 2}}, testCloneDeepCustomizerFn);
+    result = _.cloneDeep<{a: {b: number;}}>({a: {b: 2}}, testCloneDeepCustomizerFn, any);
+    result = _({a: {b: 2}}).cloneDeep();
+    result = _({a: {b: 2}}).cloneDeep(testCloneDeepCustomizerFn);
+    result = _({a: {b: 2}}).cloneDeep(testCloneDeepCustomizerFn, any);
+}
+
+// _.eq
+module TestEq {
+    let customizer: (value: any, other: any, indexOrKey?: number|string) => boolean;
+
+    {
+        let result: boolean;
+
+        result = _.eq(any, any);
+        result = _.eq(any, any, customizer);
+        result = _.eq(any, any, customizer, any);
+
+        result = _(any).eq(any);
+        result = _(any).eq(any, customizer);
+        result = _(any).eq(any, customizer, any);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(any).chain().eq(any);
+        result = _(any).chain().eq(any, customizer);
+        result = _(any).chain().eq(any, customizer, any);
+    }
+}
+
+// _.gt
+module TestGt {
+    {
+        let result: boolean;
+
+        result = _.gt(any, any);
+        result = _(1).gt(any);
+        result = _([]).gt(any);
+        result = _({}).gt(any);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().gt(any);
+        result = _([]).chain().gt(any);
+        result = _({}).chain().gt(any);
+    }
+}
+
+// _.gte
+module TestGte {
+    {
+        let result: boolean;
+
+        result = _.gte(any, any);
+        result = _(1).gte(any);
+        result = _([]).gte(any);
+        result = _({}).gte(any);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().gte(any);
+        result = _([]).chain().gte(any);
+        result = _({}).chain().gte(any);
+    }
+}
+
+// _.isArguments
+module TestisArguments {
+    {
+        let value: number|IArguments;
+
+        if (_.isArguments(value)) {
+            let result: IArguments = value;
+        }
+        else {
+            let result: number = value;
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isArguments(any);
+        result = _(1).isArguments();
+        result = _<any>([]).isArguments();
+        result = _({}).isArguments();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isArguments();
+        result = _<any>([]).chain().isArguments();
+        result = _({}).chain().isArguments();
+    }
+}
+
+// _.isArray
+module TestIsArray {
+    {
+        let value: number|string[]|boolean[];
+
+        if (_.isArray<string>(value)) {
+            let result: string[] = value;
+        }
+        else {
+            if (_.isArray<boolean>(value)) {
+                let result: boolean[] = value;
+            }
+            else {
+                let result: number = value;
+            }
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isArray(any);
+        result = _(1).isArray();
+        result = _<any>([]).isArray();
+        result = _({}).isArray();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isArray();
+        result = _<any>([]).chain().isArray();
+        result = _({}).chain().isArray();
+    }
+}
+
+// _.isBoolean
+module TestIsBoolean {
+    {
+        let value: number|boolean;
+
+        if (_.isBoolean(value)) {
+            let result: boolean = value;
+        }
+        else {
+            let result: number = value;
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isBoolean(any);
+        result = _(1).isBoolean();
+        result = _<any>([]).isBoolean();
+        result = _({}).isBoolean();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isBoolean();
+        result = _<any>([]).chain().isBoolean();
+        result = _({}).chain().isBoolean();
+    }
+}
+
+// _.isDate
+module TestIsBoolean {
+    {
+        let value: number|Date;
+
+        if (_.isDate(value)) {
+            let result: Date = value;
+        }
+        else {
+            let result: number = value;
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isDate(any);
+        result = _(42).isDate();
+        result = _<any>([]).isDate();
+        result = _({}).isDate();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(42).chain().isDate();
+        result = _<any>([]).chain().isDate();
+        result = _({}).chain().isDate();
+    }
+}
+
+// _.isElement
+module TestIsElement {
+    {
+        let result: boolean;
+
+        result = _.isElement(any);
+
+        result = _(42).isElement();
+        result = _<any>([]).isElement();
+        result = _({}).isElement();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(42).chain().isElement();
+        result = _<any>([]).chain().isElement();
+        result = _({}).chain().isElement();
+    }
+}
+
+// _.isEmpty
+result = <boolean>_.isEmpty([1, 2, 3]);
+result = <boolean>_.isEmpty({});
+result = <boolean>_.isEmpty('');
+result = <boolean>_([1, 2, 3]).isEmpty();
+result = <boolean>_({}).isEmpty();
+result = <boolean>_('').isEmpty();
+
+// _.isEqual
+module TestIsEqual {
+    let customizer: (value: any, other: any, indexOrKey?: number|string) => boolean;
+
+    {
+        let result: boolean;
+
+        result = _.isEqual(any, any);
+        result = _.isEqual(any, any, customizer);
+        result = _.isEqual(any, any, customizer, any);
+
+        result = _(any).isEqual(any);
+        result = _(any).isEqual(any, customizer);
+        result = _(any).isEqual(any, customizer, any);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(any).chain().isEqual(any);
+        result = _(any).chain().isEqual(any, customizer);
+        result = _(any).chain().isEqual(any, customizer, any);
+    }
+}
+
+// _.isError
+module TestIsError {
+    {
+        let value: number|Error;
+
+        if (_.isError(value)) {
+            let result: Error = value;
+        }
+        else {
+            let result: number = value;
+        }
+    }
+
+    {
+        class CustomError extends Error {}
+
+        let value: number|CustomError;
+
+        if (_.isError(value)) {
+            let result: CustomError = value;
+        }
+        else {
+            let result: number = value;
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isError(any);
+        result = _(1).isError();
+        result = _<any>([]).isError();
+        result = _({}).isError();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isError();
+        result = _<any>([]).chain().isError();
+        result = _({}).chain().isError();
+    }
+}
+
+// _.isFinite
+module TestIsFinite {
+    {
+        let result: boolean;
+
+        result = _.isFinite(any);
+        result = _(1).isFinite();
+        result = _<any>([]).isFinite();
+        result = _({}).isFinite();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isFinite();
+        result = _<any>([]).chain().isFinite();
+        result = _({}).chain().isFinite();
+    }
+}
+
+// _.isFunction
+module TestIsFunction {
+    {
+        let value: number|Function;
+
+        if (_.isFunction(value)) {
+            let result: Function = value;
+        }
+        else {
+            let result: number = value;
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isFunction(any);
+        result = _(1).isFunction();
+        result = _<any>([]).isFunction();
+        result = _({}).isFunction();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isFunction();
+        result = _<any>([]).chain().isFunction();
+        result = _({}).chain().isFunction();
+    }
+}
+
+// _.isMatch
+var testIsMatchCustiomizerFn: (value: any, other: any, indexOrKey: number|string) => boolean;
+result = <boolean>_.isMatch({}, {});
+result = <boolean>_.isMatch({}, {}, testIsMatchCustiomizerFn);
+result = <boolean>_.isMatch({}, {}, testIsMatchCustiomizerFn, {});
+result = <boolean>_({}).isMatch({});
+result = <boolean>_({}).isMatch({}, testIsMatchCustiomizerFn);
+result = <boolean>_({}).isMatch({}, testIsMatchCustiomizerFn, {});
+
+// _.isNaN
+module TestIsNaN {
+    {
+        let result: boolean;
+
+        result = _.isNaN(any);
+
+        result = _(1).isNaN();
+        result = _<any>([]).isNaN();
+        result = _({}).isNaN();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isNaN();
+        result = _<any>([]).chain().isNaN();
+        result = _({}).chain().isNaN();
+    }
+}
+
+// _.isNative
+module TestIsNative {
+    {
+        let value: number|Function;
+
+        if (_.isNative(value)) {
+            let result: Function = value;
+        }
+        else {
+            let result: number = value;
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isNative(any);
+
+        result = _(1).isNative();
+        result = _<any>([]).isNative();
+        result = _({}).isNative();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isNative();
+        result = _<any>([]).chain().isNative();
+        result = _({}).chain().isNative();
+    }
+}
+
+// _.isNull
+module TestIsNull {
+    {
+        let result: boolean;
+
+        result = _.isNull(any);
+
+        result = _(1).isNull();
+        result = _<any>([]).isNull();
+        result = _({}).isNull();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isNull();
+        result = _<any>([]).chain().isNull();
+        result = _({}).chain().isNull();
+    }
+}
+
+// _.isNumber
+module TestIsNumber {
+    {
+        let value: string|number;
+
+        if (_.isNumber(value)) {
+            let result: number = value;
+        }
+        else {
+            let result: string = value;
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isNumber(any);
+
+        result = _(1).isNumber();
+        result = _<any>([]).isNumber();
+        result = _({}).isNumber();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isNumber();
+        result = _<any>([]).chain().isNumber();
+        result = _({}).chain().isNumber();
+    }
+}
+
+// _.isObject
+module TestIsObject {
+    {
+        let result: boolean;
+
+        result = _.isObject(any);
+        result = _(1).isObject();
+        result = _<any>([]).isObject();
+        result = _({}).isObject();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isObject();
+        result = _<any>([]).chain().isObject();
+        result = _({}).chain().isObject();
+    }
+}
+
+// _.isPlainObject
+module TestIsPlainObject {
+    {
+        let result: boolean;
+
+        result = _.isPlainObject(any);
+        result = _(1).isPlainObject();
+        result = _<any>([]).isPlainObject();
+        result = _({}).isPlainObject();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isPlainObject();
+        result = _<any>([]).chain().isPlainObject();
+        result = _({}).chain().isPlainObject();
+    }
+}
+
+// _.isRegExp
+module TestIsRegExp {
+    {
+        let value: number|RegExp;
+
+        if (_.isRegExp(value)) {
+            let result: RegExp = value;
+        }
+        else {
+            let result: number = value;
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isRegExp(any);
+        result = _(1).isRegExp();
+        result = _<any>([]).isRegExp();
+        result = _({}).isRegExp();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isRegExp();
+        result = _<any>([]).chain().isRegExp();
+        result = _({}).chain().isRegExp();
+    }
+}
+
+// _.isString
+module TestIsString {
+    {
+        let value: number|string;
+
+        if (_.isString(value)) {
+            let result: string = value;
+        }
+        else {
+            let result: number = value;
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isString(any);
+        result = _(1).isString();
+        result = _<any>([]).isString();
+        result = _({}).isString();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isString();
+        result = _<any>([]).chain().isString();
+        result = _({}).chain().isString();
+    }
+}
+
+// _.isTypedArray
+module TestIsTypedArray {
+    {
+        let result: boolean;
+
+        result = _.isTypedArray([]);
+        result = _([]).isTypedArray();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _([]).chain().isTypedArray();
+    }
+}
+
+// _.isUndefined
+module TestIsUndefined {
+    {
+        let result: boolean;
+
+        result = _.isUndefined(any);
+
+        result = _(1).isUndefined();
+        result = _<any>([]).isUndefined();
+        result = _({}).isUndefined();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isUndefined();
+        result = _<any>([]).chain().isUndefined();
+        result = _({}).chain().isUndefined();
+    }
+}
+
+// _.lt
+module TestLt {
+    {
+        let result: boolean;
+
+        result = _.lt(any, any);
+        result = _(1).lt(any);
+        result = _([]).lt(any);
+        result = _({}).lt(any);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().lt(any);
+        result = _([]).chain().lt(any);
+        result = _({}).chain().lt(any);
+    }
+}
+
+// _.lte
+module TestLte {
+    {
+        let result: boolean;
+
+        result = _.lte(any, any);
+        result = _(1).lte(any);
+        result = _([]).lte(any);
+        result = _({}).lte(any);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().lte(any);
+        result = _([]).chain().lte(any);
+        result = _({}).chain().lte(any);
+    }
+}
+
+// _.toArray
+module TestToArray {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+    let numericDictionary: _.NumericDictionary<TResult>;
+
+    {
+        let result: string[];
+
+        result = _.toArray<string>('');
+        result = _.toArray('');
+    }
+
+    {
+        let result: TResult[];
+
+        result = _.toArray<TResult>(array);
+        result = _.toArray<TResult>(list);
+        result = _.toArray<TResult>(dictionary);
+        result = _.toArray<TResult>(numericDictionary);
+
+        result = _.toArray(array);
+        result = _.toArray(list);
+        result = _.toArray(dictionary);
+        result = _.toArray(numericDictionary);
+    }
+
+    {
+        let result: any[];
+
+        result = _.toArray();
+        result = _.toArray(42);
+        result = _.toArray(true);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(array).toArray();
+        result = _(list).toArray<TResult>();
+        result = _(dictionary).toArray<TResult>();
+        result = _(numericDictionary).toArray<TResult>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(array).chain().toArray();
+        result = _(list).chain().toArray<TResult>();
+        result = _(dictionary).chain().toArray<TResult>();
+        result = _(numericDictionary).chain().toArray<TResult>();
+    }
+}
+
+// _.toPlainObject
+module TestToPlainObject {
+    let result: TResult;
+
+    result = _.toPlainObject<TResult>();
+    result = _.toPlainObject<TResult>(true);
+    result = _.toPlainObject<TResult>(1);
+    result = _.toPlainObject<TResult>('a');
+    result = _.toPlainObject<TResult>([]);
+    result = _.toPlainObject<TResult>({});
+
+    result = _(true).toPlainObject<TResult>().value();
+    result = _(1).toPlainObject<TResult>().value();
+    result = _('a').toPlainObject<TResult>().value();
+    result = _([1]).toPlainObject<TResult>().value();
+    result = _<string>([]).toPlainObject<TResult>().value();
+    result = _({}).toPlainObject<TResult>().value();
+}
+
+/********
+ * Math *
+ ********/
+
+// _.add
+module TestAdd {
+    {
+        let result: number;
+
+        result = _.add(1, 1);
+        result = _(1).add(1);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(1).chain().add(1);
+    }
+}
+
+// _.ceil
+module TestCeil {
+    {
+        let result: number;
+
+        result = _.ceil(6.004);
+        result = _.ceil(6.004, 2);
+
+        result = _(6.004).ceil();
+        result = _(6.004).ceil(2);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(6.004).chain().ceil();
+        result = _(6.004).chain().ceil(2);
+    }
+}
+
+// _.floor
+module TestFloor {
+    {
+        let result: number;
+
+        result = _.floor(4.006);
+        result = _.floor(0.046, 2);
+        result = _.floor(4060, -2);
+
+        result = _(4.006).floor();
+        result = _(0.046).floor(2);
+        result = _(4060).floor(-2);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(4.006).chain().floor();
+        result = _(0.046).chain().floor(2);
+        result = _(4060).chain().floor(-2);
+    }
+}
+
+// _.max
+module TestMax {
+    let array: number[];
+    let list: _.List<number>;
+    let dictionary: _.Dictionary<number>;
+
+    let listIterator: (value: number, index: number, collection: _.List<number>) => number;
+    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => number;
+
+    let result: number;
+
+    result = _.max<number>(array);
+    result = _.max<number>(array, listIterator);
+    result = _.max<number>(array, listIterator, any);
+    result = _.max<number>(array, '');
+    result = _.max<{a: number}, number>(array, {a: 42});
+
+    result = _.max<number>(list);
+    result = _.max<number>(list, listIterator);
+    result = _.max<number>(list, listIterator, any);
+    result = _.max<number>(list, '');
+    result = _.max<{a: number}, number>(list, {a: 42});
+
+    result = _.max<number>(dictionary);
+    result = _.max<number>(dictionary, dictionaryIterator);
+    result = _.max<number>(dictionary, dictionaryIterator, any);
+    result = _.max<number>(dictionary, '');
+    result = _.max<{a: number}, number>(dictionary, {a: 42});
+
+    result = _(array).max();
+    result = _(array).max(listIterator);
+    result = _(array).max(listIterator, any);
+    result = _(array).max('');
+    result = _(array).max<{a: number}>({a: 42});
+
+    result = _(list).max<number>();
+    result = _(list).max<number>(listIterator);
+    result = _(list).max<number>(listIterator, any);
+    result = _(list).max<number>('');
+    result = _(list).max<{a: number}, number>({a: 42});
+
+    result = _(dictionary).max<number>();
+    result = _(dictionary).max<number>(dictionaryIterator);
+    result = _(dictionary).max<number>(dictionaryIterator, any);
+    result = _(dictionary).max<number>('');
+    result = _(dictionary).max<{a: number}, number>({a: 42});
+}
+
+// _.min
+module TestMin {
+    let array: number[];
+    let list: _.List<number>;
+    let dictionary: _.Dictionary<number>;
+
+    let listIterator: (value: number, index: number, collection: _.List<number>) => number;
+    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => number;
+
+    let result: number;
+
+    result = _.min<number>(array);
+    result = _.min<number>(array, listIterator);
+    result = _.min<number>(array, listIterator, any);
+    result = _.min<number>(array, '');
+    result = _.min<{a: number}, number>(array, {a: 42});
+
+    result = _.min<number>(list);
+    result = _.min<number>(list, listIterator);
+    result = _.min<number>(list, listIterator, any);
+    result = _.min<number>(list, '');
+    result = _.min<{a: number}, number>(list, {a: 42});
+
+    result = _.min<number>(dictionary);
+    result = _.min<number>(dictionary, dictionaryIterator);
+    result = _.min<number>(dictionary, dictionaryIterator, any);
+    result = _.min<number>(dictionary, '');
+    result = _.min<{a: number}, number>(dictionary, {a: 42});
+
+    result = _(array).min();
+    result = _(array).min(listIterator);
+    result = _(array).min(listIterator, any);
+    result = _(array).min('');
+    result = _(array).min<{a: number}>({a: 42});
+
+    result = _(list).min<number>();
+    result = _(list).min<number>(listIterator);
+    result = _(list).min<number>(listIterator, any);
+    result = _(list).min<number>('');
+    result = _(list).min<{a: number}, number>({a: 42});
+
+    result = _(dictionary).min<number>();
+    result = _(dictionary).min<number>(dictionaryIterator);
+    result = _(dictionary).min<number>(dictionaryIterator, any);
+    result = _(dictionary).min<number>('');
+    result = _(dictionary).min<{a: number}, number>({a: 42});
+}
+
+// _.round
+module TestRound {
+    {
+        let result: number;
+
+        result = _.round(4.006);
+        result = _.round(4.006, 2);
+
+        result = _(4.006).round();
+        result = _(4.006).round(2);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(4.006).chain().round();
+        result = _(4.006).chain().round(2);
+    }
+}
+
+// _.sum
+module TestSum {
+    let array: number[];
+    let list: _.List<number>;
+    let dictionary: _.Dictionary<number>;
+
+    let listIterator: (value: number, index: number, collection: _.List<number>) => number;
+    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => number;
+
+    {
+        let result: number;
+
+        result = _.sum(array);
+        result = _.sum<number>(array);
+        result = _.sum<number>(array, listIterator);
+        result = _.sum<number>(array, listIterator, any);
+        result = _.sum<number>(array, '');
+
+
+        result = _.sum(list);
+        result = _.sum<number>(list);
+        result = _.sum<number>(list, listIterator);
+        result = _.sum<number>(list, listIterator, any);
+        result = _.sum<number>(list, '');
+
+        result = _.sum(dictionary);
+        result = _.sum<number>(dictionary);
+        result = _.sum<number>(dictionary, dictionaryIterator);
+        result = _.sum<number>(dictionary, dictionaryIterator, any);
+        result = _.sum<number>(dictionary, '');
+
+        result = _(array).sum();
+        result = _(array).sum(listIterator);
+        result = _(array).sum(listIterator, any);
+        result = _(array).sum('');
+
+
+        result = _(list).sum();
+        result = _(list).sum<number>(listIterator);
+        result = _(list).sum<number>(listIterator, any);
+        result = _(list).sum('');
+
+        result = _(dictionary).sum();
+        result = _(dictionary).sum<number>(dictionaryIterator);
+        result = _(dictionary).sum<number>(dictionaryIterator, any);
+        result = _(dictionary).sum('');
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(array).chain().sum();
+        result = _(array).chain().sum(listIterator);
+        result = _(array).chain().sum(listIterator, any);
+        result = _(array).chain().sum('');
+
+
+        result = _(list).chain().sum();
+        result = _(list).chain().sum<number>(listIterator);
+        result = _(list).chain().sum<number>(listIterator, any);
+        result = _(list).chain().sum('');
+
+        result = _(dictionary).chain().sum();
+        result = _(dictionary).chain().sum<number>(dictionaryIterator);
+        result = _(dictionary).chain().sum<number>(dictionaryIterator, any);
+        result = _(dictionary).chain().sum('');
+    }
+}
+
+/**********
+ * Number *
+ **********/
+
+// _.inRange
+module TestInRange {
+    {
+        let result: boolean;
+
+        result = _.inRange(3, 2, 4);
+        result = _.inRange(4, 8);
+
+        result = _(3).inRange(2, 4);
+        result = _(4).inRange(8);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(3).chain().inRange(2, 4);
+        result = _(4).chain().inRange(8);
+    }
+}
+
+// _.random
+module TestRandom {
+    {
+        let result: number;
+
+        result = _.random();
+        result = _.random(1);
+        result = _.random(1, 2);
+        result = _.random(1, 2, true);
+        result = _.random(1, true);
+        result = _.random(true);
+
+        result = _(1).random();
+        result = _(1).random(2);
+        result = _(1).random(2, true);
+        result = _(1).random(true);
+        result = _(true).random();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(1).chain().random();
+        result = _(1).chain().random(2);
+        result = _(1).chain().random(2, true);
+        result = _(1).chain().random(true);
+        result = _(true).chain().random();
+    }
+}
+
+/**********
+ * Object *
+ **********/
+
+// _.assign
+module TestAssign {
+    interface Obj {a: string};
+    interface S1 {a: number};
+    interface S2 {b: number};
+    interface S3 {c: number};
+    interface S4 {d: number};
+    interface S5 {e: number};
+
+    let obj: Obj;
+    let s1: S1;
+    let s2: S2;
+    let s3: S3;
+    let s4: S4;
+    let s5: S5;
+
+    let customizer: (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}) => any;
+
+    {
+        let result: Obj;
+
+        result = _.assign<Obj>(obj);
+    }
+
+    {
+        let result: {a: number};
+
+        result = _.assign<Obj, S1, {a: number}>(obj, s1);
+        result = _.assign<Obj, S1, {a: number}>(obj, s1, customizer);
+        result = _.assign<Obj, S1, {a: number}>(obj, s1, customizer, any);
+    }
+
+    {
+        let result: {a: number, b: number};
+
+        result = _.assign<Obj, S1, S2, {a: number, b: number}>(obj, s1, s2);
+        result = _.assign<Obj, S1, S2, {a: number, b: number}>(obj, s1, s2, customizer);
+        result = _.assign<Obj, S1, S2, {a: number, b: number}>(obj, s1, s2, customizer, any);
+    }
+
+    {
+        let result: {a: number, b: number, c: number};
+
+        result = _.assign<Obj, S1, S2, S3, {a: number, b: number, c: number}>(obj, s1, s2, s3);
+        result = _.assign<Obj, S1, S2, S3, {a: number, b: number, c: number}>(obj, s1, s2, s3, customizer);
+        result = _.assign<Obj, S1, S2, S3, {a: number, b: number, c: number}>(obj, s1, s2, s3, customizer, any);
+    }
+
+    {
+        let result: {a: number, b: number, c: number, d: number};
+
+        result = _.assign<Obj, S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(obj, s1, s2, s3, s4);
+        result = _.assign<Obj, S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(obj, s1, s2, s3, s4, customizer);
+        result = _.assign<Obj, S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(obj, s1, s2, s3, s4, customizer, any);
+    }
+
+    {
+        let result: {a: number, b: number, c: number, d: number, e: number};
+
+        result = _.assign<Obj, {a: number, b: number, c: number, d: number, e: number}>(obj, s1, s2, s3, s4, s5);
+        result = _.assign<Obj, {a: number, b: number, c: number, d: number, e: number}>(obj, s1, s2, s3, s4, s5, customizer);
+        result = _.assign<Obj, {a: number, b: number, c: number, d: number, e: number}>(obj, s1, s2, s3, s4, s5, customizer, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<Obj>;
+
+        result = _(obj).assign();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number}>;
+
+        result = _(obj).assign<S1, {a: number}>(s1);
+        result = _(obj).assign<S1, {a: number}>(s1, customizer);
+        result = _(obj).assign<S1, {a: number}>(s1, customizer, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number}>;
+
+        result = _(obj).assign<S1, S2, {a: number, b: number}>(s1, s2);
+        result = _(obj).assign<S1, S2, {a: number, b: number}>(s1, s2, customizer);
+        result = _(obj).assign<S1, S2, {a: number, b: number}>(s1, s2, customizer, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number}>;
+
+        result = _(obj).assign<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3);
+        result = _(obj).assign<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3, customizer);
+        result = _(obj).assign<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3, customizer, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number, d: number}>;
+
+        result = _(obj).assign<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4);
+        result = _(obj).assign<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4, customizer);
+        result = _(obj).assign<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4, customizer, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number, d: number, e: number}>;
+
+        result = _(obj).assign<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5);
+        result = _(obj).assign<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5, customizer);
+        result = _(obj).assign<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5, customizer, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<Obj>;
+
+        result = _(obj).chain().assign();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number}>;
+
+        result = _(obj).chain().assign<S1, {a: number}>(s1);
+        result = _(obj).chain().assign<S1, {a: number}>(s1, customizer);
+        result = _(obj).chain().assign<S1, {a: number}>(s1, customizer, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number}>;
+
+        result = _(obj).chain().assign<S1, S2, {a: number, b: number}>(s1, s2);
+        result = _(obj).chain().assign<S1, S2, {a: number, b: number}>(s1, s2, customizer);
+        result = _(obj).chain().assign<S1, S2, {a: number, b: number}>(s1, s2, customizer, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number}>;
+
+        result = _(obj).chain().assign<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3);
+        result = _(obj).chain().assign<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3, customizer);
+        result = _(obj).chain().assign<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3, customizer, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number, d: number}>;
+
+        result = _(obj).chain().assign<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4);
+        result = _(obj).chain().assign<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4, customizer);
+        result = _(obj).chain().assign<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4, customizer, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number, d: number, e: number}>;
+
+        result = _(obj).chain().assign<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5);
+        result = _(obj).chain().assign<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5, customizer);
+        result = _(obj).chain().assign<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5, customizer, any);
+    }
+}
+
+// _.create
+module TestCreate {
+    type SampleProto = {a: number};
+    type SampleProps = {b: string};
+
+    let prototype: SampleProto;
+    let properties: SampleProps;
+
+    {
+        let result: {a: number; b: string};
+
+        result = _.create<SampleProto, SampleProps>(prototype, properties);
+        result = _.create(prototype, properties);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number; b: string}>;
+
+        result = _(prototype).create<SampleProps>(properties);
+        result = _(prototype).create(properties);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number; b: string}>;
+
+        result = _(prototype).chain().create<SampleProps>(properties);
+        result = _(prototype).chain().create(properties);
+    }
+}
+
+// _.defaults
+module TestDefaults {
+    interface Obj {a: string};
+    interface S1 {a: number};
+    interface S2 {b: number};
+    interface S3 {c: number};
+    interface S4 {d: number};
+    interface S5 {e: number};
+
+    let obj: Obj;
+    let s1: S1;
+    let s2: S2;
+    let s3: S3;
+    let s4: S4;
+    let s5: S5;
+
+    {
+        let result: Obj;
+
+        result = _.defaults<Obj>(obj);
+    }
+
+    {
+        let result: {a: string};
+
+        result = _.defaults<Obj, S1, {a: string}>(obj, s1);
+    }
+
+    {
+        let result: {a: string, b: number};
+
+        result = _.defaults<Obj, S1, S2, {a: string, b: number}>(obj, s1, s2);
+    }
+
+    {
+        let result: {a: string, b: number, c: number};
+
+        result = _.defaults<Obj, S1, S2, S3, {a: string, b: number, c: number}>(obj, s1, s2, s3);
+    }
+
+    {
+        let result: {a: string, b: number, c: number, d: number};
+
+        result = _.defaults<Obj, S1, S2, S3, S4, {a: string, b: number, c: number, d: number}>(obj, s1, s2, s3, s4);
+    }
+
+    {
+        let result: {a: string, b: number, c: number, d: number, e: number};
+
+        result = _.defaults<Obj, {a: string, b: number, c: number, d: number, e: number}>(obj, s1, s2, s3, s4, s5);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<Obj>;
+
+        result = _(obj).defaults();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: string}>;
+
+        result = _(obj).defaults<S1, {a: string}>(s1);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: string, b: number}>;
+
+        result = _(obj).defaults<S1, S2, {a: string, b: number}>(s1, s2);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: string, b: number, c: number}>;
+
+        result = _(obj).defaults<S1, S2, S3, {a: string, b: number, c: number}>(s1, s2, s3);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: string, b: number, c: number, d: number}>;
+
+        result = _(obj).defaults<S1, S2, S3, S4, {a: string, b: number, c: number, d: number}>(s1, s2, s3, s4);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: string, b: number, c: number, d: number, e: number}>;
+
+        result = _(obj).defaults<{a: string, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<Obj>;
+
+        result = _(obj).chain().defaults();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: string}>;
+
+        result = _(obj).chain().defaults<S1, {a: string}>(s1);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: string, b: number}>;
+
+        result = _(obj).chain().defaults<S1, S2, {a: string, b: number}>(s1, s2);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: string, b: number, c: number}>;
+
+        result = _(obj).chain().defaults<S1, S2, S3, {a: string, b: number, c: number}>(s1, s2, s3);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: string, b: number, c: number, d: number}>;
+
+        result = _(obj).chain().defaults<S1, S2, S3, S4, {a: string, b: number, c: number, d: number}>(s1, s2, s3, s4);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: string, b: number, c: number, d: number, e: number}>;
+
+        result = _(obj).chain().defaults<{a: string, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5);
+    }
+}
+
+//_.defaultsDeep
+interface DefaultsDeepResult {
+    user: {
+        name: string;
+        age: number;
+    }
+}
+var TestDefaultsDeepObject = {'user': {'name': 'barney'}};
+var TestDefaultsDeepSource = {'user': {'name': 'fred', 'age': 36}};
+result = <DefaultsDeepResult>_.defaultsDeep(TestDefaultsDeepObject, TestDefaultsDeepSource);
+result = <DefaultsDeepResult>_(TestDefaultsDeepObject).defaultsDeep<DefaultsDeepResult>(TestDefaultsDeepSource).value();
+
+// _.extend
+module TestExtend {
+    type Obj = {a: string};
+    type S1 = {a: number};
+    type S2 = {b: number};
+    type S3 = {c: number};
+    type S4 = {d: number};
+    type S5 = {e: number};
+
+    let obj: Obj;
+    let s1: S1;
+    let s2: S2;
+    let s3: S3;
+    let s4: S4;
+    let s5: S5;
+
+    let customizer: (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}) => any;
+
+    {
+        let result: Obj;
+
+        result = _.extend<Obj>(obj);
+    }
+
+    {
+        let result: {a: number};
+
+        result = _.extend<Obj, S1, Obj & S1>(obj, s1);
+        result = _.extend<Obj, S1, Obj & S1>(obj, s1, customizer);
+        result = _.extend<Obj, S1, Obj & S1>(obj, s1, customizer, any);
+    }
+
+    {
+        let result: {a: number, b: number};
+
+        result = _.extend<Obj, S1, S2, Obj & S1 & S2>(obj, s1, s2);
+        result = _.extend<Obj, S1, S2, Obj & S1 & S2>(obj, s1, s2, customizer);
+        result = _.extend<Obj, S1, S2, Obj & S1 & S2>(obj, s1, s2, customizer, any);
+    }
+
+    {
+        let result: {a: number, b: number, c: number};
+
+        result = _.extend<Obj, S1, S2, S3, Obj & S1 & S2 & S3>(obj, s1, s2, s3);
+        result = _.extend<Obj, S1, S2, S3, Obj & S1 & S2 & S3>(obj, s1, s2, s3, customizer);
+        result = _.extend<Obj, S1, S2, S3, Obj & S1 & S2 & S3>(obj, s1, s2, s3, customizer, any);
+    }
+
+    {
+        let result: {a: number, b: number, c: number, d: number};
+
+        result = _.extend<Obj, S1, S2, S3, S4, Obj & S1 & S2 & S3 & S4>(obj, s1, s2, s3, s4);
+        result = _.extend<Obj, S1, S2, S3, S4, Obj & S1 & S2 & S3 & S4>(obj, s1, s2, s3, s4, customizer);
+        result = _.extend<Obj, S1, S2, S3, S4, Obj & S1 & S2 & S3 & S4>(obj, s1, s2, s3, s4, customizer, any);
+    }
+
+    {
+        let result: {a: number, b: number, c: number, d: number, e: number};
+
+        result = _.extend<Obj, Obj & S1 & S2 & S3 & S4 & S5>(obj, s1, s2, s3, s4, s5);
+        result = _.extend<Obj, Obj & S1 & S2 & S3 & S4 & S5>(obj, s1, s2, s3, s4, s5, customizer);
+        result = _.extend<Obj, Obj & S1 & S2 & S3 & S4 & S5>(obj, s1, s2, s3, s4, s5, customizer, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<Obj>;
+
+        result = _(obj).extend();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number}>;
+
+        result = _(obj).extend<S1, Obj & S1>(s1);
+        result = _(obj).extend<S1, Obj & S1>(s1, customizer);
+        result = _(obj).extend<S1, Obj & S1>(s1, customizer, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number}>;
+
+        result = _(obj).extend<S1, S2, Obj & S1 & S2>(s1, s2);
+        result = _(obj).extend<S1, S2, Obj & S1 & S2>(s1, s2, customizer);
+        result = _(obj).extend<S1, S2, Obj & S1 & S2>(s1, s2, customizer, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number}>;
+
+        result = _(obj).extend<S1, S2, S3, Obj & S1 & S2 & S3>(s1, s2, s3);
+        result = _(obj).extend<S1, S2, S3, Obj & S1 & S2 & S3>(s1, s2, s3, customizer);
+        result = _(obj).extend<S1, S2, S3, Obj & S1 & S2 & S3>(s1, s2, s3, customizer, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number, d: number}>;
+
+        result = _(obj).extend<S1, S2, S3, S4, Obj & S1 & S2 & S3 & S4>(s1, s2, s3, s4);
+        result = _(obj).extend<S1, S2, S3, S4, Obj & S1 & S2 & S3 & S4>(s1, s2, s3, s4, customizer);
+        result = _(obj).extend<S1, S2, S3, S4, Obj & S1 & S2 & S3 & S4>(s1, s2, s3, s4, customizer, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number, d: number, e: number}>;
+
+        result = _(obj).extend<Obj & S1 & S2 & S3 & S4 & S5>(s1, s2, s3, s4, s5);
+        result = _(obj).extend<Obj & S1 & S2 & S3 & S4 & S5>(s1, s2, s3, s4, s5, customizer);
+        result = _(obj).extend<Obj & S1 & S2 & S3 & S4 & S5>(s1, s2, s3, s4, s5, customizer, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<Obj>;
+
+        result = _(obj).chain().extend();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number}>;
+
+        result = _(obj).chain().extend<S1, Obj & S1>(s1);
+        result = _(obj).chain().extend<S1, Obj & S1>(s1, customizer);
+        result = _(obj).chain().extend<S1, Obj & S1>(s1, customizer, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number}>;
+
+        result = _(obj).chain().extend<S1, S2, Obj & S1 & S2>(s1, s2);
+        result = _(obj).chain().extend<S1, S2, Obj & S1 & S2>(s1, s2, customizer);
+        result = _(obj).chain().extend<S1, S2, Obj & S1 & S2>(s1, s2, customizer, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number}>;
+
+        result = _(obj).chain().extend<S1, S2, S3, Obj & S1 & S2 & S3>(s1, s2, s3);
+        result = _(obj).chain().extend<S1, S2, S3, Obj & S1 & S2 & S3>(s1, s2, s3, customizer);
+        result = _(obj).chain().extend<S1, S2, S3, Obj & S1 & S2 & S3>(s1, s2, s3, customizer, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number, d: number}>;
+
+        result = _(obj).chain().extend<S1, S2, S3, S4, Obj & S1 & S2 & S3 & S4>(s1, s2, s3, s4);
+        result = _(obj).chain().extend<S1, S2, S3, S4, Obj & S1 & S2 & S3 & S4>(s1, s2, s3, s4, customizer);
+        result = _(obj).chain().extend<S1, S2, S3, S4, Obj & S1 & S2 & S3 & S4>(s1, s2, s3, s4, customizer, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number, d: number, e: number}>;
+
+        result = _(obj).chain().extend<Obj & S1 & S2 & S3 & S4 & S5>(s1, s2, s3, s4, s5);
+        result = _(obj).chain().extend<Obj & S1 & S2 & S3 & S4 & S5>(s1, s2, s3, s4, s5, customizer);
+        result = _(obj).chain().extend<Obj & S1 & S2 & S3 & S4 & S5>(s1, s2, s3, s4, s5, customizer, any);
+    }
+}
+
+// _.findKey
+module TestFindKey {
+    {
+        let predicateFn: (value: any, key?: string, object?: {}) => boolean;
+        let result: string;
+
+        result = _.findKey<{a: string;}>({a: ''});
+
+        result = _.findKey<{a: string;}>({a: ''}, predicateFn);
+        result = _.findKey<{a: string;}>({a: ''}, predicateFn, any);
+
+
+        result = _.findKey<{a: string;}>({a: ''}, '');
+        result = _.findKey<{a: string;}>({a: ''}, '', any);
+
+        result = _.findKey<{a: number;}, {a: string;}>({a: ''}, {a: 42});
+
+        result = _<{a: string;}>({a: ''}).findKey();
+
+        result = _<{a: string;}>({a: ''}).findKey(predicateFn);
+        result = _<{a: string;}>({a: ''}).findKey(predicateFn, any);
+
+
+        result = _<{a: string;}>({a: ''}).findKey('');
+        result = _<{a: string;}>({a: ''}).findKey('', any);
+
+        result = _<{a: string;}>({a: ''}).findKey<{a: number;}>({a: 42});
+    }
+
+    {
+        let predicateFn: (value: string, key?: string, collection?: _.Dictionary<string>) => boolean;
+        let result: string;
+
+        result = _.findKey<string, {a: string;}>({a: ''}, predicateFn);
+        result = _.findKey<string, {a: string;}>({a: ''}, predicateFn, any);
+
+        result = _<{a: string;}>({a: ''}).findKey<string>(predicateFn);
+        result = _<{a: string;}>({a: ''}).findKey<string>(predicateFn, any);
+    }
+
+    {
+        let predicateFn: (value: any, key?: string, object?: {}) => boolean;
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _<{a: string;}>({a: ''}).chain().findKey();
+
+        result = _<{a: string;}>({a: ''}).chain().findKey(predicateFn);
+        result = _<{a: string;}>({a: ''}).chain().findKey(predicateFn, any);
+
+
+        result = _<{a: string;}>({a: ''}).chain().findKey('');
+        result = _<{a: string;}>({a: ''}).chain().findKey('', any);
+
+        result = _<{a: string;}>({a: ''}).chain().findKey<{a: number;}>({a: 42});
+    }
+
+    {
+        let predicateFn: (value: string, key?: string, collection?: _.Dictionary<string>) => boolean;
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _<{a: string;}>({a: ''}).chain().findKey<string>(predicateFn);
+        result = _<{a: string;}>({a: ''}).chain().findKey<string>(predicateFn, any);
+    }
+}
+
+// _.findLastKey
+module TestFindLastKey {
+    {
+        let predicateFn: (value: any, key?: string, object?: {}) => boolean;
+        let result: string;
+
+        result = _.findLastKey<{a: string;}>({a: ''});
+
+        result = _.findLastKey<{a: string;}>({a: ''}, predicateFn);
+        result = _.findLastKey<{a: string;}>({a: ''}, predicateFn, any);
+
+
+        result = _.findLastKey<{a: string;}>({a: ''}, '');
+        result = _.findLastKey<{a: string;}>({a: ''}, '', any);
+
+        result = _.findLastKey<{a: number;}, {a: string;}>({a: ''}, {a: 42});
+
+        result = _<{a: string;}>({a: ''}).findLastKey();
+
+        result = _<{a: string;}>({a: ''}).findLastKey(predicateFn);
+        result = _<{a: string;}>({a: ''}).findLastKey(predicateFn, any);
+
+
+        result = _<{a: string;}>({a: ''}).findLastKey('');
+        result = _<{a: string;}>({a: ''}).findLastKey('', any);
+
+        result = _<{a: string;}>({a: ''}).findLastKey<{a: number;}>({a: 42});
+    }
+
+    {
+        let predicateFn: (value: string, key?: string, collection?: _.Dictionary<string>) => boolean;
+        let result: string;
+
+        result = _.findLastKey<string, {a: string;}>({a: ''}, predicateFn);
+        result = _.findLastKey<string, {a: string;}>({a: ''}, predicateFn, any);
+
+        result = _<{a: string;}>({a: ''}).findLastKey<string>(predicateFn);
+        result = _<{a: string;}>({a: ''}).findLastKey<string>(predicateFn, any);
+    }
+
+    {
+        let predicateFn: (value: any, key?: string, object?: {}) => boolean;
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _<{a: string;}>({a: ''}).chain().findLastKey();
+
+        result = _<{a: string;}>({a: ''}).chain().findLastKey(predicateFn);
+        result = _<{a: string;}>({a: ''}).chain().findLastKey(predicateFn, any);
+
+
+        result = _<{a: string;}>({a: ''}).chain().findLastKey('');
+        result = _<{a: string;}>({a: ''}).chain().findLastKey('', any);
+
+        result = _<{a: string;}>({a: ''}).chain().findLastKey<{a: number;}>({a: 42});
+    }
+
+    {
+        let predicateFn: (value: string, key?: string, collection?: _.Dictionary<string>) => boolean;
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _<{a: string;}>({a: ''}).chain().findLastKey<string>(predicateFn);
+        result = _<{a: string;}>({a: ''}).chain().findLastKey<string>(predicateFn, any);
+    }
+}
+
+// _.forIn
+module TestForIn {
+    type SampleObject = {a: number; b: string; c: boolean;};
+
+    let dictionary: _.Dictionary<number>;
+    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => any;
+
+    let object: SampleObject;
+    let objectIterator: (element: any, key?: string, collection?: any) => any;
+
+    {
+        let result: _.Dictionary<number>;
+
+        result = _.forIn<number>(dictionary);
+        result = _.forIn<number>(dictionary, dictionaryIterator);
+        result = _.forIn<number>(dictionary, dictionaryIterator, any);
+    }
+
+    {
+        let result: SampleObject;
+
+        result = _.forIn<SampleObject>(object);
+        result = _.forIn<SampleObject>(object, objectIterator);
+        result = _.forIn<SampleObject>(object, objectIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _(dictionary).forIn<number>();
+        result = _(dictionary).forIn<number>(dictionaryIterator);
+        result = _(dictionary).forIn<number>(dictionaryIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _(dictionary).chain().forIn<number>();
+        result = _(dictionary).chain().forIn<number>(dictionaryIterator);
+        result = _(dictionary).chain().forIn<number>(dictionaryIterator, any);
+    }
+}
+
+// _.forInRight
+module TestForInRight {
+    type SampleObject = {a: number; b: string; c: boolean;};
+
+    let dictionary: _.Dictionary<number>;
+    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => any;
+
+    let object: SampleObject;
+    let objectIterator: (element: any, key?: string, collection?: any) => any;
+
+    {
+        let result: _.Dictionary<number>;
+
+        result = _.forInRight<number>(dictionary);
+        result = _.forInRight<number>(dictionary, dictionaryIterator);
+        result = _.forInRight<number>(dictionary, dictionaryIterator, any);
+    }
+
+    {
+        let result: SampleObject;
+
+        result = _.forInRight<SampleObject>(object);
+        result = _.forInRight<SampleObject>(object, objectIterator);
+        result = _.forInRight<SampleObject>(object, objectIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _(dictionary).forInRight<number>();
+        result = _(dictionary).forInRight<number>(dictionaryIterator);
+        result = _(dictionary).forInRight<number>(dictionaryIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _(dictionary).chain().forInRight<number>();
+        result = _(dictionary).chain().forInRight<number>(dictionaryIterator);
+        result = _(dictionary).chain().forInRight<number>(dictionaryIterator, any);
+    }
+}
+
+// _.forOwn
+module TestForOwn {
+    type SampleObject = {a: number; b: string; c: boolean;};
+
+    let dictionary: _.Dictionary<number>;
+    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => any;
+
+    let object: SampleObject;
+    let objectIterator: (element: any, key?: string, collection?: any) => any;
+
+    {
+        let result: _.Dictionary<number>;
+
+        result = _.forOwn<number>(dictionary);
+        result = _.forOwn<number>(dictionary, dictionaryIterator);
+        result = _.forOwn<number>(dictionary, dictionaryIterator, any);
+    }
+
+    {
+        let result: SampleObject;
+
+        result = _.forOwn<SampleObject>(object);
+        result = _.forOwn<SampleObject>(object, objectIterator);
+        result = _.forOwn<SampleObject>(object, objectIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _(dictionary).forOwn<number>();
+        result = _(dictionary).forOwn<number>(dictionaryIterator);
+        result = _(dictionary).forOwn<number>(dictionaryIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _(dictionary).chain().forOwn<number>();
+        result = _(dictionary).chain().forOwn<number>(dictionaryIterator);
+        result = _(dictionary).chain().forOwn<number>(dictionaryIterator, any);
+    }
+}
+
+// _.forOwnRight
+module TestForOwnRight {
+    type SampleObject = {a: number; b: string; c: boolean;};
+
+    let dictionary: _.Dictionary<number>;
+    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => any;
+
+    let object: SampleObject;
+    let objectIterator: (element: any, key?: string, collection?: any) => any;
+
+    {
+        let result: _.Dictionary<number>;
+
+        result = _.forOwnRight<number>(dictionary);
+        result = _.forOwnRight<number>(dictionary, dictionaryIterator);
+        result = _.forOwnRight<number>(dictionary, dictionaryIterator, any);
+    }
+
+    {
+        let result: SampleObject;
+
+        result = _.forOwnRight<SampleObject>(object);
+        result = _.forOwnRight<SampleObject>(object, objectIterator);
+        result = _.forOwnRight<SampleObject>(object, objectIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _(dictionary).forOwnRight<number>();
+        result = _(dictionary).forOwnRight<number>(dictionaryIterator);
+        result = _(dictionary).forOwnRight<number>(dictionaryIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<number>>;
+
+        result = _(dictionary).chain().forOwnRight<number>();
+        result = _(dictionary).chain().forOwnRight<number>(dictionaryIterator);
+        result = _(dictionary).chain().forOwnRight<number>(dictionaryIterator, any);
+    }
+}
+
+// _.functions
+module TestFunctions {
+    type SampleObject = {a: number; b: string; c: boolean;};
+
+    let object: SampleObject;
+
+    {
+        let result: string[];
+
+        result = _.functions<SampleObject>(object);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _(object).functions();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _(object).chain().functions();
+    }
+}
+
+// _.get
+result = <number>_.get<number>({ 'a': [{ 'b': { 'c': 3 } }] }, 'a[0].b.c');
+
+{
+    let result: TResult;
+    result = _.get<TResult>({}, '');
+    result = _.get<TResult>({}, 42);
+    result = _.get<TResult>({}, true);
+    result = _.get<TResult>({}, ['', 42, true]);
+    result = _({}).get<TResult>('');
+    result = _({}).get<TResult>(42);
+    result = _({}).get<TResult>(true);
+    result = _({}).get<TResult>(['', 42, true]);
+}
+
+// _.has
+module TestHas {
+    type SampleObject = {a: number; b: string; c: boolean;};
+
+    let object: SampleObject;
+
+    {
+        let result: boolean;
+
+        result = _.has<SampleObject>(object, '');
+        result = _.has<SampleObject>(object, 42);
+        result = _.has<SampleObject>(object, true);
+        result = _.has<SampleObject>(object, ['', 42, true]);
+
+        result = _(object).has('');
+        result = _(object).has(42);
+        result = _(object).has(true);
+        result = _(object).has(['', 42, true]);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(object).chain().has('');
+        result = _(object).chain().has(42);
+        result = _(object).chain().has(true);
+        result = _(object).chain().has(['', 42, true]);
+    }
+}
+
+// _.invert
+module TestInvert {
+    {
+        let result: TResult;
+
+        result = _.invert<Object, TResult>({});
+        result = _.invert<Object, TResult>({}, true);
+
+        result = _.invert<TResult>({});
+        result = _.invert<TResult>({}, true);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<TResult>;
+
+        result = _({}).invert<TResult>();
+        result = _({}).invert<TResult>(true);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<TResult>;
+
+        result = _({}).chain().invert<TResult>();
+        result = _({}).chain().invert<TResult>(true);
+    }
+}
+
+// _.keys
+module TestKeys {
+    let object: _.Dictionary<any>;
+
+    {
+        let result: string[];
+
+        result = _.keys(object);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _(object).keys();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _(object).chain().keys();
+    }
+}
+
+// _.keysIn
+module TestKeysIn {
+    let object: _.Dictionary<any>;
+
+    {
+        let result: string[];
+
+        result = _.keysIn(object);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _(object).keysIn();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _(object).chain().keysIn();
+    }
+}
+
+// _.mapKeys
+module TestMapKeys {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let dictionary: _.Dictionary<TResult>;
+
+    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => string;
+    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => string;
+
+    {
+        let result: _.Dictionary<TResult>;
+
+        result = _.mapKeys<TResult, string>(array);
+        result = _.mapKeys<TResult, string>(array, listIterator);
+        result = _.mapKeys<TResult, string>(array, listIterator, any);
+        result = _.mapKeys<TResult>(array, '');
+        result = _.mapKeys<TResult>(array, '', any);
+        result = _.mapKeys<TResult, {}>(array, {});
+
+        result = _.mapKeys<TResult, string>(list);
+        result = _.mapKeys<TResult, string>(list, listIterator);
+        result = _.mapKeys<TResult, string>(list, listIterator, any);
+        result = _.mapKeys<TResult>(list, '');
+        result = _.mapKeys<TResult>(list, '', any);
+        result = _.mapKeys<TResult, {}>(list, {});
+
+        result = _.mapKeys<TResult, string>(dictionary);
+        result = _.mapKeys<TResult, string>(dictionary, dictionaryIterator);
+        result = _.mapKeys<TResult, string>(dictionary, dictionaryIterator, any);
+        result = _.mapKeys<TResult>(dictionary, '');
+        result = _.mapKeys<TResult>(dictionary, '', any);
+        result = _.mapKeys<TResult, {}>(dictionary, {});
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<TResult>>;
+
+        result = _(array).mapKeys<string>();
+        result = _(array).mapKeys<string>(listIterator);
+        result = _(array).mapKeys<string>(listIterator, any);
+        result = _(array).mapKeys('');
+        result = _(array).mapKeys('', any);
+        result = _(array).mapKeys<{}>({});
+
+        result = _(list).mapKeys<TResult, string>();
+        result = _(list).mapKeys<TResult, string>(listIterator);
+        result = _(list).mapKeys<TResult, string>(listIterator, any);
+        result = _(list).mapKeys<TResult>('');
+        result = _(list).mapKeys<TResult>('', any);
+        result = _(list).mapKeys<TResult, {}>({});
+
+        result = _(dictionary).mapKeys<TResult, string>();
+        result = _(dictionary).mapKeys<TResult, string>(dictionaryIterator);
+        result = _(dictionary).mapKeys<TResult, string>(dictionaryIterator, any);
+        result = _(dictionary).mapKeys<TResult>('');
+        result = _(dictionary).mapKeys<TResult>('', any);
+        result = _(dictionary).mapKeys<TResult, {}>({});
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<TResult>>;
+
+        result = _(array).chain().mapKeys<string>();
+        result = _(array).chain().mapKeys<string>(listIterator);
+        result = _(array).chain().mapKeys<string>(listIterator, any);
+        result = _(array).chain().mapKeys('');
+        result = _(array).chain().mapKeys('', any);
+        result = _(array).chain().mapKeys<{}>({});
+
+        result = _(list).chain().mapKeys<TResult, string>();
+        result = _(list).chain().mapKeys<TResult, string>(listIterator);
+        result = _(list).chain().mapKeys<TResult, string>(listIterator, any);
+        result = _(list).chain().mapKeys<TResult>('');
+        result = _(list).chain().mapKeys<TResult>('', any);
+        result = _(list).chain().mapKeys<TResult, {}>({});
+
+        result = _(dictionary).chain().mapKeys<TResult, string>();
+        result = _(dictionary).chain().mapKeys<TResult, string>(dictionaryIterator);
+        result = _(dictionary).chain().mapKeys<TResult, string>(dictionaryIterator, any);
+        result = _(dictionary).chain().mapKeys<TResult>('');
+        result = _(dictionary).chain().mapKeys<TResult>('', any);
+        result = _(dictionary).chain().mapKeys<TResult, {}>({});
+    }
+}
+
+// _.merge
+module TestMerge {
+    type InitialValue = { a : number };
+    type MergingValue = { b : string };
+
+    var initialValue  = { a : 1 };
+    var mergingValue  = { b : "hi" };
+
+    type ExpectedResult = { a: number, b: string };
+    let result: ExpectedResult;
+
+    let customizer: (value: any, srcValue: any, key?: string, object?: InitialValue, source?: MergingValue) => any;
+
+    // Test for basic merging
+
+    result = _.merge(initialValue, mergingValue);
+    result = _.merge(initialValue, mergingValue, customizer);
+    result = _.merge(initialValue, mergingValue, customizer, any);
+
+    result = _.merge(initialValue, {}, mergingValue);
+    result = _.merge(initialValue, {}, mergingValue, customizer);
+    result = _.merge(initialValue, {}, mergingValue, customizer, any);
+
+    result = _.merge(initialValue, {}, {}, mergingValue);
+    result = _.merge(initialValue, {}, {}, mergingValue, customizer);
+    result = _.merge(initialValue, {}, {}, mergingValue, customizer, any);
+
+    result = _.merge(initialValue, {}, {}, {}, mergingValue);
+    result = _.merge(initialValue, {}, {}, {}, mergingValue, customizer);
+    result = _.merge(initialValue, {}, {}, {}, mergingValue, customizer, any);
+
+    // Once we get to the varargs version, you have to specify the result explicitly
+    result = _.merge<ExpectedResult>(initialValue, {}, {}, {}, {}, mergingValue);
+    result = _.merge<ExpectedResult>(initialValue, {}, {}, {}, {}, mergingValue, customizer);
+    result = _.merge<ExpectedResult>(initialValue, {}, {}, {}, {}, mergingValue, customizer, any);
+
+    // Test for multiple combinations of many types
+
+    type ComplicatedExpectedType = { a: number, b: string, c: {}, d: number[], e: boolean };
+
+    var complicatedResult: ComplicatedExpectedType = _.merge({ a: 1 },
+                                                             { b: "string" },
+                                                             { c: {} },
+                                                             { d: [1] },
+                                                             { e: true });
+    // Test for type overriding
+
+    type ExpectedTypeAfterOverriding = { a: boolean };
+
+    var overriddenResult: ExpectedTypeAfterOverriding = _.merge({ a: 1 },
+                                                                { a: "string" },
+                                                                { a: {} },
+                                                                { a: [1] },
+                                                                { a: true });
+
+    // Tests for basic chaining with merge
+
+    result = _(initialValue).merge(mergingValue).value();
+    result = _(initialValue).merge(mergingValue, customizer).value();
+    result = _(initialValue).merge(mergingValue, customizer, any).value();
+
+    result = _(initialValue).merge({}, mergingValue).value();
+    result = _(initialValue).merge({}, mergingValue, customizer).value();
+    result = _(initialValue).merge({}, mergingValue, customizer, any).value();
+
+    result = _(initialValue).merge({}, {}, mergingValue).value();
+    result = _(initialValue).merge({}, {}, mergingValue, customizer).value();
+    result = _(initialValue).merge({}, {}, mergingValue, customizer, any).value();
+
+    result = _(initialValue).merge({}, {}, {}, mergingValue).value();
+    result = _(initialValue).merge({}, {}, {}, mergingValue, customizer).value();
+    result = _(initialValue).merge({}, {}, {}, mergingValue, customizer, any).value();
+
+    // Once we get to the varargs version, you have to specify the result explicitly
+    result = _(initialValue).merge<ExpectedResult>({}, {}, {}, {}, mergingValue).value();
+    result = _(initialValue).merge<ExpectedResult>({}, {}, {}, {}, mergingValue, customizer).value();
+    result = _(initialValue).merge<ExpectedResult>({}, {}, {}, {}, mergingValue, customizer, any).value();
+
+    // Test complex multiple combinations with chaining
+
+    var complicatedResult: ComplicatedExpectedType = _({ a: 1 }).merge({ b: "string" },
+                                                                       { c: {} },
+                                                                       { d: [1] },
+                                                                       { e: true }).value();
+
+    // Test for type overriding with chaining
+
+    var overriddenResult: ExpectedTypeAfterOverriding = _({ a: 1 }).merge({ a: "string" },
+                                                                          { a: {} },
+                                                                          { a: [1] },
+                                                                          { a: true }).value();
+
+}
+
+// _.methods
+module TestFunctions {
+    type SampleObject = {a: number; b: string; c: boolean;};
+
+    let object: SampleObject;
+
+    {
+        let result: string[];
+
+        result = _.methods<SampleObject>(object);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _(object).methods();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _(object).chain().methods();
+    }
+}
+
+// _.omit
+module TestOmit {
+    let predicate: (element: any, key: string, collection: any) => boolean;
+
+    {
+        let result: TResult;
+
+        result = _.omit<TResult, Object>({}, 'a');
+        result = _.omit<TResult, Object>({}, 0, 'a');
+        result = _.omit<TResult, Object>({}, true, 0, 'a');
+        result = _.omit<TResult, Object>({}, ['b', 1, false], true, 0, 'a');
+        result = _.omit<TResult, Object>({}, predicate);
+        result = _.omit<TResult, Object>({}, predicate, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<TResult>;
+
+        result = _({}).omit<TResult>('a');
+        result = _({}).omit<TResult>(0, 'a');
+        result = _({}).omit<TResult>(true, 0, 'a');
+        result = _({}).omit<TResult>(['b', 1, false], true, 0, 'a');
+        result = _({}).omit<TResult>(predicate);
+        result = _({}).omit<TResult>(predicate, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<TResult>;
+
+        result = _({}).chain().omit<TResult>('a');
+        result = _({}).chain().omit<TResult>(0, 'a');
+        result = _({}).chain().omit<TResult>(true, 0, 'a');
+        result = _({}).chain().omit<TResult>(['b', 1, false], true, 0, 'a');
+        result = _({}).chain().omit<TResult>(predicate);
+        result = _({}).chain().omit<TResult>(predicate, any);
+    }
+}
+
+// _.pairs
+module TestPairs {
+    let object: _.Dictionary<string>;
+
+    {
+        let result: any[][];
+
+        result = _.pairs<_.Dictionary<string>>(object);
+    }
+
+    {
+        let result: string[][];
+
+        result = _.pairs<_.Dictionary<string>, string>(object);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string[]>;
+
+        result = _(object).pairs<string>();
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<any[]>;
+
+        result = _(object).pairs();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string[]>;
+
+        result = _(object).chain().pairs<string>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<any[]>;
+
+        result = _(object).chain().pairs();
+    }
+}
+
+// _.pick
+module TestPick {
+    let predicate: (element: any, key: string, collection: any) => boolean;
+
+    {
+        let result: TResult;
+
+        result = _.pick<TResult, Object>({}, 'a');
+        result = _.pick<TResult, Object>({}, 0, 'a');
+        result = _.pick<TResult, Object>({}, true, 0, 'a');
+        result = _.pick<TResult, Object>({}, ['b', 1, false], true, 0, 'a');
+        result = _.pick<TResult, Object>({}, predicate);
+        result = _.pick<TResult, Object>({}, predicate, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<TResult>;
+
+        result = _({}).pick<TResult>('a');
+        result = _({}).pick<TResult>(0, 'a');
+        result = _({}).pick<TResult>(true, 0, 'a');
+        result = _({}).pick<TResult>(['b', 1, false], true, 0, 'a');
+        result = _({}).pick<TResult>(predicate);
+        result = _({}).pick<TResult>(predicate, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<TResult>;
+
+        result = _({}).chain().pick<TResult>('a');
+        result = _({}).chain().pick<TResult>(0, 'a');
+        result = _({}).chain().pick<TResult>(true, 0, 'a');
+        result = _({}).chain().pick<TResult>(['b', 1, false], true, 0, 'a');
+        result = _({}).chain().pick<TResult>(predicate);
+        result = _({}).chain().pick<TResult>(predicate, any);
+    }
+}
+
+// _.result
+{
+    let testResultPath: number|string|boolean|Array<number|string|boolean>;
+    let testResultDefaultValue: TResult;
+    let result: TResult;
+    result = _.result<{}, TResult>({}, testResultPath);
+    result = _.result<{}, TResult>({}, testResultPath, testResultDefaultValue);
+    result = _({}).result<TResult>(testResultPath);
+    result = _({}).result<TResult>(testResultPath, testResultDefaultValue);
+}
+
+// _.set
+module TestSet {
+    type SampleValue = {a: number; b: string; c: boolean;};
+
+    let object: TResult;
+    let value = {a: 1, b: '', c: true};
+
+    {
+        let result: TResult;
+
+        result = _.set(object, '', any);
+        result = _.set(object, ['a', 'b', 1], any);
+
+        result = _.set<SampleValue>(object, '', value);
+        result = _.set<SampleValue>(object, ['a', 'b', 1], value);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<TResult>;
+
+        result = _(object).set('', any);
+        result = _(object).set(['a', 'b', 1], any);
+
+        result = _(object).set<SampleValue>('', value);
+        result = _(object).set<SampleValue>(['a', 'b', 1], value);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<TResult>;
+
+        result = _(object).chain().set('', any);
+        result = _(object).chain().set(['a', 'b', 1], any);
+
+        result = _(object).chain().set<SampleValue>('', value);
+        result = _(object).chain().set<SampleValue>(['a', 'b', 1], value);
+    }
+}
+
+// _.transform
+module TestTransform {
+    let array: number[];
+    let dictionary: _.Dictionary<number>;
+
+    {
+        let iterator: (acc: TResult[], curr: number, index?: number, arr?: number[]) => void;
+        let accumulator: TResult[];
+        let result: TResult[];
+
+        result = _.transform<number, TResult>(array);
+        result = _.transform<number, TResult>(array, iterator);
+        result = _.transform<number, TResult>(array, iterator, accumulator);
+        result = _.transform<number, TResult>(array, iterator, accumulator, any);
+
+        result = _<number>(array).transform<TResult>().value();
+        result = _<number>(array).transform<TResult>(iterator).value();
+        result = _<number>(array).transform<TResult>(iterator, accumulator).value();
+        result = _<number>(array).transform<TResult>(iterator, accumulator, any).value();
+    }
+
+    {
+        let iterator: (acc: _.Dictionary<TResult>, curr: number, index?: number, arr?: number[]) => void;
+        let accumulator: _.Dictionary<TResult>;
+        let result: _.Dictionary<TResult>;
+
+        result = _.transform<number, TResult>(array, iterator);
+        result = _.transform<number, TResult>(array, iterator, accumulator);
+        result = _.transform<number, TResult>(array, iterator, accumulator, any);
+
+        result = _<number>(array).transform<TResult>(iterator).value();
+        result = _<number>(array).transform<TResult>(iterator, accumulator).value();
+        result = _<number>(array).transform<TResult>(iterator, accumulator, any).value();
+    }
+
+    {
+        let iterator: (acc: _.Dictionary<TResult>, curr: number, key?: string, dict?: _.Dictionary<number>) => void;
+        let accumulator: _.Dictionary<TResult>;
+        let result: _.Dictionary<TResult>;
+
+        result = _.transform<number, TResult>(dictionary);
+        result = _.transform<number, TResult>(dictionary, iterator);
+        result = _.transform<number, TResult>(dictionary, iterator, accumulator);
+        result = _.transform<number, TResult>(dictionary, iterator, accumulator, any);
+
+        result = _(dictionary).transform<number, TResult>().value();
+        result = _(dictionary).transform<number, TResult>(iterator).value();
+        result = _(dictionary).transform<number, TResult>(iterator, accumulator).value();
+        result = _(dictionary).transform<number, TResult>(iterator, accumulator, any).value();
+    }
+
+    {
+        let iterator: (acc: TResult[], curr: number, key?: string, dict?: _.Dictionary<number>) => void;
+        let accumulator: TResult[];
+        let result: TResult[];
+
+        result = _.transform<number, TResult>(dictionary, iterator);
+        result = _.transform<number, TResult>(dictionary, iterator, accumulator);
+        result = _.transform<number, TResult>(dictionary, iterator, accumulator, any);
+
+        result = _(dictionary).transform<number, TResult>(iterator).value();
+        result = _(dictionary).transform<number, TResult>(iterator, accumulator).value();
+        result = _(dictionary).transform<number, TResult>(iterator, accumulator, any).value();
+    }
+}
+
+// _.values
+module TestValues {
+    let object: _.Dictionary<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.values<TResult>(object);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(object).values<TResult>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(object).chain().values<TResult>();
+    }
+}
+
+// _.valuesIn
+module TestValuesIn {
+    let object: _.Dictionary<TResult>;
+
+    {
+        let result: TResult[];
+
+        result = _.valuesIn<TResult>(object);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(object).valuesIn<TResult>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(object).chain().valuesIn<TResult>();
+    }
+}
+
+/**********
+ * String *
+ **********/
+
+// _.camelCase
+module TestCamelCase {
+    {
+        let result: string;
+
+        result = _.camelCase('Foo Bar');
+        result = _('Foo Bar').camelCase();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('Foo Bar').chain().camelCase();
+    }
+}
+
+// _.capitalize
+module TestCapitalize {
+    {
+        let result: string;
+
+        result = _.capitalize('fred');
+        result = _('fred').capitalize();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('fred').chain().capitalize();
+    }
+}
+
+// _.deburr
+module TestDeburr {
+    {
+        let result: string;
+
+        result = _.deburr('déjà vu');
+        result = _('déjà vu').deburr();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('déjà vu').chain().deburr();
+    }
+}
+
+// _.endsWith
+module TestEndsWith {
+    {
+        let result: boolean;
+
+        result = _.endsWith('abc', 'c');
+        result = _.endsWith('abc', 'c', 1);
+
+        result = _('abc').endsWith('c');
+        result = _('abc').endsWith('c', 1);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _('abc').chain().endsWith('c');
+        result = _('abc').chain().endsWith('c', 1);
+    }
+}
+
+// _.escape
+module TestEscape {
+    {
+        let result: string;
+
+        result = _.escape('fred, barney, & pebbles');
+        result = _('fred, barney, & pebbles').escape();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('fred, barney, & pebbles').chain().escape();
+    }
+}
+
+// _.escapeRegExp
+module TestEscapeRegExp {
+    {
+        let result: string;
+
+        result = _.escapeRegExp('[lodash](https://lodash.com/)');
+        result = _('[lodash](https://lodash.com/)').escapeRegExp();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('[lodash](https://lodash.com/)').chain().escapeRegExp();
+    }
+}
+
+// _.kebabCase
+module TestKebabCase {
+    {
+        let result: string;
+
+        result = _.kebabCase('Foo Bar');
+        result = _('Foo Bar').kebabCase();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('Foo Bar').chain().kebabCase();
+    }
+}
+
+// _.pad
+module TestPad {
+    {
+        let result: string;
+
+        result = _.pad('abd');
+        result = _.pad('abc', 8);
+        result = _.pad('abc', 8, '_-');
+
+        result = _('abc').pad();
+        result = _('abc').pad(8);
+        result = _('abc').pad(8, '_-');
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('abc').chain().pad();
+        result = _('abc').chain().pad(8);
+        result = _('abc').chain().pad(8, '_-');
+    }
+}
+
+// _.padLeft
+module TestPadLeft {
+    {
+        let result: string;
+
+        result = _.padLeft('abc');
+        result = _.padLeft('abc', 6);
+        result = _.padLeft('abc', 6, '_-');
+
+        result = _('abc').padLeft();
+        result = _('abc').padLeft(6);
+        result = _('abc').padLeft(6, '_-');
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('abc').chain().padLeft();
+        result = _('abc').chain().padLeft(6);
+        result = _('abc').chain().padLeft(6, '_-');
+    }
+}
+
+// _.padRight
+module TestPadRight {
+    {
+        let result: string;
+
+        result = _.padRight('abc');
+        result = _.padRight('abc', 6);
+        result = _.padRight('abc', 6, '_-');
+
+        result = _('abc').padRight();
+        result = _('abc').padRight(6);
+        result = _('abc').padRight(6, '_-');
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('abc').chain().padRight();
+        result = _('abc').chain().padRight(6);
+        result = _('abc').chain().padRight(6, '_-');
+    }
+}
+
+
+// _.parseInt
+module TestParseInt {
+    {
+        let result: number;
+
+        result = _.parseInt('08');
+        result = _.parseInt('08', 10);
+
+        result = _('08').parseInt();
+        result = _('08').parseInt(10);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _('08').chain().parseInt();
+        result = _('08').chain().parseInt(10);
+    }
+}
+
+// _.repeat
+module TestRepeat {
+    {
+        let result: string;
+        result = _.repeat('*');
+        result = _.repeat('*', 3);
+
+        result = _('*').repeat();
+        result = _('*').repeat(3);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('*').chain().repeat();
+        result = _('*').chain().repeat(3);
+    }
+}
+
+// _.snakeCase
+module TestSnakeCase {
+    {
+        let result: string;
+
+        result = _.snakeCase('Foo Bar');
+        result = _('Foo Bar').snakeCase();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('Foo Bar').chain().snakeCase();
+    }
+}
+
+// _.startCase
+module TestStartCase {
+    {
+        let result: string;
+
+        result = _.startCase('--foo-bar');
+        result = _('--foo-bar').startCase();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('--foo-bar').chain().startCase();
+    }
+}
+
+// _.startsWith
+module TestStartsWith {
+    {
+        let result: boolean;
+
+        result = _.startsWith('abc', 'a');
+        result = _.startsWith('abc', 'a', 1);
+
+        result = _('abc').startsWith('a');
+        result = _('abc').startsWith('a', 1);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _('abc').chain().startsWith('a');
+        result = _('abc').chain().startsWith('a', 1);
+    }
+}
+
+// _.template
+module TestTemplate {
+    interface TemplateExecutor {
+        (obj?: Object): string;
+        source: string;
+    }
+
+    let options: {
+        escape?: RegExp;
+        evaluate?: RegExp;
+        imports?: _.Dictionary<any>;
+        interpolate?: RegExp;
+        sourceURL?: string;
+        variable?: string;
+    };
+
+    {
+        let result: TemplateExecutor;
+
+        result = _.template('');
+        result = _.template('', options);
+
+        result = _('').template();
+        result = _('').template(options);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<TemplateExecutor>;
+
+        result = _('').chain().template();
+        result = _('').chain().template(options);
+    }
+}
+
+// _.trim
+module TestTrim {
+    {
+        let result: string;
+
+        result = _.trim();
+        result = _.trim('  abc  ');
+        result = _.trim('-_-abc-_-', '_-');
+
+        result = _('-_-abc-_-').trim();
+        result = _('-_-abc-_-').trim('_-');
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('-_-abc-_-').chain().trim();
+        result = _('-_-abc-_-').chain().trim('_-');
+    }
+}
+
+// _.trimLeft
+module TestTrimLeft {
+    {
+        let result: string;
+
+        result = _.trimLeft();
+        result = _.trimLeft('  abc  ');
+        result = _.trimLeft('-_-abc-_-', '_-');
+
+        result = _('-_-abc-_-').trimLeft();
+        result = _('-_-abc-_-').trimLeft('_-');
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('-_-abc-_-').chain().trimLeft();
+        result = _('-_-abc-_-').chain().trimLeft('_-');
+    }
+}
+
+// _.trimRight
+
+module TestTrimRight {
+    {
+        let result: string;
+
+        result = _.trimRight();
+        result = _.trimRight('  abc  ');
+        result = _.trimRight('-_-abc-_-', '_-');
+
+        result = _('-_-abc-_-').trimRight();
+        result = _('-_-abc-_-').trimRight('_-');
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('-_-abc-_-').chain().trimRight();
+        result = _('-_-abc-_-').chain().trimRight('_-');
+    }
+}
+
+// _.trunc
+module TestTrunc {
+    {
+        let result: string;
+
+        result = _.trunc('hi-diddly-ho there, neighborino');
+        result = _.trunc('hi-diddly-ho there, neighborino', 24);
+        result = _.trunc('hi-diddly-ho there, neighborino', { 'length': 24, 'separator': ' ' });
+        result = _.trunc('hi-diddly-ho there, neighborino', { 'length': 24, 'separator': /,? +/ });
+        result = _.trunc('hi-diddly-ho there, neighborino', { 'omission': ' […]' });
+
+        result = _('hi-diddly-ho there, neighborino').trunc();
+        result = _('hi-diddly-ho there, neighborino').trunc(24);
+        result = _('hi-diddly-ho there, neighborino').trunc({ 'length': 24, 'separator': ' ' });
+        result = _('hi-diddly-ho there, neighborino').trunc({ 'length': 24, 'separator': /,? +/ });
+        result = _('hi-diddly-ho there, neighborino').trunc({ 'omission': ' […]' });
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('hi-diddly-ho there, neighborino').chain().trunc();
+        result = _('hi-diddly-ho there, neighborino').chain().trunc(24);
+        result = _('hi-diddly-ho there, neighborino').chain().trunc({ 'length': 24, 'separator': ' ' });
+        result = _('hi-diddly-ho there, neighborino').chain().trunc({ 'length': 24, 'separator': /,? +/ });
+        result = _('hi-diddly-ho there, neighborino').chain().trunc({ 'omission': ' […]' });
+    }
+}
+
+// _.unescape
+module TestUnescape {
+    {
+        let result: string;
+
+        result = _.unescape('fred, barney, &amp; pebbles');
+        result = _('fred, barney, &amp; pebbles').unescape();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('fred, barney, &amp; pebbles').chain().unescape();
+    }
+}
+
+// _.words
+module TestWords {
+    {
+        let result: string[];
+
+        result = _.words('fred, barney, & pebbles');
+        result = _.words('fred, barney, & pebbles', /[^, ]+/g);
+
+        result = _('fred, barney, & pebbles').words();
+        result = _('fred, barney, & pebbles').words(/[^, ]+/g);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _('fred, barney, & pebbles').chain().words();
+        result = _('fred, barney, & pebbles').chain().words(/[^, ]+/g);
+    }
+}
+
+/***********
+ * Utility *
+ ***********/
+
+// _.attempt
+module TestAttempt {
+    let func: (...args: any[]) => {a: string};
+
+    {
+        let result: {a: string}|Error;
+
+        result = _.attempt<{a: string}>(func);
+        result = _(func).attempt<{a: string}>();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: string}|Error>;
+
+        result = _(func).chain().attempt<{a: string}>();
+    }
+}
+
+// _.callback
+module TestCallback {
+    {
+        let result: (...args: any[]) => TResult;
+
+        result = _.callback<TResult>(Function);
+        result = _.callback<TResult>(Function, any);
+    }
+
+    {
+        let result: (object: any) => TResult;
+
+        result = _.callback<TResult>('');
+        result = _.callback<TResult>('', any);
+    }
+
+    {
+        let result: (object: any) => boolean;
+
+        result = _.callback({});
+        result = _.callback({}, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(...args: any[]) => TResult>;
+
+        result = _(Function).callback<TResult>();
+        result = _(Function).callback<TResult>(any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(object: any) => TResult>;
+
+        result = _('').callback<TResult>();
+        result = _('').callback<TResult>(any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(object: any) => boolean>;
+
+        result = _({}).callback();
+        result = _({}).callback(any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(...args: any[]) => TResult>;
+
+        result = _(Function).chain().callback<TResult>();
+        result = _(Function).chain().callback<TResult>(any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(object: any) => TResult>;
+
+        result = _('').chain().callback<TResult>();
+        result = _('').chain().callback<TResult>(any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(object: any) => boolean>;
+
+        result = _({}).chain().callback();
+        result = _({}).chain().callback(any);
+    }
+}
+
+// _.constant
+module TestConstant {
+    {
+        let result: () => number;
+        result: _.constant<number>(42);
+    }
+
+    {
+        let result: () => string;
+        result: _.constant<string>('a');
+    }
+
+    {
+        let result: () => boolean;
+        result: _.constant<boolean>(true);
+    }
+
+    {
+        let result: () => string[];
+        result: _.constant<string[]>(['a']);
+    }
+
+    {
+        let result: () => {a: string};
+        result: _.constant<{a: string}>({a: 'a'});
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<() => number>;
+        result: _(42).constant<number>();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<() => string>;
+        result: _('a').constant<string>();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<() => boolean>;
+        result: _(true).constant<boolean>();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<() => string[]>;
+        result: _(['a']).constant<string[]>();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<() => {a: string}>;
+        result: _({a: 'a'}).constant<{a: string}>();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<() => number>;
+        result: _(42).chain().constant<number>();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<() => string>;
+        result: _('a').chain().constant<string>();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<() => boolean>;
+        result: _(true).chain().constant<boolean>();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<() => string[]>;
+        result: _(['a']).chain().constant<string[]>();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<() => {a: string}>;
+        result: _({a: 'a'}).chain().constant<{a: string}>();
+    }
+}
+
+// _.identity
+{
+    let testIdentityValue: TResult;
+    let result: TResult;
+    result = _.identity<TResult>(testIdentityValue);
+    result = _(testIdentityValue).identity();
+}
+{
+    let result: number;
+    result = _(42).identity();
+}
+{
+    let result: boolean[];
+    result = _<boolean>([]).identity();
+}
+
+// _.iteratee
+module TestIteratee {
+    {
+        let result: (...args: any[]) => TResult;
+
+        result = _.iteratee<TResult>(Function);
+        result = _.iteratee<TResult>(Function, any);
+    }
+
+    {
+        let result: (object: any) => TResult;
+
+        result = _.iteratee<TResult>('');
+        result = _.iteratee<TResult>('', any);
+    }
+
+    {
+        let result: (object: any) => boolean;
+
+        result = _.iteratee({});
+        result = _.iteratee({}, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(...args: any[]) => TResult>;
+
+        result = _(Function).iteratee<TResult>();
+        result = _(Function).iteratee<TResult>(any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(object: any) => TResult>;
+
+        result = _('').iteratee<TResult>();
+        result = _('').iteratee<TResult>(any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(object: any) => boolean>;
+
+        result = _({}).iteratee();
+        result = _({}).iteratee(any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(...args: any[]) => TResult>;
+
+        result = _(Function).chain().iteratee<TResult>();
+        result = _(Function).chain().iteratee<TResult>(any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(object: any) => TResult>;
+
+        result = _('').chain().iteratee<TResult>();
+        result = _('').chain().iteratee<TResult>(any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(object: any) => boolean>;
+
+        result = _({}).chain().iteratee();
+        result = _({}).chain().iteratee(any);
+    }
+}
+
+// _.matches
+module TestMatches {
+    let source: TResult;
+
+    {
+        let result: (value: any) => boolean;
+        result = _.matches<TResult>(source);
+    }
+
+    {
+        let result: (value: TResult) => boolean;
+        result = _.matches<TResult, TResult>(source);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(value: TResult) => boolean>;
+        result = _(source).matches<TResult>();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(value: TResult) => boolean>;
+        result = _(source).chain().matches<TResult>();
+    }
+}
+
+// _.matchesProperty
+module TestMatches {
+    let path: {toString(): string;}|{toString(): string;}[];
+    let source: TResult;
+
+    {
+        let result: (value: any) => boolean;
+
+        result = _.matchesProperty<TResult>(path, source);
+    }
+
+    {
+        let result: (value: TResult) => boolean;
+
+        result = _.matchesProperty<TResult, TResult>(path, source);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(value: any) => boolean>;
+
+        result = _(path).matchesProperty<TResult>(source);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(value: TResult) => boolean>;
+
+        result = _(path).matchesProperty<TResult, TResult>(source);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(value: any) => boolean>;
+
+        result = _(path).chain().matchesProperty<TResult>(source);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(value: TResult) => boolean>;
+
+        result = _(path).chain().matchesProperty<TResult, TResult>(source);
+    }
+}
+
+// _.method
+module TestMethod {
+    {
+        let result: (object: any) => {a: string};
+
+        result = _.method<{a: string}>('a.0');
+        result = _.method<{a: string}>('a.0', any);
+        result = _.method<{a: string}>('a.0', any, any);
+        result = _.method<{a: string}>('a.0', any, any, any);
+
+        result = _.method<{a: string}>(['a', 0]);
+        result = _.method<{a: string}>(['a', 0], any);
+        result = _.method<{a: string}>(['a', 0], any, any);
+        result = _.method<{a: string}>(['a', 0], any, any, any);
+    }
+
+    {
+        let result: (object: {a: string}) => {b: string};
+
+        result = _.method<{a: string}, {b: string}>('a.0');
+        result = _.method<{a: string}, {b: string}>('a.0', any);
+        result = _.method<{a: string}, {b: string}>('a.0', any, any);
+        result = _.method<{a: string}, {b: string}>('a.0', any, any, any);
+
+        result = _.method<{a: string}, {b: string}>(['a', 0]);
+        result = _.method<{a: string}, {b: string}>(['a', 0], any);
+        result = _.method<{a: string}, {b: string}>(['a', 0], any, any);
+        result = _.method<{a: string}, {b: string}>(['a', 0], any, any, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(object: any) => {a: string}>;
+
+        result = _('a.0').method<{a: string}>();
+        result = _('a.0').method<{a: string}>(any);
+        result = _('a.0').method<{a: string}>(any, any);
+        result = _('a.0').method<{a: string}>(any, any, any);
+
+        result = _(['a', 0]).method<{a: string}>();
+        result = _(['a', 0]).method<{a: string}>(any);
+        result = _(['a', 0]).method<{a: string}>(any, any);
+        result = _(['a', 0]).method<{a: string}>(any, any, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(object: {a: string}) => {b: string}>;
+
+        result = _('a.0').method<{a: string}, {b: string}>();
+        result = _('a.0').method<{a: string}, {b: string}>(any);
+        result = _('a.0').method<{a: string}, {b: string}>(any, any);
+        result = _('a.0').method<{a: string}, {b: string}>(any, any, any);
+
+        result = _(['a', 0]).method<{a: string}, {b: string}>();
+        result = _(['a', 0]).method<{a: string}, {b: string}>(any);
+        result = _(['a', 0]).method<{a: string}, {b: string}>(any, any);
+        result = _(['a', 0]).method<{a: string}, {b: string}>(any, any, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(object: any) => {a: string}>;
+
+        result = _('a.0').chain().method<{a: string}>();
+        result = _('a.0').chain().method<{a: string}>(any);
+        result = _('a.0').chain().method<{a: string}>(any, any);
+        result = _('a.0').chain().method<{a: string}>(any, any, any);
+
+        result = _(['a', 0]).chain().method<{a: string}>();
+        result = _(['a', 0]).chain().method<{a: string}>(any);
+        result = _(['a', 0]).chain().method<{a: string}>(any, any);
+        result = _(['a', 0]).chain().method<{a: string}>(any, any, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(object: {a: string}) => {b: string}>;
+
+        result = _('a.0').chain().method<{a: string}, {b: string}>();
+        result = _('a.0').chain().method<{a: string}, {b: string}>(any);
+        result = _('a.0').chain().method<{a: string}, {b: string}>(any, any);
+        result = _('a.0').chain().method<{a: string}, {b: string}>(any, any, any);
+
+        result = _(['a', 0]).chain().method<{a: string}, {b: string}>();
+        result = _(['a', 0]).chain().method<{a: string}, {b: string}>(any);
+        result = _(['a', 0]).chain().method<{a: string}, {b: string}>(any, any);
+        result = _(['a', 0]).chain().method<{a: string}, {b: string}>(any, any, any);
+    }
+}
+
+// _.methodOf
+module TestMethodOf {
+    type SampleObject = {a: {b: () => TResult}[]};
+    type ResultFn = (path: _.StringRepresentable|_.StringRepresentable[]) => TResult;
+
+    let object: SampleObject;
+
+    {
+        let result: ResultFn;
+
+        result = _.methodOf<SampleObject, TResult>(object);
+        result = _.methodOf<SampleObject, TResult>(object, any);
+        result = _.methodOf<SampleObject, TResult>(object, any, any);
+        result = _.methodOf<SampleObject, TResult>(object, any, any, any);
+
+        result = _.methodOf<TResult>(object);
+        result = _.methodOf<TResult>(object, any);
+        result = _.methodOf<TResult>(object, any, any);
+        result = _.methodOf<TResult>(object, any, any, any);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<ResultFn>;
+
+        result = _(object).methodOf<TResult>();
+        result = _(object).methodOf<TResult>(any);
+        result = _(object).methodOf<TResult>(any, any);
+        result = _(object).methodOf<TResult>(any, any, any);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<ResultFn>;
+
+        result = _(object).chain().methodOf<TResult>();
+        result = _(object).chain().methodOf<TResult>(any);
+        result = _(object).chain().methodOf<TResult>(any, any);
+        result = _(object).chain().methodOf<TResult>(any, any, any);
+    }
+}
+
+// _.mixin
+module TestMixin {
+    let source: _.Dictionary<Function>;
+    let options: {chain?: boolean};
+
+    {
+        let result: TResult;
+
+        result = _.mixin<TResult, Object>({}, source);
+        result = _.mixin<TResult, Object>({}, source, options);
+        result = _.mixin<TResult>(source);
+        result = _.mixin<TResult>(source, options);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<TResult>;
+
+        result = _({}).mixin<TResult>(source);
+        result = _({}).mixin<TResult>(source, options);
+        result = _(source).mixin<TResult>();
+        result = _(source).mixin<TResult>(options);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<TResult>;
+
+        result = _({}).chain().mixin<TResult>(source);
+        result = _({}).chain().mixin<TResult>(source, options);
+        result = _(source).chain().mixin<TResult>();
+        result = _(source).chain().mixin<TResult>(options);
+    }
+}
+
+// _.noConflict
+{
+    let result: typeof _;
+    result = _.noConflict();
+    result = _(42).noConflict();
+    result = _<any>([]).noConflict();
+    result = _({}).noConflict();
+}
+
+// _.noop
+module TestNoop {
+    {
+        let result: void;
+
+        result = _.noop();
+        result = _.noop(1);
+        result = _.noop('a', 1);
+        result = _.noop(true, 'a', 1);
+
+        result = _('a').noop(true, 'a', 1);
+        result = _([1]).noop(true, 'a', 1);
+        result = _<string>([]).noop(true, 'a', 1);
+        result = _({}).noop(true, 'a', 1);
+        result = _(any).noop(true, 'a', 1);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<void>;
+
+        result = _('a').chain().noop(true, 'a', 1);
+        result = _([1]).chain().noop(true, 'a', 1);
+        result = _<string>([]).chain().noop(true, 'a', 1);
+        result = _({}).chain().noop(true, 'a', 1);
+        result = _(any).chain().noop(true, 'a', 1);
+    }
+}
+
+// _.property
+module TestProperty {
+    interface SampleObject {
+        a: {
+            b: number[];
+        }
+    }
+
+    {
+        let result: (object: SampleObject) => number;
+
+        result = _.property<SampleObject, number>('a.b[0]');
+        result = _.property<SampleObject, number>(['a', 'b', 0]);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(object: SampleObject) => number>;
+
+        result = _('a.b[0]').property<SampleObject, number>();
+        result = _(['a', 'b', 0]).property<SampleObject, number>();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(object: SampleObject) => number>;
+
+        result = _('a.b[0]').chain().property<SampleObject, number>();
+        result = _(['a', 'b', 0]).chain().property<SampleObject, number>();
+    }
+}
+
+// _.propertyOf
+module TestPropertyOf {
+    interface SampleObject {
+        a: {
+            b: number[];
+        }
+    }
+
+    let object: SampleObject;
+
+    {
+        let result: (path: string|string[]) => any;
+
+        result = _.propertyOf({});
+        result = _.propertyOf<SampleObject>(object);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<(path: string|string[]) => any>;
+
+        result = _({}).propertyOf();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<(path: string|string[]) => any>;
+
+        result = _({}).chain().propertyOf();
+    }
+}
+
+// _.range
+module TestRange {
+    {
+        let result: number[];
+
+        result = _.range(10);
+        result = _.range(1, 11);
+        result = _.range(0, 30, 5);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<number>;
+
+        result = _(10).range();
+        result = _(1).range(11);
+        result = _(0).range(30, 5);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<number>;
+
+        result = _(10).chain().range();
+        result = _(1).chain().range(11);
+        result = _(0).chain().range(30, 5);
+    }
+}
+
+// _.runInContext
+{
+    let result: typeof _;
+    result = _.runInContext();
+    result = _.runInContext({});
+    result = _({}).runInContext();
+}
+
+// _.times
+module TestTimes {
+    let iteratee: (num: number) => TResult;
+
+    {
+        let result: number[];
+
+        result = _.times(42);
+    }
+
+    {
+        let result: TResult[];
+
+        result = _.times(42, iteratee);
+        result = _.times(42, iteratee, any);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<number>;
+
+        result = _(42).times();
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<TResult>;
+
+        result = _(42).times(iteratee);
+        result = _(42).times(iteratee, any);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<number>;
+
+        result = _(42).chain().times();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<TResult>;
+
+        result = _(42).chain().times(iteratee);
+        result = _(42).chain().times(iteratee, any);
+    }
+}
+
+// _.uniqueId
+module TestUniqueId {
+    {
+        let result: string;
+
+        result = _.uniqueId();
+        result = _.uniqueId('');
+
+        result = _('').uniqueId();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('').chain().uniqueId();
+    }
+}
+
+result = <string>_.VERSION;
+result = <_.Support>_.support;
+result = <_.TemplateSettings>_.templateSettings;
+
+// _.partial & _.partialRight
+{
+    function func0(): number {
+        return 42;
+    }
+    function func1(arg1: number): number {
+        return arg1 * 2;
+    }
+    function func2(arg1: number, arg2: string): number {
+        return arg1 * arg2.length;
+    }
+    function func3(arg1: number, arg2: string, arg3: boolean): number {
+        return arg1 * arg2.length + (arg3 ? 1 : 0);
+    }
+    function func4(arg1: number, arg2: string, arg3: boolean, arg4: number): number {
+        return arg1 * arg2.length + (arg3 ? 1 : 0) - arg4;
+    }
+    let res____: () => number;
+    let res1___: (arg1: number                                              ) => number;
+    let res_2__: (              arg2: string                                ) => number;
+    let res__3_: (                              arg3: boolean               ) => number;
+    let res___4: (                                              arg4: number) => number;
+    let res12__: (arg1: number, arg2: string                                ) => number;
+    let res1_3_: (arg1: number,                 arg3: boolean               ) => number;
+    let res1__4: (arg1: number,                                 arg4: number) => number;
+    let res_23_: (              arg2: string,   arg3: boolean               ) => number;
+    let res_2_4: (              arg2: string,                   arg4: number) => number;
+    let res__34: (                              arg3: boolean,  arg4: number) => number;
+    let res123_: (arg1: number, arg2: string,   arg3: boolean               ) => number;
+    let res12_4: (arg1: number, arg2: string,                   arg4: number) => number;
+    let res1_34: (arg1: number,                 arg3: boolean,  arg4: number) => number;
+    let res_234: (              arg2: string,   arg3: boolean,  arg4: number) => number;
+    let res1234: (arg1: number, arg2: string,   arg3: boolean,  arg4: number) => number;
+
+    //
+    // _.partial
+    //
+    // with arity 0 function
+    res____ = _.partial(func0);
+    // with arity 1 function
+    res____ = _.partial(func1, 42       );
+    res1___ = _.partial(func1           );
+    // with arity 2 function
+    res12__ = _.partial(func2           );
+    res_2__ = _.partial(func2, 42       );
+    res1___ = _.partial(func2,  _, "foo");
+    res____ = _.partial(func2, 42, "foo");
+    // with arity 3 function
+    res123_ = _.partial(func3                 );
+    res_23_ = _.partial(func3, 42             );
+    res1_3_ = _.partial(func3,  _, "foo"      );
+    res__3_ = _.partial(func3, 42, "foo"      );
+    res12__ = _.partial(func3,  _,     _, true);
+    res_2__ = _.partial(func3, 42,     _, true);
+    res1___ = _.partial(func3,  _, "foo", true);
+    res____ = _.partial(func3, 42, "foo", true);
+    // with arity 4 function
+    res1234 = _.partial(func4                      );
+    res_234 = _.partial(func4, 42                  );
+    res1_34 = _.partial(func4,  _, "foo"           );
+    res__34 = _.partial(func4, 42, "foo"           );
+    res12_4 = _.partial(func4,  _,     _, true     );
+    res_2_4 = _.partial(func4, 42,     _, true     );
+    res1__4 = _.partial(func4,  _, "foo", true     );
+    res___4 = _.partial(func4, 42, "foo", true     );
+    res123_ = _.partial(func4,  _,     _,    _, 100);
+    res_23_ = _.partial(func4, 42,     _,    _, 100);
+    res1_3_ = _.partial(func4,  _, "foo",    _, 100);
+    res__3_ = _.partial(func4, 42, "foo",    _, 100);
+    res12__ = _.partial(func4,  _,     _, true, 100);
+    res_2__ = _.partial(func4, 42,     _, true, 100);
+    res1___ = _.partial(func4,  _, "foo", true, 100);
+    res____ = _.partial(func4, 42, "foo", true, 100);
+
+    //
+    // _.partialRight
+    //
+    // with arity 0 function
+    res____ = _.partialRight(func0);
+    // with arity 1 function
+    res____ = _.partialRight(func1, 42       );
+    res1___ = _.partialRight(func1           );
+    // with arity 2 function
+    res12__ = _.partialRight(func2           );
+    res_2__ = _.partialRight(func2, 42,     _);
+    res1___ = _.partialRight(func2,     "foo");
+    res____ = _.partialRight(func2, 42, "foo");
+    // with arity 3 function
+    res123_ = _.partialRight(func3                 );
+    res_23_ = _.partialRight(func3, 42,     _,    _);
+    res1_3_ = _.partialRight(func3,     "foo",    _);
+    res__3_ = _.partialRight(func3, 42, "foo",    _);
+    res12__ = _.partialRight(func3,            true);
+    res_2__ = _.partialRight(func3, 42,     _, true);
+    res1___ = _.partialRight(func3,     "foo", true);
+    res____ = _.partialRight(func3, 42, "foo", true);
+    // with arity 4 function
+    res1234 = _.partialRight(func4                      );
+    res_234 = _.partialRight(func4, 42,     _,    _,   _);
+    res1_34 = _.partialRight(func4,     "foo",    _,   _);
+    res__34 = _.partialRight(func4, 42, "foo",    _,   _);
+    res12_4 = _.partialRight(func4,            true,   _);
+    res_2_4 = _.partialRight(func4, 42,     _, true,   _);
+    res1__4 = _.partialRight(func4,     "foo", true,   _);
+    res___4 = _.partialRight(func4, 42, "foo", true,   _);
+    res123_ = _.partialRight(func4,                  100);
+    res_23_ = _.partialRight(func4, 42,     _,    _, 100);
+    res1_3_ = _.partialRight(func4,     "foo",    _, 100);
+    res__3_ = _.partialRight(func4, 42, "foo",    _, 100);
+    res12__ = _.partialRight(func4,            true, 100);
+    res_2__ = _.partialRight(func4, 42,     _, true, 100);
+    res1___ = _.partialRight(func4,     "foo", true, 100);
+    res____ = _.partialRight(func4, 42, "foo", true, 100);
+}
diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index 0293b17e6..af33b66ac 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -858,6 +858,29 @@ module TestIndexOf {
     }
 }
 
+// _.sortedIndexOf
+module TestIndexOf {
+    let array: TResult[];
+    let list: _.List<TResult>;
+    let value: TResult;
+
+    {
+        let result: number;
+
+        result = _.sortedIndexOf<TResult>(array, value);
+        result = _.sortedIndexOf<TResult>(list, value);
+        result = _(array).sortedIndexOf(value);
+        result = _(list).sortedIndexOf<TResult>(value);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(array).chain().sortedIndexOf(value);
+        result = _(list).chain().sortedIndexOf<TResult>(value);
+    }
+}
+
 //_.initial
 module TestInitial {
     let array: TResult[];
@@ -985,134 +1008,6 @@ module TestLastIndexOf {
     }
 }
 
-// _.object
-module TestObject {
-    let arrayOfKeys: string[];
-    let arrayOfValues: number[];
-    let arrayOfKeyValuePairs: (string|number)[][]
-
-    let listOfKeys: _.List<string>;
-    let listOfValues: _.List<number>;
-    let listOfKeyValuePairs: _.List<_.List<string|number>>;
-
-    {
-        let result: _.Dictionary<void>;
-
-        result = _.object<_.Dictionary<void>>(arrayOfKeys);
-        result = _.object<_.Dictionary<void>>(listOfKeys);
-    }
-
-    {
-        let result: _.Dictionary<number>;
-
-        result = _.object<_.Dictionary<number>>(arrayOfKeys, arrayOfValues);
-        result = _.object<_.Dictionary<number>>(arrayOfKeys, listOfValues);
-        result = _.object<_.Dictionary<number>>(listOfKeys, listOfValues);
-        result = _.object<_.Dictionary<number>>(listOfKeys, arrayOfValues);
-
-        result = _.object<number, _.Dictionary<number>>(arrayOfKeys, arrayOfValues);
-        result = _.object<number, _.Dictionary<number>>(arrayOfKeys, listOfValues);
-        result = _.object<number, _.Dictionary<number>>(listOfKeys, listOfValues);
-        result = _.object<number, _.Dictionary<number>>(listOfKeys, arrayOfValues);
-
-        result = _.object<_.Dictionary<number>>(arrayOfKeyValuePairs);
-        result = _.object<_.Dictionary<number>>(listOfKeyValuePairs);
-    }
-
-    {
-        let result: _.Dictionary<any>;
-
-        result = _.object(arrayOfKeys);
-        result = _.object(arrayOfKeys, arrayOfValues);
-        result = _.object(arrayOfKeys, listOfValues);
-
-        result = _.object(listOfKeys);
-        result = _.object(listOfKeys, listOfValues);
-        result = _.object(listOfKeys, arrayOfValues);
-
-        result = _.object<_.Dictionary<number>>(arrayOfKeyValuePairs);
-        result = _.object<_.Dictionary<number>>(listOfKeyValuePairs);
-    }
-
-    {
-        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<void>>;
-
-        result = _(arrayOfKeys).object<_.Dictionary<void>>();
-        result = _(listOfKeys).object<_.Dictionary<void>>();
-    }
-
-    {
-        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<number>>;
-
-        result = _(arrayOfKeys).object<_.Dictionary<number>>(arrayOfValues);
-        result = _(arrayOfKeys).object<_.Dictionary<number>>(listOfValues);
-        result = _(listOfKeys).object<_.Dictionary<number>>(listOfValues);
-        result = _(listOfKeys).object<_.Dictionary<number>>(arrayOfValues);
-
-        result = _(arrayOfKeys).object<number, _.Dictionary<number>>(arrayOfValues);
-        result = _(arrayOfKeys).object<number, _.Dictionary<number>>(listOfValues);
-        result = _(listOfKeys).object<number, _.Dictionary<number>>(listOfValues);
-        result = _(listOfKeys).object<number, _.Dictionary<number>>(arrayOfValues);
-
-        result = _(listOfKeys).object<_.Dictionary<number>>(arrayOfKeyValuePairs);
-        result = _(listOfKeys).object<_.Dictionary<number>>(listOfKeyValuePairs);
-    }
-
-    {
-        let result: _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
-
-        result = _(arrayOfKeys).object();
-        result = _(arrayOfKeys).object(arrayOfValues);
-        result = _(arrayOfKeys).object(listOfValues);
-
-        result = _(listOfKeys).object();
-        result = _(listOfKeys).object(listOfValues);
-        result = _(listOfKeys).object(arrayOfValues);
-
-        result = _(listOfKeys).object(arrayOfKeyValuePairs);
-        result = _(listOfKeys).object(listOfKeyValuePairs);
-    }
-
-    {
-        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<void>>;
-
-        result = _(arrayOfKeys).chain().object<_.Dictionary<void>>();
-        result = _(listOfKeys).chain().object<_.Dictionary<void>>();
-    }
-
-    {
-        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<number>>;
-
-        result = _(arrayOfKeys).chain().object<_.Dictionary<number>>(arrayOfValues);
-        result = _(arrayOfKeys).chain().object<_.Dictionary<number>>(listOfValues);
-        result = _(listOfKeys).chain().object<_.Dictionary<number>>(listOfValues);
-        result = _(listOfKeys).chain().object<_.Dictionary<number>>(arrayOfValues);
-
-        result = _(arrayOfKeys).chain().object<number, _.Dictionary<number>>(arrayOfValues);
-        result = _(arrayOfKeys).chain().object<number, _.Dictionary<number>>(listOfValues);
-        result = _(listOfKeys).chain().object<number, _.Dictionary<number>>(listOfValues);
-        result = _(listOfKeys).chain().object<number, _.Dictionary<number>>(arrayOfValues);
-
-        result = _(listOfKeys).chain().object<_.Dictionary<number>>(arrayOfKeyValuePairs);
-        result = _(listOfKeys).chain().object<_.Dictionary<number>>(listOfKeyValuePairs);
-    }
-
-    {
-        let result: _.LoDashExplicitObjectWrapper<_.Dictionary<any>>;
-
-        result = _(arrayOfKeys).chain().object();
-        result = _(arrayOfKeys).chain().object(arrayOfValues);
-        result = _(arrayOfKeys).chain().object(listOfValues);
-
-        result = _(listOfKeys).chain().object();
-        result = _(listOfKeys).chain().object(listOfValues);
-        result = _(listOfKeys).chain().object(arrayOfValues);
-
-        result = _(listOfKeys).chain().object(arrayOfKeyValuePairs);
-        result = _(listOfKeys).chain().object(listOfKeyValuePairs);
-    }
-}
-
 // _.pull
 module TestPull {
     let array: TResult[];
@@ -1283,31 +1178,31 @@ module TestRemove {
     }
 }
 
-// _.rest
-module TestRest {
+// _.tail
+module TestTail {
     let array: TResult[];
     let list: _.List<TResult>;
 
     {
         let result: TResult[];
 
-        result = _.rest<TResult>(array);
-        result = _.rest<TResult>(list);
+        result = _.tail<TResult>(array);
+        result = _.tail<TResult>(list);
 
     }
 
     {
         let result: _.LoDashImplicitArrayWrapper<TResult>;
 
-        result = _(array).rest();
-        result = _(list).rest<TResult>();
+        result = _(array).tail();
+        result = _(list).tail<TResult>();
     }
 
     {
         let result: _.LoDashExplicitArrayWrapper<TResult>;
 
-        result = _(array).chain().rest();
-        result = _(list).chain().rest<TResult>();
+        result = _(array).chain().tail();
+        result = _(list).chain().tail<TResult>();
     }
 }
 
@@ -1357,70 +1252,89 @@ module TestSortedIndex {
         let result: number;
 
         result = _.sortedIndex<string>('', '');
-        result = _.sortedIndex<string>('', '', stringIterator);
-        result = _.sortedIndex<string>('', '', stringIterator, any);
-        result = _.sortedIndex<string, number>('', '', stringIterator);
-        result = _.sortedIndex<string, number>('', '', stringIterator, any);
 
         result = _.sortedIndex<SampleType>(array, value);
-        result = _.sortedIndex<SampleType>(array, value, arrayIterator);
-        result = _.sortedIndex<SampleType>(array, value, arrayIterator, any);
-        result = _.sortedIndex<SampleType>(array, value, '');
-        result = _.sortedIndex<SampleType>(array, value, {a: 42});
-        result = _.sortedIndex<SampleType, number>(array, value, arrayIterator);
-        result = _.sortedIndex<SampleType, number>(array, value, arrayIterator, any);
-        result = _.sortedIndex<{a: number}, SampleType>(array, value, {a: 42});
 
         result = _.sortedIndex<SampleType>(list, value);
-        result = _.sortedIndex<SampleType>(list, value, listIterator);
-        result = _.sortedIndex<SampleType>(list, value, listIterator, any);
-        result = _.sortedIndex<SampleType>(list, value, '');
-        result = _.sortedIndex<SampleType>(list, value, {a: 42});
-        result = _.sortedIndex<SampleType, number>(list, value, listIterator);
-        result = _.sortedIndex<SampleType, number>(list, value, listIterator, any);
-        result = _.sortedIndex<{a: number}, SampleType>(list, value, {a: 42});
 
         result = _('').sortedIndex('');
-        result = _('').sortedIndex<number>('', stringIterator);
-        result = _('').sortedIndex<number>('', stringIterator, any);
 
         result = _(array).sortedIndex(value);
-        result = _(array).sortedIndex<number>(value, arrayIterator);
-        result = _(array).sortedIndex<number>(value, arrayIterator, any);
-        result = _(array).sortedIndex(value, '');
-        result = _(array).sortedIndex<{a: number}>(value, {a: 42});
 
         result = _(list).sortedIndex<SampleType>(value);
-        result = _(list).sortedIndex<SampleType>(value, listIterator);
-        result = _(list).sortedIndex<SampleType>(value, listIterator, any);
-        result = _(list).sortedIndex<SampleType>(value, '');
-        result = _(list).sortedIndex<SampleType>(value, {a: 42});
-        result = _(list).sortedIndex<SampleType, number>(value, listIterator);
-        result = _(list).sortedIndex<SampleType, number>(value, listIterator, any);
-        result = _(list).sortedIndex<{a: number}, SampleType>(value, {a: 42});
+
     }
 
     {
         let result: _.LoDashExplicitWrapper<number>;
 
         result = _('').chain().sortedIndex('');
-        result = _('').chain().sortedIndex<number>('', stringIterator);
-        result = _('').chain().sortedIndex<number>('', stringIterator, any);
 
         result = _(array).chain().sortedIndex(value);
-        result = _(array).chain().sortedIndex<number>(value, arrayIterator);
-        result = _(array).chain().sortedIndex<number>(value, arrayIterator, any);
-        result = _(array).chain().sortedIndex(value, '');
-        result = _(array).chain().sortedIndex<{a: number}>(value, {a: 42});
 
         result = _(list).chain().sortedIndex<SampleType>(value);
-        result = _(list).chain().sortedIndex<SampleType>(value, listIterator);
-        result = _(list).chain().sortedIndex<SampleType>(value, listIterator, any);
-        result = _(list).chain().sortedIndex<SampleType>(value, '');
-        result = _(list).chain().sortedIndex<SampleType>(value, {a: 42});
-        result = _(list).chain().sortedIndex<SampleType, number>(value, listIterator);
-        result = _(list).chain().sortedIndex<SampleType, number>(value, listIterator, any);
-        result = _(list).chain().sortedIndex<{a: number}, SampleType>(value, {a: 42});
+
+    }
+}
+
+// _.sortedIndexBy
+module TestSortedIndexBy {
+    type SampleType = {a: number; b: string; c: boolean;};
+
+    let array: SampleType[];
+    let list: _.List<SampleType>;
+
+    let value: SampleType;
+
+    let stringIterator: (x: string) => number;
+    let arrayIterator: (x: SampleType) => number;
+    let listIterator: (x: SampleType) => number;
+
+    {
+        let result: number;
+
+        result = _.sortedIndexBy<string>('', '', stringIterator);
+        result = _.sortedIndexBy<string, number>('', '', stringIterator);
+
+        result = _.sortedIndexBy<SampleType>(array, value, arrayIterator);
+        result = _.sortedIndexBy<SampleType>(array, value, '');
+        result = _.sortedIndexBy<SampleType>(array, value, {a: 42});
+        result = _.sortedIndexBy<SampleType, number>(array, value, arrayIterator);
+        result = _.sortedIndexBy<{a: number}, SampleType>(array, value, {a: 42});
+
+        result = _.sortedIndexBy<SampleType>(list, value, listIterator);
+        result = _.sortedIndexBy<SampleType>(list, value, '');
+        result = _.sortedIndexBy<SampleType>(list, value, {a: 42});
+        result = _.sortedIndexBy<SampleType, number>(list, value, listIterator);
+        result = _.sortedIndexBy<{a: number}, SampleType>(list, value, {a: 42});
+
+        result = _('').sortedIndexBy<number>('', stringIterator);
+
+        result = _(array).sortedIndexBy<number>(value, arrayIterator);
+        result = _(array).sortedIndexBy(value, '');
+        result = _(array).sortedIndexBy<{a: number}>(value, {a: 42});
+
+        result = _(list).sortedIndexBy<SampleType>(value, listIterator);
+        result = _(list).sortedIndexBy<SampleType>(value, '');
+        result = _(list).sortedIndexBy<SampleType>(value, {a: 42});
+        result = _(list).sortedIndexBy<SampleType, number>(value, listIterator);
+        result = _(list).sortedIndexBy<{a: number}, SampleType>(value, {a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _('').chain().sortedIndexBy<number>('', stringIterator);
+
+        result = _(array).chain().sortedIndexBy<number>(value, arrayIterator);
+        result = _(array).chain().sortedIndexBy(value, '');
+        result = _(array).chain().sortedIndexBy<{a: number}>(value, {a: 42});
+
+        result = _(list).chain().sortedIndexBy<SampleType>(value, listIterator);
+        result = _(list).chain().sortedIndexBy<SampleType>(value, '');
+        result = _(list).chain().sortedIndexBy<SampleType>(value, {a: 42});
+        result = _(list).chain().sortedIndexBy<SampleType, number>(value, listIterator);
+        result = _(list).chain().sortedIndexBy<{a: number}, SampleType>(value, {a: 42});
     }
 }
 
@@ -1441,70 +1355,87 @@ module TestSortedLastIndex {
         let result: number;
 
         result = _.sortedLastIndex<string>('', '');
-        result = _.sortedLastIndex<string>('', '', stringIterator);
-        result = _.sortedLastIndex<string>('', '', stringIterator, any);
-        result = _.sortedLastIndex<string, number>('', '', stringIterator);
-        result = _.sortedLastIndex<string, number>('', '', stringIterator, any);
 
         result = _.sortedLastIndex<SampleType>(array, value);
-        result = _.sortedLastIndex<SampleType>(array, value, arrayIterator);
-        result = _.sortedLastIndex<SampleType>(array, value, arrayIterator, any);
-        result = _.sortedLastIndex<SampleType>(array, value, '');
-        result = _.sortedLastIndex<SampleType>(array, value, {a: 42});
-        result = _.sortedLastIndex<SampleType, number>(array, value, arrayIterator);
-        result = _.sortedLastIndex<SampleType, number>(array, value, arrayIterator, any);
-        result = _.sortedLastIndex<{a: number}, SampleType>(array, value, {a: 42});
 
         result = _.sortedLastIndex<SampleType>(list, value);
-        result = _.sortedLastIndex<SampleType>(list, value, listIterator);
-        result = _.sortedLastIndex<SampleType>(list, value, listIterator, any);
-        result = _.sortedLastIndex<SampleType>(list, value, '');
-        result = _.sortedLastIndex<SampleType>(list, value, {a: 42});
-        result = _.sortedLastIndex<SampleType, number>(list, value, listIterator);
-        result = _.sortedLastIndex<SampleType, number>(list, value, listIterator, any);
-        result = _.sortedLastIndex<{a: number}, SampleType>(list, value, {a: 42});
 
         result = _('').sortedLastIndex('');
-        result = _('').sortedLastIndex<number>('', stringIterator);
-        result = _('').sortedLastIndex<number>('', stringIterator, any);
 
         result = _(array).sortedLastIndex(value);
-        result = _(array).sortedLastIndex<number>(value, arrayIterator);
-        result = _(array).sortedLastIndex<number>(value, arrayIterator, any);
-        result = _(array).sortedLastIndex(value, '');
-        result = _(array).sortedLastIndex<{a: number}>(value, {a: 42});
 
         result = _(list).sortedLastIndex<SampleType>(value);
-        result = _(list).sortedLastIndex<SampleType>(value, listIterator);
-        result = _(list).sortedLastIndex<SampleType>(value, listIterator, any);
-        result = _(list).sortedLastIndex<SampleType>(value, '');
-        result = _(list).sortedLastIndex<SampleType>(value, {a: 42});
-        result = _(list).sortedLastIndex<SampleType, number>(value, listIterator);
-        result = _(list).sortedLastIndex<SampleType, number>(value, listIterator, any);
-        result = _(list).sortedLastIndex<{a: number}, SampleType>(value, {a: 42});
     }
 
     {
         let result: _.LoDashExplicitWrapper<number>;
 
         result = _('').chain().sortedLastIndex('');
-        result = _('').chain().sortedLastIndex<number>('', stringIterator);
-        result = _('').chain().sortedLastIndex<number>('', stringIterator, any);
 
         result = _(array).chain().sortedLastIndex(value);
-        result = _(array).chain().sortedLastIndex<number>(value, arrayIterator);
-        result = _(array).chain().sortedLastIndex<number>(value, arrayIterator, any);
-        result = _(array).chain().sortedLastIndex(value, '');
-        result = _(array).chain().sortedLastIndex<{a: number}>(value, {a: 42});
 
         result = _(list).chain().sortedLastIndex<SampleType>(value);
-        result = _(list).chain().sortedLastIndex<SampleType>(value, listIterator);
-        result = _(list).chain().sortedLastIndex<SampleType>(value, listIterator, any);
-        result = _(list).chain().sortedLastIndex<SampleType>(value, '');
-        result = _(list).chain().sortedLastIndex<SampleType>(value, {a: 42});
-        result = _(list).chain().sortedLastIndex<SampleType, number>(value, listIterator);
-        result = _(list).chain().sortedLastIndex<SampleType, number>(value, listIterator, any);
-        result = _(list).chain().sortedLastIndex<{a: number}, SampleType>(value, {a: 42});
+    }
+}
+
+// _.sortedLastIndexBy
+module TestSortedLastIndexBy {
+    type SampleType = {a: number; b: string; c: boolean;};
+
+    let array: SampleType[];
+    let list: _.List<SampleType>;
+
+    let value: SampleType;
+
+    let stringIterator: (x: string) => number;
+    let arrayIterator: (x: SampleType) => number;
+    let listIterator: (x: SampleType) => number;
+
+    {
+        let result: number;
+
+        result = _.sortedLastIndexBy<string>('', '', stringIterator);
+        result = _.sortedLastIndexBy<string, number>('', '', stringIterator);
+
+        result = _.sortedLastIndexBy<SampleType>(array, value, arrayIterator);
+        result = _.sortedLastIndexBy<SampleType>(array, value, '');
+        result = _.sortedLastIndexBy<SampleType>(array, value, {a: 42});
+        result = _.sortedLastIndexBy<SampleType, number>(array, value, arrayIterator);
+        result = _.sortedLastIndexBy<{a: number}, SampleType>(array, value, {a: 42});
+
+        result = _.sortedLastIndexBy<SampleType>(list, value, listIterator);
+        result = _.sortedLastIndexBy<SampleType>(list, value, '');
+        result = _.sortedLastIndexBy<SampleType>(list, value, {a: 42});
+        result = _.sortedLastIndexBy<SampleType, number>(list, value, listIterator);
+        result = _.sortedLastIndexBy<{a: number}, SampleType>(list, value, {a: 42});
+
+        result = _('').sortedLastIndexBy<number>('', stringIterator);
+
+        result = _(array).sortedLastIndexBy<number>(value, arrayIterator);
+        result = _(array).sortedLastIndexBy(value, '');
+        result = _(array).sortedLastIndexBy<{a: number}>(value, {a: 42});
+
+        result = _(list).sortedLastIndexBy<SampleType>(value, listIterator);
+        result = _(list).sortedLastIndexBy<SampleType>(value, '');
+        result = _(list).sortedLastIndexBy<SampleType>(value, {a: 42});
+        result = _(list).sortedLastIndexBy<SampleType, number>(value, listIterator);
+        result = _(list).sortedLastIndexBy<{a: number}, SampleType>(value, {a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _('').chain().sortedLastIndexBy<number>('', stringIterator);
+
+        result = _(array).chain().sortedLastIndexBy<number>(value, arrayIterator);
+        result = _(array).chain().sortedLastIndexBy(value, '');
+        result = _(array).chain().sortedLastIndexBy<{a: number}>(value, {a: 42});
+
+        result = _(list).chain().sortedLastIndexBy<SampleType>(value, listIterator);
+        result = _(list).chain().sortedLastIndexBy<SampleType>(value, '');
+        result = _(list).chain().sortedLastIndexBy<SampleType>(value, {a: 42});
+        result = _(list).chain().sortedLastIndexBy<SampleType, number>(value, listIterator);
+        result = _(list).chain().sortedLastIndexBy<{a: number}, SampleType>(value, {a: 42});
     }
 }
 
@@ -1794,158 +1725,46 @@ module TestUniq {
 
     {
         let result: string[];
-
         result = _.uniq<string>('abc');
-        result = _.uniq<string>('abc', true);
-        result = _.uniq<string>('abc', true, stringIterator);
-        result = _.uniq<string>('abc', true, stringIterator, any);
-        result = _.uniq<string, string>('abc', true, stringIterator);
-        result = _.uniq<string, string>('abc', true, stringIterator, any);
-        result = _.uniq<string>('abc', stringIterator);
-        result = _.uniq<string>('abc', stringIterator, any);
-        result = _.uniq<string, string>('abc', stringIterator);
-        result = _.uniq<string, string>('abc', stringIterator, any);
     }
 
     {
         let result: SampleObject[];
 
         result = _.uniq<SampleObject>(array);
-        result = _.uniq<SampleObject>(array, true);
-        result = _.uniq<SampleObject>(array, true, listIterator);
-        result = _.uniq<SampleObject>(array, true, listIterator, any);
-        result = _.uniq<SampleObject, number>(array, true, listIterator);
-        result = _.uniq<SampleObject, number>(array, true, listIterator, any);
-        result = _.uniq<SampleObject>(array, listIterator);
-        result = _.uniq<SampleObject>(array, listIterator, any);
-        result = _.uniq<SampleObject, number>(array, listIterator);
-        result = _.uniq<SampleObject, number>(array, listIterator, any);
-        result = _.uniq<SampleObject>(array, true, 'a');
-        result = _.uniq<SampleObject>(array, true, 'a', any);
-        result = _.uniq<SampleObject>(array, 'a');
-        result = _.uniq<SampleObject>(array, 'a', any);
-        result = _.uniq<SampleObject>(array, true, {a: 42});
-        result = _.uniq<{a: number}, SampleObject>(array, true, {a: 42});
-        result = _.uniq<SampleObject>(array, {a: 42});
-        result = _.uniq<{a: number}, SampleObject>(array, {a: 42});
-
         result = _.uniq<SampleObject>(list);
-        result = _.uniq<SampleObject>(list, true);
-        result = _.uniq<SampleObject>(list, true, listIterator);
-        result = _.uniq<SampleObject>(list, true, listIterator, any);
-        result = _.uniq<SampleObject, number>(list, true, listIterator);
-        result = _.uniq<SampleObject, number>(list, true, listIterator, any);
-        result = _.uniq<SampleObject>(list, listIterator);
-        result = _.uniq<SampleObject>(list, listIterator, any);
-        result = _.uniq<SampleObject, number>(list, listIterator);
-        result = _.uniq<SampleObject, number>(list, listIterator, any);
-        result = _.uniq<SampleObject>(list, true, 'a');
-        result = _.uniq<SampleObject>(list, true, 'a', any);
-        result = _.uniq<SampleObject>(list, 'a');
-        result = _.uniq<SampleObject>(list, 'a', any);
-        result = _.uniq<SampleObject>(list, true, {a: 42});
-        result = _.uniq<{a: number}, SampleObject>(list, true, {a: 42});
-        result = _.uniq<SampleObject>(list, {a: 42});
-        result = _.uniq<{a: number}, SampleObject>(list, {a: 42});
     }
 
     {
         let result: _.LoDashImplicitArrayWrapper<string>;
-
         result = _('abc').uniq();
-        result = _('abc').uniq(true);
-        result = _('abc').uniq<string>(true, stringIterator);
-        result = _('abc').uniq<string>(true, stringIterator, any);
-        result = _('abc').uniq<string>(stringIterator);
-        result = _('abc').uniq<string>(stringIterator, any);
     }
 
     {
         let result: _.LoDashImplicitArrayWrapper<SampleObject>;
 
         result = _(array).uniq();
-        result = _(array).uniq(true);
-        result = _(array).uniq<number>(true, listIterator);
-        result = _(array).uniq<number>(true, listIterator, any);
-        result = _(array).uniq<number>(listIterator);
-        result = _(array).uniq<number>(listIterator, any);
-        result = _(array).uniq(true, 'a');
-        result = _(array).uniq(true, 'a', any);
-        result = _(array).uniq('a');
-        result = _(array).uniq('a', any);
-        result = _(array).uniq<{a: number}>(true, {a: 42});
-        result = _(array).uniq<{a: number}>({a: 42});
-
         result = _(list).uniq<SampleObject>();
-        result = _(list).uniq<SampleObject>(true);
-        result = _(list).uniq<SampleObject>(true, listIterator);
-        result = _(list).uniq<SampleObject>(true, listIterator, any);
-        result = _(list).uniq<SampleObject, number>(true, listIterator);
-        result = _(list).uniq<SampleObject, number>(true, listIterator, any);
-        result = _(list).uniq<SampleObject>(listIterator);
-        result = _(list).uniq<SampleObject>(listIterator, any);
-        result = _(list).uniq<SampleObject, number>(listIterator);
-        result = _(list).uniq<SampleObject, number>(listIterator, any);
-        result = _(list).uniq<SampleObject>(true, 'a');
-        result = _(list).uniq<SampleObject>(true, 'a', any);
-        result = _(list).uniq<SampleObject>('a');
-        result = _(list).uniq<SampleObject>('a', any);
-        result = _(list).uniq<SampleObject>(true, {a: 42});
-        result = _(list).uniq<{a: number}, SampleObject>(true, {a: 42});
-        result = _(list).uniq<SampleObject>({a: 42});
-        result = _(list).uniq<{a: number}, SampleObject>({a: 42});
     }
 
     {
         let result: _.LoDashExplicitArrayWrapper<string>;
 
         result = _('abc').chain().uniq();
-        result = _('abc').chain().uniq(true);
-        result = _('abc').chain().uniq<string>(true, stringIterator);
-        result = _('abc').chain().uniq<string>(true, stringIterator, any);
-        result = _('abc').chain().uniq<string>(stringIterator);
-        result = _('abc').chain().uniq<string>(stringIterator, any);
     }
 
     {
         let result: _.LoDashExplicitArrayWrapper<SampleObject>;
 
         result = _(array).chain().uniq();
-        result = _(array).chain().uniq(true);
-        result = _(array).chain().uniq<number>(true, listIterator);
-        result = _(array).chain().uniq<number>(true, listIterator, any);
-        result = _(array).chain().uniq<number>(listIterator);
-        result = _(array).chain().uniq<number>(listIterator, any);
-        result = _(array).chain().uniq(true, 'a');
-        result = _(array).chain().uniq(true, 'a', any);
-        result = _(array).chain().uniq('a');
-        result = _(array).chain().uniq('a', any);
-        result = _(array).chain().uniq<{a: number}>(true, {a: 42});
-        result = _(array).chain().uniq<{a: number}>({a: 42});
-
         result = _(list).chain().uniq<SampleObject>();
-        result = _(list).chain().uniq<SampleObject>(true);
-        result = _(list).chain().uniq<SampleObject>(true, listIterator);
-        result = _(list).chain().uniq<SampleObject>(true, listIterator, any);
-        result = _(list).chain().uniq<SampleObject, number>(true, listIterator);
-        result = _(list).chain().uniq<SampleObject, number>(true, listIterator, any);
-        result = _(list).chain().uniq<SampleObject>(listIterator);
-        result = _(list).chain().uniq<SampleObject>(listIterator, any);
-        result = _(list).chain().uniq<SampleObject, number>(listIterator);
-        result = _(list).chain().uniq<SampleObject, number>(listIterator, any);
-        result = _(list).chain().uniq<SampleObject>(true, 'a');
-        result = _(list).chain().uniq<SampleObject>(true, 'a', any);
-        result = _(list).chain().uniq<SampleObject>('a');
-        result = _(list).chain().uniq<SampleObject>('a', any);
-        result = _(list).chain().uniq<SampleObject>(true, {a: 42});
-        result = _(list).chain().uniq<{a: number}, SampleObject>(true, {a: 42});
-        result = _(list).chain().uniq<SampleObject>({a: 42});
-        result = _(list).chain().uniq<{a: number}, SampleObject>({a: 42});
+
     }
 }
 
-// _.unique
-module TestUnique {
+
+// _.uniqBy
+module TestUniqBy {
     type SampleObject = {a: number; b: string; c: boolean};
 
     let array: SampleObject[];
@@ -1957,152 +1776,182 @@ module TestUnique {
     {
         let result: string[];
 
-        result = _.unique<string>('abc');
-        result = _.unique<string>('abc', true);
-        result = _.unique<string>('abc', true, stringIterator);
-        result = _.unique<string>('abc', true, stringIterator, any);
-        result = _.unique<string, string>('abc', true, stringIterator);
-        result = _.unique<string, string>('abc', true, stringIterator, any);
-        result = _.unique<string>('abc', stringIterator);
-        result = _.unique<string>('abc', stringIterator, any);
-        result = _.unique<string, string>('abc', stringIterator);
-        result = _.unique<string, string>('abc', stringIterator, any);
+        result = _.uniqBy<string>('abc', stringIterator);
+        result = _.uniqBy<string, string>('abc', stringIterator);
     }
 
     {
         let result: SampleObject[];
 
-        result = _.unique<SampleObject>(array);
-        result = _.unique<SampleObject>(array, true);
-        result = _.unique<SampleObject>(array, true, listIterator);
-        result = _.unique<SampleObject>(array, true, listIterator, any);
-        result = _.unique<SampleObject, number>(array, true, listIterator);
-        result = _.unique<SampleObject, number>(array, true, listIterator, any);
-        result = _.unique<SampleObject>(array, listIterator);
-        result = _.unique<SampleObject>(array, listIterator, any);
-        result = _.unique<SampleObject, number>(array, listIterator);
-        result = _.unique<SampleObject, number>(array, listIterator, any);
-        result = _.unique<SampleObject>(array, true, 'a');
-        result = _.unique<SampleObject>(array, true, 'a', any);
-        result = _.unique<SampleObject>(array, 'a');
-        result = _.unique<SampleObject>(array, 'a', any);
-        result = _.unique<SampleObject>(array, true, {a: 42});
-        result = _.unique<{a: number}, SampleObject>(array, true, {a: 42});
-        result = _.unique<SampleObject>(array, {a: 42});
-        result = _.unique<{a: number}, SampleObject>(array, {a: 42});
+        result = _.uniqBy<SampleObject>(array, listIterator);
+        result = _.uniqBy<SampleObject, number>(array, listIterator);
+        result = _.uniqBy<SampleObject>(array, 'a');
+        result = _.uniqBy<SampleObject>(array, {a: 42});
+        result = _.uniqBy<{a: number}, SampleObject>(array, {a: 42});
 
-        result = _.unique<SampleObject>(list);
-        result = _.unique<SampleObject>(list, true);
-        result = _.unique<SampleObject>(list, true, listIterator);
-        result = _.unique<SampleObject>(list, true, listIterator, any);
-        result = _.unique<SampleObject, number>(list, true, listIterator);
-        result = _.unique<SampleObject, number>(list, true, listIterator, any);
-        result = _.unique<SampleObject>(list, listIterator);
-        result = _.unique<SampleObject>(list, listIterator, any);
-        result = _.unique<SampleObject, number>(list, listIterator);
-        result = _.unique<SampleObject, number>(list, listIterator, any);
-        result = _.unique<SampleObject>(list, true, 'a');
-        result = _.unique<SampleObject>(list, true, 'a', any);
-        result = _.unique<SampleObject>(list, 'a');
-        result = _.unique<SampleObject>(list, 'a', any);
-        result = _.unique<SampleObject>(list, true, {a: 42});
-        result = _.unique<{a: number}, SampleObject>(list, true, {a: 42});
-        result = _.unique<SampleObject>(list, {a: 42});
-        result = _.unique<{a: number}, SampleObject>(list, {a: 42});
+        result = _.uniqBy<SampleObject>(list, listIterator);
+        result = _.uniqBy<SampleObject, number>(list, listIterator);
+        result = _.uniqBy<SampleObject>(list, 'a');
+        result = _.uniqBy<SampleObject>(list, {a: 42});
+        result = _.uniqBy<{a: number}, SampleObject>(list, {a: 42});
     }
 
     {
         let result: _.LoDashImplicitArrayWrapper<string>;
 
-        result = _('abc').unique();
-        result = _('abc').unique(true);
-        result = _('abc').unique<string>(true, stringIterator);
-        result = _('abc').unique<string>(true, stringIterator, any);
-        result = _('abc').unique<string>(stringIterator);
-        result = _('abc').unique<string>(stringIterator, any);
+        result = _('abc').uniqBy<string>(stringIterator);
     }
 
     {
         let result: _.LoDashImplicitArrayWrapper<SampleObject>;
 
-        result = _(array).unique();
-        result = _(array).unique(true);
-        result = _(array).unique<number>(true, listIterator);
-        result = _(array).unique<number>(true, listIterator, any);
-        result = _(array).unique<number>(listIterator);
-        result = _(array).unique<number>(listIterator, any);
-        result = _(array).unique(true, 'a');
-        result = _(array).unique(true, 'a', any);
-        result = _(array).unique('a');
-        result = _(array).unique('a', any);
-        result = _(array).unique<{a: number}>(true, {a: 42});
-        result = _(array).unique<{a: number}>({a: 42});
+        result = _(array).uniqBy<number>(listIterator);
+        result = _(array).uniqBy('a');
+        result = _(array).uniqBy<{a: number}>({a: 42});
 
-        result = _(list).unique<SampleObject>();
-        result = _(list).unique<SampleObject>(true);
-        result = _(list).unique<SampleObject>(true, listIterator);
-        result = _(list).unique<SampleObject>(true, listIterator, any);
-        result = _(list).unique<SampleObject, number>(true, listIterator);
-        result = _(list).unique<SampleObject, number>(true, listIterator, any);
-        result = _(list).unique<SampleObject>(listIterator);
-        result = _(list).unique<SampleObject>(listIterator, any);
-        result = _(list).unique<SampleObject, number>(listIterator);
-        result = _(list).unique<SampleObject, number>(listIterator, any);
-        result = _(list).unique<SampleObject>(true, 'a');
-        result = _(list).unique<SampleObject>(true, 'a', any);
-        result = _(list).unique<SampleObject>('a');
-        result = _(list).unique<SampleObject>('a', any);
-        result = _(list).unique<SampleObject>(true, {a: 42});
-        result = _(list).unique<{a: number}, SampleObject>(true, {a: 42});
-        result = _(list).unique<SampleObject>({a: 42});
-        result = _(list).unique<{a: number}, SampleObject>({a: 42});
+        result = _(list).uniqBy<SampleObject>(listIterator);
+        result = _(list).uniqBy<SampleObject, number>(listIterator);
+        result = _(list).uniqBy<SampleObject>('a');
+        result = _(list).uniqBy<SampleObject>({a: 42});
+        result = _(list).uniqBy<{a: number}, SampleObject>({a: 42});
     }
 
     {
         let result: _.LoDashExplicitArrayWrapper<string>;
 
-        result = _('abc').chain().unique();
-        result = _('abc').chain().unique(true);
-        result = _('abc').chain().unique<string>(true, stringIterator);
-        result = _('abc').chain().unique<string>(true, stringIterator, any);
-        result = _('abc').chain().unique<string>(stringIterator);
-        result = _('abc').chain().unique<string>(stringIterator, any);
+        result = _('abc').chain().uniqBy<string>(stringIterator);
     }
 
     {
         let result: _.LoDashExplicitArrayWrapper<SampleObject>;
 
-        result = _(array).chain().unique();
-        result = _(array).chain().unique(true);
-        result = _(array).chain().unique<number>(true, listIterator);
-        result = _(array).chain().unique<number>(true, listIterator, any);
-        result = _(array).chain().unique<number>(listIterator);
-        result = _(array).chain().unique<number>(listIterator, any);
-        result = _(array).chain().unique(true, 'a');
-        result = _(array).chain().unique(true, 'a', any);
-        result = _(array).chain().unique('a');
-        result = _(array).chain().unique('a', any);
-        result = _(array).chain().unique<{a: number}>(true, {a: 42});
-        result = _(array).chain().unique<{a: number}>({a: 42});
+        result = _(array).chain().uniqBy<number>(listIterator);
+        result = _(array).chain().uniqBy('a');
+        result = _(array).chain().uniqBy<{a: number}>({a: 42});
 
-        result = _(list).chain().unique<SampleObject>();
-        result = _(list).chain().unique<SampleObject>(true);
-        result = _(list).chain().unique<SampleObject>(true, listIterator);
-        result = _(list).chain().unique<SampleObject>(true, listIterator, any);
-        result = _(list).chain().unique<SampleObject, number>(true, listIterator);
-        result = _(list).chain().unique<SampleObject, number>(true, listIterator, any);
-        result = _(list).chain().unique<SampleObject>(listIterator);
-        result = _(list).chain().unique<SampleObject>(listIterator, any);
-        result = _(list).chain().unique<SampleObject, number>(listIterator);
-        result = _(list).chain().unique<SampleObject, number>(listIterator, any);
-        result = _(list).chain().unique<SampleObject>(true, 'a');
-        result = _(list).chain().unique<SampleObject>(true, 'a', any);
-        result = _(list).chain().unique<SampleObject>('a');
-        result = _(list).chain().unique<SampleObject>('a', any);
-        result = _(list).chain().unique<SampleObject>(true, {a: 42});
-        result = _(list).chain().unique<{a: number}, SampleObject>(true, {a: 42});
-        result = _(list).chain().unique<SampleObject>({a: 42});
-        result = _(list).chain().unique<{a: number}, SampleObject>({a: 42});
+        result = _(list).chain().uniqBy<SampleObject>(listIterator);
+        result = _(list).chain().uniqBy<SampleObject, number>(listIterator);
+        result = _(list).chain().uniqBy<SampleObject>('a');
+        result = _(list).chain().uniqBy<SampleObject>({a: 42});
+        result = _(list).chain().uniqBy<{a: number}, SampleObject>({a: 42});
+    }
+}
+
+// _.sortedUniq
+module TestSortedUniq {
+    type SampleObject = {a: number; b: string; c: boolean};
+
+    let array: SampleObject[];
+    let list: _.List<SampleObject>;
+
+    let stringIterator: (value: string, index: number, collection: string) => string;
+    let listIterator: (value: SampleObject, index: number, collection: _.List<SampleObject>) => number;
+
+    {
+        let result: string[];
+        result = _.sortedUniq<string>('abc');
+    }
+
+    {
+        let result: SampleObject[];
+        result = _.sortedUniq<SampleObject>(array);
+        result = _.sortedUniq<SampleObject>(list);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+        result = _('abc').sortedUniq();
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<SampleObject>;
+        result = _(array).sortedUniq();
+        result = _(list).sortedUniq<SampleObject>();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+        result = _('abc').chain().sortedUniq();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<SampleObject>;
+        result = _(array).chain().sortedUniq();
+        result = _(list).chain().sortedUniq<SampleObject>();
+    }
+}
+
+// _.sortedUniqBy
+module TestSortedUniqBy {
+    type SampleObject = {a: number; b: string; c: boolean};
+
+    let array: SampleObject[];
+    let list: _.List<SampleObject>;
+
+    let stringIterator: (value: string, index: number, collection: string) => string;
+    let listIterator: (value: SampleObject, index: number, collection: _.List<SampleObject>) => number;
+
+    {
+        let result: string[];
+
+        result = _.sortedUniqBy<string>('abc', stringIterator);
+        result = _.sortedUniqBy<string, string>('abc', stringIterator);
+    }
+
+    {
+        let result: SampleObject[];
+
+        result = _.sortedUniqBy<SampleObject>(array, listIterator);
+        result = _.sortedUniqBy<SampleObject, number>(array, listIterator);
+        result = _.sortedUniqBy<SampleObject>(array, 'a');
+        result = _.sortedUniqBy<SampleObject>(array, {a: 42});
+        result = _.sortedUniqBy<{a: number}, SampleObject>(array, {a: 42});
+
+        result = _.sortedUniqBy<SampleObject>(list, listIterator);
+        result = _.sortedUniqBy<SampleObject, number>(list, listIterator);
+        result = _.sortedUniqBy<SampleObject>(list, 'a');
+        result = _.sortedUniqBy<SampleObject>(list, {a: 42});
+        result = _.sortedUniqBy<{a: number}, SampleObject>(list, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('abc').sortedUniqBy<string>(stringIterator);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<SampleObject>;
+
+        result = _(array).sortedUniqBy<number>(listIterator);
+        result = _(array).sortedUniqBy('a');
+        result = _(array).sortedUniqBy<{a: number}>({a: 42});
+
+        result = _(list).sortedUniqBy<SampleObject>(listIterator);
+        result = _(list).sortedUniqBy<SampleObject, number>(listIterator);
+        result = _(list).sortedUniqBy<SampleObject>('a');
+        result = _(list).sortedUniqBy<SampleObject>({a: 42});
+        result = _(list).sortedUniqBy<{a: number}, SampleObject>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _('abc').chain().sortedUniqBy<string>(stringIterator);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<SampleObject>;
+
+        result = _(array).chain().sortedUniqBy<number>(listIterator);
+        result = _(array).chain().sortedUniqBy('a');
+        result = _(array).chain().sortedUniqBy<{a: number}>({a: 42});
+
+        result = _(list).chain().sortedUniqBy<SampleObject>(listIterator);
+        result = _(list).chain().sortedUniqBy<SampleObject, number>(listIterator);
+        result = _(list).chain().sortedUniqBy<SampleObject>('a');
+        result = _(list).chain().sortedUniqBy<SampleObject>({a: 42});
+        result = _(list).chain().sortedUniqBy<{a: number}, SampleObject>({a: 42});
     }
 }
 
@@ -2847,44 +2696,6 @@ module TestReverse {
     }
 }
 
-// _.prototype.run
-module TestRun {
-    {
-        let result: string;
-
-        result = _('').run();
-        result = _('').chain().run();
-    }
-
-    {
-        let result: number;
-
-        result = _(42).run();
-        result = _(42).chain().run();
-    }
-
-    {
-        let result: boolean;
-
-        result = _(true).run();
-        result = _(true).chain().run();
-    }
-
-    {
-        let result: string[];
-
-        result = _<string>([]).run();
-        result = _<string>([]).chain().run();
-    }
-
-    {
-        let result: {a: string};
-
-        result = _({a: ''}).run();
-        result = _({a: ''}).chain().run();
-    }
-}
-
 // _.prototype.toJSON
 module TestToJSON {
     {
@@ -3020,170 +2831,6 @@ module TestValueOf {
  * Collection *
  **************/
 
-// _.all
-module TestAll {
-    let array: TResult[];
-    let list: _.List<TResult>;
-    let dictionary: _.Dictionary<TResult>;
-
-    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
-    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => boolean;
-
-    {
-        let result: boolean;
-
-        result = _.all<TResult>(array);
-        result = _.all<TResult>(array, listIterator);
-        result = _.all<TResult>(array, listIterator, any);
-        result = _.all<TResult>(array, '');
-        result = _.all<{a: number}, TResult>(array, {a: 42});
-
-        result = _.all<TResult>(list);
-        result = _.all<TResult>(list, listIterator);
-        result = _.all<TResult>(list, listIterator, any);
-        result = _.all<TResult>(list, '');
-        result = _.all<{a: number}, TResult>(list, {a: 42});
-
-        result = _.all<TResult>(dictionary);
-        result = _.all<TResult>(dictionary, dictionaryIterator);
-        result = _.all<TResult>(dictionary, dictionaryIterator, any);
-        result = _.all<TResult>(dictionary, '');
-        result = _.all<{a: number}, TResult>(dictionary, {a: 42});
-
-        result = _(array).all();
-        result = _(array).all(listIterator);
-        result = _(array).all(listIterator, any);
-        result = _(array).all('');
-        result = _(array).all<{a: number}>({a: 42});
-
-        result = _(list).all<TResult>();
-        result = _(list).all<TResult>(listIterator);
-        result = _(list).all<TResult>(listIterator, any);
-        result = _(list).all('');
-        result = _(list).all<{a: number}>({a: 42});
-
-        result = _(dictionary).all<TResult>();
-        result = _(dictionary).all<TResult>(dictionaryIterator);
-        result = _(dictionary).all<TResult>(dictionaryIterator, any);
-        result = _(dictionary).all('');
-        result = _(dictionary).all<{a: number}>({a: 42});
-    }
-
-    {
-        let result: _.LoDashExplicitWrapper<boolean>;
-
-        result = _(array).chain().all();
-        result = _(array).chain().all(listIterator);
-        result = _(array).chain().all(listIterator, any);
-        result = _(array).chain().all('');
-        result = _(array).chain().all<{a: number}>({a: 42});
-
-        result = _(list).chain().all<TResult>();
-        result = _(list).chain().all<TResult>(listIterator);
-        result = _(list).chain().all<TResult>(listIterator, any);
-        result = _(list).chain().all('');
-        result = _(list).chain().all<{a: number}>({a: 42});
-
-        result = _(dictionary).chain().all<TResult>();
-        result = _(dictionary).chain().all<TResult>(dictionaryIterator);
-        result = _(dictionary).chain().all<TResult>(dictionaryIterator, any);
-        result = _(dictionary).chain().all('');
-        result = _(dictionary).chain().all<{a: number}>({a: 42});
-    }
-}
-
-// _.any
-module TestAny {
-    let array: TResult[];
-    let list: _.List<TResult>;
-    let dictionary: _.Dictionary<TResult>;
-    let numericDictionary: _.NumericDictionary<TResult>;
-
-    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
-    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => boolean;
-    let numericDictionaryIterator: (value: TResult, key: number, collection: _.NumericDictionary<TResult>) => boolean;
-
-    {
-        let result: boolean;
-
-        result = _.any<TResult>(array);
-        result = _.any<TResult>(array, listIterator);
-        result = _.any<TResult>(array, listIterator, any);
-        result = _.any<TResult>(array, '');
-        result = _.any<{a: number}, TResult>(array, {a: 42});
-
-        result = _.any<TResult>(list);
-        result = _.any<TResult>(list, listIterator);
-        result = _.any<TResult>(list, listIterator, any);
-        result = _.any<TResult>(list, '');
-        result = _.any<{a: number}, TResult>(list, {a: 42});
-
-        result = _.any<TResult>(dictionary);
-        result = _.any<TResult>(dictionary, dictionaryIterator);
-        result = _.any<TResult>(dictionary, dictionaryIterator, any);
-        result = _.any<TResult>(dictionary, '');
-        result = _.any<{a: number}, TResult>(dictionary, {a: 42});
-
-        result = _.any<TResult>(numericDictionary);
-        result = _.any<TResult>(numericDictionary, numericDictionaryIterator);
-        result = _.any<TResult>(numericDictionary, numericDictionaryIterator, any);
-        result = _.any<TResult>(numericDictionary, '');
-        result = _.any<{a: number}, TResult>(numericDictionary, {a: 42});
-
-        result = _(array).any();
-        result = _(array).any(listIterator);
-        result = _(array).any(listIterator, any);
-        result = _(array).any('');
-        result = _(array).any<{a: number}>({a: 42});
-
-        result = _(list).any<TResult>();
-        result = _(list).any<TResult>(listIterator);
-        result = _(list).any<TResult>(listIterator, any);
-        result = _(list).any('');
-        result = _(list).any<{a: number}>({a: 42});
-
-        result = _(dictionary).any<TResult>();
-        result = _(dictionary).any<TResult>(dictionaryIterator);
-        result = _(dictionary).any<TResult>(dictionaryIterator, any);
-        result = _(dictionary).any('');
-        result = _(dictionary).any<{a: number}>({a: 42});
-
-        result = _(numericDictionary).any<TResult>();
-        result = _(numericDictionary).any<TResult>(numericDictionaryIterator);
-        result = _(numericDictionary).any<TResult>(numericDictionaryIterator, any);
-        result = _(numericDictionary).any('');
-        result = _(numericDictionary).any<{a: number}>({a: 42});
-    }
-
-    {
-        let result: _.LoDashExplicitWrapper<boolean>;
-
-        result = _(array).chain().any();
-        result = _(array).chain().any(listIterator);
-        result = _(array).chain().any(listIterator, any);
-        result = _(array).chain().any('');
-        result = _(array).chain().any<{a: number}>({a: 42});
-
-        result = _(list).chain().any<TResult>();
-        result = _(list).chain().any<TResult>(listIterator);
-        result = _(list).chain().any<TResult>(listIterator, any);
-        result = _(list).chain().any('');
-        result = _(list).chain().any<{a: number}>({a: 42});
-
-        result = _(dictionary).chain().any<TResult>();
-        result = _(dictionary).chain().any<TResult>(dictionaryIterator);
-        result = _(dictionary).chain().any<TResult>(dictionaryIterator, any);
-        result = _(dictionary).chain().any('');
-        result = _(dictionary).chain().any<{a: number}>({a: 42});
-
-        result = _(numericDictionary).chain().any<TResult>();
-        result = _(numericDictionary).chain().any<TResult>(numericDictionaryIterator);
-        result = _(numericDictionary).chain().any<TResult>(numericDictionaryIterator, any);
-        result = _(numericDictionary).chain().any('');
-        result = _(numericDictionary).chain().any<{a: number}>({a: 42});
-    }
-}
-
 // _.at
 module TestAt {
     let array: TResult[];
@@ -3215,143 +2862,6 @@ module TestAt {
     }
 }
 
-// _.collect
-module TestCollect {
-    let array: number[];
-    let list: _.List<number>;
-    let dictionary: _.Dictionary<number>;
-
-    let listIterator: (value: number, index: number, collection: _.List<number>) => TResult;
-    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => TResult;
-
-    {
-        let result: TResult[];
-
-        result = _.collect<number, TResult>(array);
-        result = _.collect<number, TResult>(array, listIterator);
-        result = _.collect<number, TResult>(array, listIterator, any);
-        result = _.collect<number, TResult>(array, '');
-
-        result = _.collect<number, TResult>(list);
-        result = _.collect<number, TResult>(list, listIterator);
-        result = _.collect<number, TResult>(list, listIterator, any);
-        result = _.collect<number, TResult>(list, '');
-
-        result = _.collect<number, TResult>(dictionary);
-        result = _.collect<number, TResult>(dictionary, dictionaryIterator);
-        result = _.collect<number, TResult>(dictionary, dictionaryIterator, any);
-        result = _.collect<number, TResult>(dictionary, '');
-    }
-
-    {
-        let result: boolean[];
-
-        result = _.collect<number, {}>(array, {});
-        result = _.collect<number, {}>(list, {});
-        result = _.collect<number, {}>(dictionary, {});
-    }
-
-    {
-        let result: _.LoDashImplicitArrayWrapper<TResult>;
-
-        result = _<number>(array).collect<TResult>();
-        result = _<number>(array).collect<TResult>(listIterator);
-        result = _<number>(array).collect<TResult>(listIterator, any);
-        result = _<number>(array).collect<TResult>('');
-
-        result = _(list).collect<number, TResult>();
-        result = _(list).collect<number, TResult>(listIterator);
-        result = _(list).collect<number, TResult>(listIterator, any);
-        result = _(list).collect<number, TResult>('');
-
-        result = _(dictionary).collect<number, TResult>();
-        result = _(dictionary).collect<number, TResult>(dictionaryIterator);
-        result = _(dictionary).collect<number, TResult>(dictionaryIterator, any);
-        result = _(dictionary).collect<number, TResult>('');
-    }
-
-    {
-        let result: _.LoDashImplicitArrayWrapper<boolean>;
-
-        result = _<number>(array).collect<{}>({});
-        result = _(list).collect<{}>({});
-        result = _(dictionary).collect<{}>({});
-    }
-
-    {
-        let result: _.LoDashExplicitArrayWrapper<TResult>;
-
-        result = _<number>(array).chain().collect<TResult>();
-        result = _<number>(array).chain().collect<TResult>(listIterator);
-        result = _<number>(array).chain().collect<TResult>(listIterator, any);
-        result = _<number>(array).chain().collect<TResult>('');
-
-        result = _(list).chain().collect<number, TResult>();
-        result = _(list).chain().collect<number, TResult>(listIterator);
-        result = _(list).chain().collect<number, TResult>(listIterator, any);
-        result = _(list).chain().collect<number, TResult>('');
-
-        result = _(dictionary).chain().collect<number, TResult>();
-        result = _(dictionary).chain().collect<number, TResult>(dictionaryIterator);
-        result = _(dictionary).chain().collect<number, TResult>(dictionaryIterator, any);
-        result = _(dictionary).chain().collect<number, TResult>('');
-    }
-
-    {
-        let result: _.LoDashExplicitArrayWrapper<boolean>;
-
-        result = _<number>(array).chain().collect<{}>({});
-        result = _(list).chain().collect<{}>({});
-        result = _(dictionary).chain().collect<{}>({});
-    }
-}
-
-// _.contains
-module TestContains {
-    type SampleType = {a: string; b: number; c: boolean;};
-
-    let array: SampleType[];
-    let list: _.List<SampleType>;
-    let dictionary: _.Dictionary<SampleType>;
-
-    let target: SampleType;
-
-    {
-        let result: boolean;
-
-        result = _.contains<SampleType>(array, target);
-        result = _.contains<SampleType>(array, target, 42);
-
-        result = _.contains<SampleType>(list, target);
-        result = _.contains<SampleType>(list, target, 42);
-
-        result = _.contains<SampleType>(dictionary, target);
-        result = _.contains<SampleType>(dictionary, target, 42);
-
-        result = _(array).contains(target);
-        result = _(array).contains(target, 42);
-
-        result = _(list).contains<SampleType>(target);
-        result = _(list).contains<SampleType>(target, 42);
-
-        result = _(dictionary).contains<SampleType>(target);
-        result = _(dictionary).contains<SampleType>(target, 42);
-    }
-
-    {
-        let result: _.LoDashExplicitWrapper<boolean>;
-
-        result = _(array).chain().contains(target);
-        result = _(array).chain().contains(target, 42);
-
-        result = _(list).chain().contains<SampleType>(target);
-        result = _(list).chain().contains<SampleType>(target, 42);
-
-        result = _(dictionary).chain().contains<SampleType>(target);
-        result = _(dictionary).chain().contains<SampleType>(target, 42);
-    }
-}
-
 // _.countBy
 module TestCountBy {
     let array: TResult[];
@@ -3485,54 +2995,6 @@ module TestCountBy {
     }
 }
 
-// _.detect
-module TestDetect {
-    let array: TResult[];
-    let list: _.List<TResult>;
-    let dictionary: _.Dictionary<TResult>;
-
-    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => boolean;
-    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => boolean;
-
-    let result: TResult;
-
-    result = _.detect<TResult>(array);
-    result = _.detect<TResult>(array, listIterator);
-    result = _.detect<TResult>(array, listIterator, any);
-    result = _.detect<TResult>(array, '');
-    result = _.detect<{a: number}, TResult>(array, {a: 42});
-
-    result = _.detect<TResult>(list);
-    result = _.detect<TResult>(list, listIterator);
-    result = _.detect<TResult>(list, listIterator, any);
-    result = _.detect<TResult>(list, '');
-    result = _.detect<{a: number}, TResult>(list, {a: 42});
-
-    result = _.detect<TResult>(dictionary);
-    result = _.detect<TResult>(dictionary, dictionaryIterator);
-    result = _.detect<TResult>(dictionary, dictionaryIterator, any);
-    result = _.detect<TResult>(dictionary, '');
-    result = _.detect<{a: number}, TResult>(dictionary, {a: 42});
-
-    result = _(array).detect();
-    result = _(array).detect(listIterator);
-    result = _(array).detect(listIterator, any);
-    result = _(array).detect('');
-    result = _(array).detect<{a: number}>({a: 42});
-
-    result = _(list).detect<TResult>();
-    result = _(list).detect<TResult>(listIterator);
-    result = _(list).detect<TResult>(listIterator, any);
-    result = _(list).detect<TResult>('');
-    result = _(list).detect<{a: number}, TResult>({a: 42});
-
-    result = _(dictionary).detect<TResult>();
-    result = _(dictionary).detect<TResult>(dictionaryIterator);
-    result = _(dictionary).detect<TResult>(dictionaryIterator, any);
-    result = _(dictionary).detect<TResult>('');
-    result = _(dictionary).detect<{a: number}, TResult>({a: 42});
-}
-
 // _.each
 module TestEach {
     let array: TResult[];
@@ -3941,12 +3403,6 @@ module TestFind {
     result = _(dictionary).find<{a: number}, TResult>({a: 42});
 }
 
-result = <number>_.findWhere([1, 2, 3, 4], function (num) {
-    return num % 2 == 0;
-});
-result = <IFoodCombined>_.findWhere(foodsCombined, { 'type': 'vegetable' });
-result = <IFoodCombined>_.findWhere(foodsCombined, 'organic');
-
 result = <number>_.findLast([1, 2, 3, 4], function (num) {
     return num % 2 == 0;
 });
@@ -4298,52 +3754,6 @@ module TestGroupBy {
     }
 }
 
-// _.include
-module TestInclude {
-    type SampleType = {a: string; b: number; c: boolean;};
-
-    let array: SampleType[];
-    let list: _.List<SampleType>;
-    let dictionary: _.Dictionary<SampleType>;
-
-    let target: SampleType;
-
-    {
-        let result: boolean;
-
-        result = _.include<SampleType>(array, target);
-        result = _.include<SampleType>(array, target, 42);
-
-        result = _.include<SampleType>(list, target);
-        result = _.include<SampleType>(list, target, 42);
-
-        result = _.include<SampleType>(dictionary, target);
-        result = _.include<SampleType>(dictionary, target, 42);
-
-        result = _(array).include(target);
-        result = _(array).include(target, 42);
-
-        result = _(list).include<SampleType>(target);
-        result = _(list).include<SampleType>(target, 42);
-
-        result = _(dictionary).include<SampleType>(target);
-        result = _(dictionary).include<SampleType>(target, 42);
-    }
-
-    {
-        let result: _.LoDashExplicitWrapper<boolean>;
-
-        result = _(array).chain().include(target);
-        result = _(array).chain().include(target, 42);
-
-        result = _(list).chain().include<SampleType>(target);
-        result = _(list).chain().include<SampleType>(target, 42);
-
-        result = _(dictionary).chain().include<SampleType>(target);
-        result = _(dictionary).chain().include<SampleType>(target, 42);
-    }
-}
-
 // _.includes
 module TestIncludes {
     type SampleType = {a: string; b: number; c: boolean;};
@@ -4390,8 +3800,8 @@ module TestIncludes {
     }
 }
 
-// _.indexBy
-module TestIndexBy {
+// _.keyBy
+module TestKeyBy {
     type SampleObject = {a: number; b: string; c: boolean;};
 
     let array: SampleObject[];
@@ -4407,136 +3817,136 @@ module TestIndexBy {
     {
         let result: _.Dictionary<string>;
 
-        result = _.indexBy<string>('abcd');
-        result = _.indexBy<string>('abcd', stringIterator);
-        result = _.indexBy<string>('abcd', stringIterator, any);
+        result = _.keyBy<string>('abcd');
+        result = _.keyBy<string>('abcd', stringIterator);
+        result = _.keyBy<string>('abcd', stringIterator, any);
     }
 
     {
         let result: _.Dictionary<SampleObject>;
 
-        result = _.indexBy<SampleObject>(array);
-        result = _.indexBy<SampleObject>(array, listIterator);
-        result = _.indexBy<SampleObject>(array, listIterator, any);
-        result = _.indexBy<SampleObject>(array, 'a');
-        result = _.indexBy<SampleObject>(array, 'a', any);
-        result = _.indexBy<{a: number}, SampleObject>(array, {a: 42});
-        result = _.indexBy<SampleObject>(array, {a: 42});
+        result = _.keyBy<SampleObject>(array);
+        result = _.keyBy<SampleObject>(array, listIterator);
+        result = _.keyBy<SampleObject>(array, listIterator, any);
+        result = _.keyBy<SampleObject>(array, 'a');
+        result = _.keyBy<SampleObject>(array, 'a', any);
+        result = _.keyBy<{a: number}, SampleObject>(array, {a: 42});
+        result = _.keyBy<SampleObject>(array, {a: 42});
 
-        result = _.indexBy<SampleObject>(list);
-        result = _.indexBy<SampleObject>(list, listIterator);
-        result = _.indexBy<SampleObject>(list, listIterator, any);
-        result = _.indexBy<SampleObject>(list, 'a');
-        result = _.indexBy<SampleObject>(list, 'a', any);
-        result = _.indexBy<{a: number}, SampleObject>(list, {a: 42});
-        result = _.indexBy<SampleObject>(list, {a: 42});
+        result = _.keyBy<SampleObject>(list);
+        result = _.keyBy<SampleObject>(list, listIterator);
+        result = _.keyBy<SampleObject>(list, listIterator, any);
+        result = _.keyBy<SampleObject>(list, 'a');
+        result = _.keyBy<SampleObject>(list, 'a', any);
+        result = _.keyBy<{a: number}, SampleObject>(list, {a: 42});
+        result = _.keyBy<SampleObject>(list, {a: 42});
 
-        result = _.indexBy<SampleObject>(numericDictionary);
-        result = _.indexBy<SampleObject>(numericDictionary, numericDictionaryIterator);
-        result = _.indexBy<SampleObject>(numericDictionary, numericDictionaryIterator, any);
-        result = _.indexBy<SampleObject>(numericDictionary, 'a');
-        result = _.indexBy<SampleObject>(numericDictionary, 'a', any);
-        result = _.indexBy<{a: number}, SampleObject>(numericDictionary, {a: 42});
-        result = _.indexBy<SampleObject>(numericDictionary, {a: 42});
+        result = _.keyBy<SampleObject>(numericDictionary);
+        result = _.keyBy<SampleObject>(numericDictionary, numericDictionaryIterator);
+        result = _.keyBy<SampleObject>(numericDictionary, numericDictionaryIterator, any);
+        result = _.keyBy<SampleObject>(numericDictionary, 'a');
+        result = _.keyBy<SampleObject>(numericDictionary, 'a', any);
+        result = _.keyBy<{a: number}, SampleObject>(numericDictionary, {a: 42});
+        result = _.keyBy<SampleObject>(numericDictionary, {a: 42});
 
-        result = _.indexBy<SampleObject>(dictionary);
-        result = _.indexBy<SampleObject>(dictionary, dictionaryIterator);
-        result = _.indexBy<SampleObject>(dictionary, dictionaryIterator, any);
-        result = _.indexBy<SampleObject>(dictionary, 'a');
-        result = _.indexBy<SampleObject>(dictionary, 'a', any);
-        result = _.indexBy<{a: number}, SampleObject>(dictionary, {a: 42});
-        result = _.indexBy<SampleObject>(dictionary, {a: 42});
+        result = _.keyBy<SampleObject>(dictionary);
+        result = _.keyBy<SampleObject>(dictionary, dictionaryIterator);
+        result = _.keyBy<SampleObject>(dictionary, dictionaryIterator, any);
+        result = _.keyBy<SampleObject>(dictionary, 'a');
+        result = _.keyBy<SampleObject>(dictionary, 'a', any);
+        result = _.keyBy<{a: number}, SampleObject>(dictionary, {a: 42});
+        result = _.keyBy<SampleObject>(dictionary, {a: 42});
     }
 
     {
         let result: _.LoDashImplicitObjectWrapper<_.Dictionary<string>>;
 
-        result = _('abcd').indexBy();
-        result = _('abcd').indexBy(stringIterator);
-        result = _('abcd').indexBy(stringIterator, any);
+        result = _('abcd').keyBy();
+        result = _('abcd').keyBy(stringIterator);
+        result = _('abcd').keyBy(stringIterator, any);
     }
 
     {
         let result: _.LoDashImplicitObjectWrapper<_.Dictionary<SampleObject>>;
 
-        result = _(array).indexBy();
-        result = _(array).indexBy(listIterator);
-        result = _(array).indexBy(listIterator, any);
-        result = _(array).indexBy('a');
-        result = _(array).indexBy('a', any);
-        result = _(array).indexBy<{a: number}>({a: 42});
+        result = _(array).keyBy();
+        result = _(array).keyBy(listIterator);
+        result = _(array).keyBy(listIterator, any);
+        result = _(array).keyBy('a');
+        result = _(array).keyBy('a', any);
+        result = _(array).keyBy<{a: number}>({a: 42});
 
-        result = _(list).indexBy<SampleObject>();
-        result = _(list).indexBy<SampleObject>(listIterator);
-        result = _(list).indexBy<SampleObject>(listIterator, any);
-        result = _(list).indexBy<SampleObject>('a');
-        result = _(list).indexBy<SampleObject>('a', any);
-        result = _(list).indexBy<{a: number}, SampleObject>({a: 42});
-        result = _(list).indexBy<SampleObject>({a: 42});
+        result = _(list).keyBy<SampleObject>();
+        result = _(list).keyBy<SampleObject>(listIterator);
+        result = _(list).keyBy<SampleObject>(listIterator, any);
+        result = _(list).keyBy<SampleObject>('a');
+        result = _(list).keyBy<SampleObject>('a', any);
+        result = _(list).keyBy<{a: number}, SampleObject>({a: 42});
+        result = _(list).keyBy<SampleObject>({a: 42});
 
-        result = _(numericDictionary).indexBy<SampleObject>();
-        result = _(numericDictionary).indexBy<SampleObject>(numericDictionaryIterator);
-        result = _(numericDictionary).indexBy<SampleObject>(numericDictionaryIterator, any);
-        result = _(numericDictionary).indexBy<SampleObject>('a');
-        result = _(numericDictionary).indexBy<SampleObject>('a', any);
-        result = _(numericDictionary).indexBy<{a: number}, SampleObject>({a: 42});
-        result = _(numericDictionary).indexBy<SampleObject>({a: 42});
+        result = _(numericDictionary).keyBy<SampleObject>();
+        result = _(numericDictionary).keyBy<SampleObject>(numericDictionaryIterator);
+        result = _(numericDictionary).keyBy<SampleObject>(numericDictionaryIterator, any);
+        result = _(numericDictionary).keyBy<SampleObject>('a');
+        result = _(numericDictionary).keyBy<SampleObject>('a', any);
+        result = _(numericDictionary).keyBy<{a: number}, SampleObject>({a: 42});
+        result = _(numericDictionary).keyBy<SampleObject>({a: 42});
 
-        result = _(dictionary).indexBy<SampleObject>();
-        result = _(dictionary).indexBy<SampleObject>(dictionaryIterator);
-        result = _(dictionary).indexBy<SampleObject>(dictionaryIterator, any);
-        result = _(dictionary).indexBy<SampleObject>('a');
-        result = _(dictionary).indexBy<SampleObject>('a', any);
-        result = _(dictionary).indexBy<{a: number}, SampleObject>({a: 42});
-        result = _(dictionary).indexBy<SampleObject>({a: 42});
+        result = _(dictionary).keyBy<SampleObject>();
+        result = _(dictionary).keyBy<SampleObject>(dictionaryIterator);
+        result = _(dictionary).keyBy<SampleObject>(dictionaryIterator, any);
+        result = _(dictionary).keyBy<SampleObject>('a');
+        result = _(dictionary).keyBy<SampleObject>('a', any);
+        result = _(dictionary).keyBy<{a: number}, SampleObject>({a: 42});
+        result = _(dictionary).keyBy<SampleObject>({a: 42});
     }
 
     {
         let result: _.LoDashExplicitObjectWrapper<_.Dictionary<string>>;
 
-        result = _('abcd').chain().indexBy();
-        result = _('abcd').chain().indexBy(stringIterator);
-        result = _('abcd').chain().indexBy(stringIterator, any);
+        result = _('abcd').chain().keyBy();
+        result = _('abcd').chain().keyBy(stringIterator);
+        result = _('abcd').chain().keyBy(stringIterator, any);
     }
 
     {
         let result: _.LoDashExplicitObjectWrapper<_.Dictionary<SampleObject>>;
 
-        result = _(array).chain().indexBy();
-        result = _(array).chain().indexBy(listIterator);
-        result = _(array).chain().indexBy(listIterator, any);
-        result = _(array).chain().indexBy('a');
-        result = _(array).chain().indexBy('a', any);
-        result = _(array).chain().indexBy<{a: number}>({a: 42});
+        result = _(array).chain().keyBy();
+        result = _(array).chain().keyBy(listIterator);
+        result = _(array).chain().keyBy(listIterator, any);
+        result = _(array).chain().keyBy('a');
+        result = _(array).chain().keyBy('a', any);
+        result = _(array).chain().keyBy<{a: number}>({a: 42});
 
-        result = _(list).chain().indexBy<SampleObject>();
-        result = _(list).chain().indexBy<SampleObject>(listIterator);
-        result = _(list).chain().indexBy<SampleObject>(listIterator, any);
-        result = _(list).chain().indexBy<SampleObject>('a');
-        result = _(list).chain().indexBy<SampleObject>('a', any);
-        result = _(list).chain().indexBy<{a: number}, SampleObject>({a: 42});
-        result = _(list).chain().indexBy<SampleObject>({a: 42});
+        result = _(list).chain().keyBy<SampleObject>();
+        result = _(list).chain().keyBy<SampleObject>(listIterator);
+        result = _(list).chain().keyBy<SampleObject>(listIterator, any);
+        result = _(list).chain().keyBy<SampleObject>('a');
+        result = _(list).chain().keyBy<SampleObject>('a', any);
+        result = _(list).chain().keyBy<{a: number}, SampleObject>({a: 42});
+        result = _(list).chain().keyBy<SampleObject>({a: 42});
 
-        result = _(numericDictionary).chain().indexBy<SampleObject>();
-        result = _(numericDictionary).chain().indexBy<SampleObject>(numericDictionaryIterator);
-        result = _(numericDictionary).chain().indexBy<SampleObject>(numericDictionaryIterator, any);
-        result = _(numericDictionary).chain().indexBy<SampleObject>('a');
-        result = _(numericDictionary).chain().indexBy<SampleObject>('a', any);
-        result = _(numericDictionary).chain().indexBy<{a: number}, SampleObject>({a: 42});
-        result = _(numericDictionary).chain().indexBy<SampleObject>({a: 42});
+        result = _(numericDictionary).chain().keyBy<SampleObject>();
+        result = _(numericDictionary).chain().keyBy<SampleObject>(numericDictionaryIterator);
+        result = _(numericDictionary).chain().keyBy<SampleObject>(numericDictionaryIterator, any);
+        result = _(numericDictionary).chain().keyBy<SampleObject>('a');
+        result = _(numericDictionary).chain().keyBy<SampleObject>('a', any);
+        result = _(numericDictionary).chain().keyBy<{a: number}, SampleObject>({a: 42});
+        result = _(numericDictionary).chain().keyBy<SampleObject>({a: 42});
 
-        result = _(dictionary).chain().indexBy<SampleObject>();
-        result = _(dictionary).chain().indexBy<SampleObject>(dictionaryIterator);
-        result = _(dictionary).chain().indexBy<SampleObject>(dictionaryIterator, any);
-        result = _(dictionary).chain().indexBy<SampleObject>('a');
-        result = _(dictionary).chain().indexBy<SampleObject>('a', any);
-        result = _(dictionary).chain().indexBy<{a: number}, SampleObject>({a: 42});
-        result = _(dictionary).chain().indexBy<SampleObject>({a: 42});
+        result = _(dictionary).chain().keyBy<SampleObject>();
+        result = _(dictionary).chain().keyBy<SampleObject>(dictionaryIterator);
+        result = _(dictionary).chain().keyBy<SampleObject>(dictionaryIterator, any);
+        result = _(dictionary).chain().keyBy<SampleObject>('a');
+        result = _(dictionary).chain().keyBy<SampleObject>('a', any);
+        result = _(dictionary).chain().keyBy<{a: number}, SampleObject>({a: 42});
+        result = _(dictionary).chain().keyBy<SampleObject>({a: 42});
     }
 }
 
-result = <number[][]>_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
-result = <string[][]>_.invoke([123, 456], String.prototype.split, '');
+result = <number[][]>_.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
+result = <string[][]>_.invokeMap([123, 456], String.prototype.split, '');
 
 // _.map
 module TestMap {
@@ -4657,68 +4067,69 @@ result = <{a: number}[][]>_([{a: 1}, {a: 2}]).partition('a', 2).value();
 result = <{a: number}[][]>_({0: {a: 1}, 1: {a: 2}}).partition<{a: number}>('a').value();
 result = <{a: number}[][]>_({0: {a: 1}, 1: {a: 2}}).partition<{a: number}>('a', 2).value();
 
-// _.pluck
-module TestPluck {
-    interface SampleObject {
-        d: {b: TResult}[];
-    }
-
-    let array: SampleObject[];
-    let list: _.List<SampleObject>;
-    let dictionary: _.Dictionary<SampleObject>;
-
-    {
-        let result: any[];
-
-        result = _.pluck<SampleObject>(array, 'd.0.b');
-        result = _.pluck<SampleObject>(array, ['d', 0, 'b']);
-
-        result = _.pluck<SampleObject>(list, 'd.0.b');
-        result = _.pluck<SampleObject>(list, ['d', 0, 'b']);
-
-        result = _.pluck<SampleObject>(dictionary, 'd.0.b');
-        result = _.pluck<SampleObject>(dictionary, ['d', 0, 'b']);
-    }
-
-    {
-        let result: TResult[];
-
-        result = _.pluck<SampleObject, TResult>(array, 'd.0.b');
-        result = _.pluck<SampleObject, TResult>(array, ['d', 0, 'b']);
-
-        result = _.pluck<SampleObject, TResult>(list, 'd.0.b');
-        result = _.pluck<SampleObject, TResult>(list, ['d', 0, 'b']);
-
-        result = _.pluck<SampleObject, TResult>(dictionary, 'd.0.b');
-        result = _.pluck<SampleObject, TResult>(dictionary, ['d', 0, 'b']);
-    }
-
-    {
-        let result: _.LoDashImplicitArrayWrapper<TResult>;
-
-        result = _(array).pluck<TResult>('d.0.b');
-        result = _(array).pluck<TResult>(['d', 0, 'b']);
-
-        result = _(list).pluck<TResult>('d.0.b');
-        result = _(list).pluck<TResult>(['d', 0, 'b']);
-
-        result = _(dictionary).pluck<TResult>('d.0.b');
-        result = _(dictionary).pluck<TResult>(['d', 0, 'b']);
-    }
-
-    {
-        let result: _.LoDashExplicitArrayWrapper<TResult>;
-
-        result = _(array).chain().pluck<TResult>('d.0.b');
-        result = _(array).chain().pluck<TResult>(['d', 0, 'b']);
-
-        result = _(list).chain().pluck<TResult>('d.0.b');
-        result = _(list).chain().pluck<TResult>(['d', 0, 'b']);
-
-        result = _(dictionary).chain().pluck<TResult>('d.0.b');
-        result = _(dictionary).chain().pluck<TResult>(['d', 0, 'b']);
-    }
-}
+// TODO
+// _.map with iteratee shorthand
+// module TestMapInsteadOfPluck {
+//     interface SampleObject {
+//         d: {b: TResult}[];
+//     }
+//
+//     let array: SampleObject[];
+//     let list: _.List<SampleObject>;
+//     let dictionary: _.Dictionary<SampleObject>;
+//
+//     {
+//         let result: any[];
+//
+//         result = _.map<SampleObject>(array, 'd.0.b');
+//         result = _.map<SampleObject>(array, ['d', 0, 'b']);
+//
+//         result = _.map<SampleObject>(list, 'd.0.b');
+//         result = _.map<SampleObject>(list, ['d', 0, 'b']);
+//
+//         result = _.map<SampleObject>(dictionary, 'd.0.b');
+//         result = _.map<SampleObject>(dictionary, ['d', 0, 'b']);
+//     }
+//
+//     {
+//         let result: TResult[];
+//
+//         result = _.map<SampleObject, TResult>(array, 'd.0.b');
+//         result = _.map<SampleObject, TResult>(array, ['d', 0, 'b']);
+//
+//         result = _.map<SampleObject, TResult>(list, 'd.0.b');
+//         result = _.map<SampleObject, TResult>(list, ['d', 0, 'b']);
+//
+//         result = _.map<SampleObject, TResult>(dictionary, 'd.0.b');
+//         result = _.map<SampleObject, TResult>(dictionary, ['d', 0, 'b']);
+//     }
+//
+//     {
+//         let result: _.LoDashImplicitArrayWrapper<TResult>;
+//
+//         result = _(array).map<TResult>('d.0.b');
+//         result = _(array).map<TResult>(['d', 0, 'b']);
+//
+//         result = _(list).map<TResult>('d.0.b');
+//         result = _(list).map<TResult>(['d', 0, 'b']);
+//
+//         result = _(dictionary).map<TResult>('d.0.b');
+//         result = _(dictionary).map<TResult>(['d', 0, 'b']);
+//     }
+//
+//     {
+//         let result: _.LoDashExplicitArrayWrapper<TResult>;
+//
+//         result = _(array).chain().map<TResult>('d.0.b');
+//         result = _(array).chain().map<TResult>(['d', 0, 'b']);
+//
+//         result = _(list).chain().map<TResult>('d.0.b');
+//         result = _(list).chain().map<TResult>(['d', 0, 'b']);
+//
+//         result = _(dictionary).chain().map<TResult>('d.0.b');
+//         result = _(dictionary).chain().map<TResult>(['d', 0, 'b']);
+//     }
+// }
 
 interface ABC {
     [index: string]: number;
@@ -4735,22 +4146,6 @@ result = <ABC>_.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function (r: ABC, num: number
     return r;
 }, {});
 
-result = <number>_.foldl([1, 2, 3], function (sum: number, num: number) {
-    return sum + num;
-});
-result = <ABC>_.foldl({ 'a': 1, 'b': 2, 'c': 3 }, function (r: ABC, num: number, key: string) {
-    r[key] = num * 3;
-    return r;
-}, {});
-
-result = <number>_.inject([1, 2, 3], function (sum: number, num: number) {
-    return sum + num;
-});
-result = <ABC>_.inject({ 'a': 1, 'b': 2, 'c': 3 }, function (r: ABC, num: number, key: string) {
-    r[key] = num * 3;
-    return r;
-}, {});
-
 result = <number>_([1, 2, 3]).reduce<number>(function (sum: number, num: number) {
     return sum + num;
 });
@@ -4759,24 +4154,7 @@ result = <ABC>_({ 'a': 1, 'b': 2, 'c': 3 }).reduce<number, ABC>(function (r: ABC
     return r;
 }, {});
 
-result = <number>_([1, 2, 3]).foldl<number>(function (sum: number, num: number) {
-    return sum + num;
-});
-result = <ABC>_({ 'a': 1, 'b': 2, 'c': 3 }).foldl<number, ABC>(function (r: ABC, num: number, key: string) {
-    r[key] = num * 3;
-    return r;
-}, {});
-
-result = <number>_([1, 2, 3]).inject<number>(function (sum: number, num: number) {
-    return sum + num;
-});
-result = <ABC>_({ 'a': 1, 'b': 2, 'c': 3 }).inject<number, ABC>(function (r: ABC, num: number, key: string) {
-    r[key] = num * 3;
-    return r;
-}, {});
-
 result = <number[]>_.reduceRight([[0, 1], [2, 3], [4, 5]], function (a: number[], b: number[]) { return a.concat(b); }, <number[]>[]);
-result = <number[]>_.foldr([[0, 1], [2, 3], [4, 5]], function (a: number[], b: number[]) { return a.concat(b); }, <number[]>[]);
 
 // _.reject
 module TestReject {
@@ -4876,110 +4254,15 @@ module TestReject {
     }
 }
 
+// _.sample
 result = <number>_.sample([1, 2, 3, 4]);
-result = <number[]>_.sample([1, 2, 3, 4], 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();
 
-// _.select
-module TestSelect {
-    let array: TResult[];
-    let list: _.List<TResult>;
-    let dictionary: _.Dictionary<TResult>;
-
-    let stringIterator: (char: string, index: number, string: string) => any;
-    let listIterator: (value: TResult, index: number, collection: _.List<TResult>) => any;
-    let dictionaryIterator: (value: TResult, key: string, collection: _.Dictionary<TResult>) => any;
-
-    {
-        let result: string[];
-
-        result = _.select('', stringIterator);
-        result = _.select('', stringIterator, any);
-    }
-
-    {
-        let result: TResult[];
-
-        result = _.select<TResult>(array, listIterator);
-        result = _.select<TResult>(array, listIterator, any);
-        result = _.select<TResult>(array, '');
-        result = _.select<TResult>(array, '', any);
-        result = _.select<{a: number}, TResult>(array, {a: 42});
-
-        result = _.select<TResult>(list, listIterator);
-        result = _.select<TResult>(list, listIterator, any);
-        result = _.select<TResult>(list, '');
-        result = _.select<TResult>(list, '', any);
-        result = _.select<{a: number}, TResult>(list, {a: 42});
-
-        result = _.select<TResult>(dictionary, dictionaryIterator);
-        result = _.select<TResult>(dictionary, dictionaryIterator, any);
-        result = _.select<TResult>(dictionary, '');
-        result = _.select<TResult>(dictionary, '', any);
-        result = _.select<{a: number}, TResult>(dictionary, {a: 42});
-    }
-
-    {
-        let result: _.LoDashImplicitArrayWrapper<string>;
-
-        result = _('').select(stringIterator);
-        result = _('').select(stringIterator, any);
-    }
-
-    {
-        let result: _.LoDashImplicitArrayWrapper<TResult>;
-
-        result = _(array).select(listIterator);
-        result = _(array).select(listIterator, any);
-        result = _(array).select('');
-        result = _(array).select('', any);
-        result = _(array).select<{a: number}>({a: 42});
-
-        result = _(list).select<TResult>(listIterator);
-        result = _(list).select<TResult>(listIterator, any);
-        result = _(list).select<TResult>('');
-        result = _(list).select<TResult>('', any);
-        result = _(list).select<{a: number}, TResult>({a: 42});
-
-        result = _(dictionary).select<TResult>(dictionaryIterator);
-        result = _(dictionary).select<TResult>(dictionaryIterator, any);
-        result = _(dictionary).select<TResult>('');
-        result = _(dictionary).select<TResult>('', any);
-        result = _(dictionary).select<{a: number}, TResult>({a: 42});
-    }
-
-    {
-        let result: _.LoDashExplicitArrayWrapper<string>;
-
-        result = _('').chain().select(stringIterator);
-        result = _('').chain().select(stringIterator, any);
-    }
-
-    {
-        let result: _.LoDashExplicitArrayWrapper<TResult>;
-
-        result = _(array).chain().select(listIterator);
-        result = _(array).chain().select(listIterator, any);
-        result = _(array).chain().select('');
-        result = _(array).chain().select('', any);
-        result = _(array).chain().select<{a: number}>({a: 42});
-
-        result = _(list).chain().select<TResult>(listIterator);
-        result = _(list).chain().select<TResult>(listIterator, any);
-        result = _(list).chain().select<TResult>('');
-        result = _(list).chain().select<TResult>('', any);
-        result = _(list).chain().select<{a: number}, TResult>({a: 42});
-
-        result = _(dictionary).chain().select<TResult>(dictionaryIterator);
-        result = _(dictionary).chain().select<TResult>(dictionaryIterator, any);
-        result = _(dictionary).chain().select<TResult>('');
-        result = _(dictionary).chain().select<TResult>('', any);
-        result = _(dictionary).chain().select<{a: number}, TResult>({a: 42});
-    }
-}
+// _.sampleSize
+result = <number[]>_.sampleSize([1, 2, 3, 4], 2);
+result = <_.LoDashImplicitArrayWrapper<number>>_([1, 2, 3, 4]).sampleSize(2);
+result = <number[]>_([1, 2, 3, 4]).sampleSize(2).value();
 
 // _.shuffle
 module TestShuffle {
@@ -5168,19 +4451,16 @@ module TestSortBy {
 
         result = _.sortBy<TResult>(array);
         result = _.sortBy<TResult, number>(array, listIterator);
-        result = _.sortBy<TResult, number>(array, listIterator, any);
         result = _.sortBy<TResult>(array, '');
         result = _.sortBy<{a: number}, TResult>(array, {a: 42});
 
         result = _.sortBy<TResult>(list);
         result = _.sortBy<TResult, number>(list, listIterator);
-        result = _.sortBy<TResult, number>(list, listIterator, any);
         result = _.sortBy<TResult>(list, '');
         result = _.sortBy<{a: number}, TResult>(list, {a: 42});
 
         result = _.sortBy<TResult>(dictionary);
         result = _.sortBy<TResult, number>(dictionary, dictionaryIterator);
-        result = _.sortBy<TResult, number>(dictionary, dictionaryIterator, any);
         result = _.sortBy<TResult>(dictionary, '');
         result = _.sortBy<{a: number}, TResult>(dictionary, {a: 42});
     }
@@ -5190,19 +4470,16 @@ module TestSortBy {
 
         result = _(array).sortBy();
         result = _(array).sortBy<number>(listIterator);
-        result = _(array).sortBy<number>(listIterator, any);
         result = _(array).sortBy('');
         result = _(array).sortBy<{a: number}>({a: 42});
 
         result = _(list).sortBy<TResult>();
         result = _(list).sortBy<TResult, number>(listIterator);
-        result = _(list).sortBy<TResult, number>(listIterator, any);
         result = _(list).sortBy<TResult>('');
         result = _(list).sortBy<{a: number}, TResult>({a: 42});
 
         result = _(dictionary).sortBy<TResult>();
         result = _(dictionary).sortBy<TResult, number>(dictionaryIterator);
-        result = _(dictionary).sortBy<TResult, number>(dictionaryIterator, any);
         result = _(dictionary).sortBy<TResult>('');
         result = _(dictionary).sortBy<{a: number}, TResult>({a: 42});
     }
@@ -5212,92 +4489,30 @@ module TestSortBy {
 
         result = _(array).chain().sortBy();
         result = _(array).chain().sortBy<number>(listIterator);
-        result = _(array).chain().sortBy<number>(listIterator, any);
         result = _(array).chain().sortBy('');
         result = _(array).chain().sortBy<{a: number}>({a: 42});
 
         result = _(list).chain().sortBy<TResult>();
         result = _(list).chain().sortBy<TResult, number>(listIterator);
-        result = _(list).chain().sortBy<TResult, number>(listIterator, any);
         result = _(list).chain().sortBy<TResult>('');
         result = _(list).chain().sortBy<{a: number}, TResult>({a: 42});
 
         result = _(dictionary).chain().sortBy<TResult>();
         result = _(dictionary).chain().sortBy<TResult, number>(dictionaryIterator);
-        result = _(dictionary).chain().sortBy<TResult, number>(dictionaryIterator, any);
         result = _(dictionary).chain().sortBy<TResult>('');
         result = _(dictionary).chain().sortBy<{a: number}, TResult>({a: 42});
     }
 }
 
-// _.sortByAll
-module TestSortByAll {
-    type SampleObject = {a: number; b: string; c: boolean};
+result = <IStoogesAge[]>_.sortBy(stoogesAges, function(stooge) { return Math.sin(stooge.age); }, function(stooge) { return stooge.name.slice(1); });
+result = <IStoogesAge[]>_.sortBy(stoogesAges, ['name', 'age']);
+result = <IStoogesAge[]>_.sortBy(stoogesAges, 'name', function(stooge) { return Math.sin(stooge.age); });
 
-    let array: SampleObject[];
-    let list: _.List<SampleObject>;
-    let numericDictionary: _.NumericDictionary<SampleObject>;
-    let dictionary: _.Dictionary<SampleObject>;;
+result = <IFoodOrganic[]>_(foodsOrganic).sortBy('organic', (food) => food.name, { organic: true }).value();
 
-    {
-        let iteratees: (value: string) => any|((value: string) => any)[];
-        let result: string[];
 
-        result = _.sortByAll<string>('acbd', iteratees);
-    }
-
-    {
-        let iteratees: (value: SampleObject) => any|string|{a: number}|((value: SampleObject) => any|string|{a: number})[];
-        let result: SampleObject[];
-
-        result = _.sortByAll<{a: number}, SampleObject>(array, iteratees);
-        result = _.sortByAll<SampleObject>(array, iteratees);
-
-        result = _.sortByAll<{a: number}, SampleObject>(list, iteratees);
-        result = _.sortByAll<SampleObject>(list, iteratees);
-
-        result = _.sortByAll<{a: number}, SampleObject>(numericDictionary, iteratees);
-        result = _.sortByAll<SampleObject>(numericDictionary, iteratees);
-
-        result = _.sortByAll<{a: number}, SampleObject>(dictionary, iteratees);
-        result = _.sortByAll<SampleObject>(dictionary, iteratees);
-    }
-
-    {
-        let iteratees: (value: SampleObject) => any|string|{a: number}|((value: SampleObject) => any|string|{a: number})[];
-        let result: _.LoDashImplicitArrayWrapper<SampleObject>;
-
-        result = _(array).sortByAll<{a: number}>(iteratees);
-
-        result = _(list).sortByAll<{a: number}, SampleObject>(iteratees);
-        result = _(list).sortByAll<SampleObject>(iteratees);
-
-        result = _(numericDictionary).sortByAll<{a: number}, SampleObject>(iteratees);
-        result = _(numericDictionary).sortByAll<SampleObject>(iteratees);
-
-        result = _(dictionary).sortByAll<{a: number}, SampleObject>(iteratees);
-        result = _(dictionary).sortByAll<SampleObject>(iteratees);
-    }
-
-    {
-        let iteratees: (value: SampleObject) => any|string|{a: number}|((value: SampleObject) => any|string|{a: number})[];
-        let result: _.LoDashExplicitArrayWrapper<SampleObject>;
-
-        result = _(array).chain().sortByAll<{a: number}>(iteratees);
-
-        result = _(list).chain().sortByAll<{a: number}, SampleObject>(iteratees);
-        result = _(list).chain().sortByAll<SampleObject>(iteratees);
-
-        result = _(numericDictionary).chain().sortByAll<{a: number}, SampleObject>(iteratees);
-        result = _(numericDictionary).chain().sortByAll<SampleObject>(iteratees);
-
-        result = _(dictionary).chain().sortByAll<{a: number}, SampleObject>(iteratees);
-        result = _(dictionary).chain().sortByAll<SampleObject>(iteratees);
-    }
-}
-
-// _.sortByOrder
-module TestSortByOrder {
+// _.orderBy
+module TestorderBy {
     type SampleObject = {a: number; b: string; c: boolean};
 
     let array: SampleObject[];
@@ -5310,88 +4525,82 @@ module TestSortByOrder {
         let iteratees: (value: string) => any|((value: string) => any)[];
         let result: string[];
 
-        result = _.sortByOrder<string>('acbd', iteratees);
-        result = _.sortByOrder<string>('acbd', iteratees, orders);
+        result = _.orderBy<string>('acbd', iteratees);
+        result = _.orderBy<string>('acbd', iteratees, orders);
     }
 
     {
         let iteratees: (value: SampleObject) => any|string|{a: number}|((value: SampleObject) => any|string|{a: number})[];
         let result: SampleObject[];
 
-        result = _.sortByOrder<{a: number}, SampleObject>(array, iteratees);
-        result = _.sortByOrder<{a: number}, SampleObject>(array, iteratees, orders);
-        result = _.sortByOrder<SampleObject>(array, iteratees);
-        result = _.sortByOrder<SampleObject>(array, iteratees, orders);
+        result = _.orderBy<{a: number}, SampleObject>(array, iteratees);
+        result = _.orderBy<{a: number}, SampleObject>(array, iteratees, orders);
+        result = _.orderBy<SampleObject>(array, iteratees);
+        result = _.orderBy<SampleObject>(array, iteratees, orders);
 
-        result = _.sortByOrder<{a: number}, SampleObject>(list, iteratees);
-        result = _.sortByOrder<{a: number}, SampleObject>(list, iteratees, orders);
-        result = _.sortByOrder<SampleObject>(list, iteratees);
-        result = _.sortByOrder<SampleObject>(list, iteratees, orders);
+        result = _.orderBy<{a: number}, SampleObject>(list, iteratees);
+        result = _.orderBy<{a: number}, SampleObject>(list, iteratees, orders);
+        result = _.orderBy<SampleObject>(list, iteratees);
+        result = _.orderBy<SampleObject>(list, iteratees, orders);
 
-        result = _.sortByOrder<{a: number}, SampleObject>(numericDictionary, iteratees);
-        result = _.sortByOrder<{a: number}, SampleObject>(numericDictionary, iteratees, orders);
-        result = _.sortByOrder<SampleObject>(numericDictionary, iteratees);
-        result = _.sortByOrder<SampleObject>(numericDictionary, iteratees, orders);
+        result = _.orderBy<{a: number}, SampleObject>(numericDictionary, iteratees);
+        result = _.orderBy<{a: number}, SampleObject>(numericDictionary, iteratees, orders);
+        result = _.orderBy<SampleObject>(numericDictionary, iteratees);
+        result = _.orderBy<SampleObject>(numericDictionary, iteratees, orders);
 
-        result = _.sortByOrder<{a: number}, SampleObject>(dictionary, iteratees);
-        result = _.sortByOrder<{a: number}, SampleObject>(dictionary, iteratees, orders);
-        result = _.sortByOrder<SampleObject>(dictionary, iteratees);
-        result = _.sortByOrder<SampleObject>(dictionary, iteratees, orders);
+        result = _.orderBy<{a: number}, SampleObject>(dictionary, iteratees);
+        result = _.orderBy<{a: number}, SampleObject>(dictionary, iteratees, orders);
+        result = _.orderBy<SampleObject>(dictionary, iteratees);
+        result = _.orderBy<SampleObject>(dictionary, iteratees, orders);
     }
 
     {
         let iteratees: (value: SampleObject) => any|string|{a: number}|((value: SampleObject) => any|string|{a: number})[];
         let result: _.LoDashImplicitArrayWrapper<SampleObject>;
 
-        result = _(array).sortByOrder<{a: number}>(iteratees);
-        result = _(array).sortByOrder<{a: number}>(iteratees, orders);
+        result = _(array).orderBy<{a: number}>(iteratees);
+        result = _(array).orderBy<{a: number}>(iteratees, orders);
 
-        result = _(list).sortByOrder<{a: number}, SampleObject>(iteratees);
-        result = _(list).sortByOrder<{a: number}, SampleObject>(iteratees, orders);
-        result = _(list).sortByOrder<SampleObject>(iteratees);
-        result = _(list).sortByOrder<SampleObject>(iteratees, orders);
+        result = _(list).orderBy<{a: number}, SampleObject>(iteratees);
+        result = _(list).orderBy<{a: number}, SampleObject>(iteratees, orders);
+        result = _(list).orderBy<SampleObject>(iteratees);
+        result = _(list).orderBy<SampleObject>(iteratees, orders);
 
-        result = _(numericDictionary).sortByOrder<{a: number}, SampleObject>(iteratees);
-        result = _(numericDictionary).sortByOrder<{a: number}, SampleObject>(iteratees, orders);
-        result = _(numericDictionary).sortByOrder<SampleObject>(iteratees);
-        result = _(numericDictionary).sortByOrder<SampleObject>(iteratees, orders);
+        result = _(numericDictionary).orderBy<{a: number}, SampleObject>(iteratees);
+        result = _(numericDictionary).orderBy<{a: number}, SampleObject>(iteratees, orders);
+        result = _(numericDictionary).orderBy<SampleObject>(iteratees);
+        result = _(numericDictionary).orderBy<SampleObject>(iteratees, orders);
 
-        result = _(dictionary).sortByOrder<{a: number}, SampleObject>(iteratees);
-        result = _(dictionary).sortByOrder<{a: number}, SampleObject>(iteratees, orders);
-        result = _(dictionary).sortByOrder<SampleObject>(iteratees);
-        result = _(dictionary).sortByOrder<SampleObject>(iteratees, orders);
+        result = _(dictionary).orderBy<{a: number}, SampleObject>(iteratees);
+        result = _(dictionary).orderBy<{a: number}, SampleObject>(iteratees, orders);
+        result = _(dictionary).orderBy<SampleObject>(iteratees);
+        result = _(dictionary).orderBy<SampleObject>(iteratees, orders);
     }
 
     {
         let iteratees: (value: SampleObject) => any|string|{a: number}|((value: SampleObject) => any|string|{a: number})[];
         let result: _.LoDashExplicitArrayWrapper<SampleObject>;
 
-        result = _(array).chain().sortByOrder<{a: number}>(iteratees);
-        result = _(array).chain().sortByOrder<{a: number}>(iteratees, orders);
+        result = _(array).chain().orderBy<{a: number}>(iteratees);
+        result = _(array).chain().orderBy<{a: number}>(iteratees, orders);
 
-        result = _(list).chain().sortByOrder<{a: number}, SampleObject>(iteratees);
-        result = _(list).chain().sortByOrder<{a: number}, SampleObject>(iteratees, orders);
-        result = _(list).chain().sortByOrder<SampleObject>(iteratees);
-        result = _(list).chain().sortByOrder<SampleObject>(iteratees, orders);
+        result = _(list).chain().orderBy<{a: number}, SampleObject>(iteratees);
+        result = _(list).chain().orderBy<{a: number}, SampleObject>(iteratees, orders);
+        result = _(list).chain().orderBy<SampleObject>(iteratees);
+        result = _(list).chain().orderBy<SampleObject>(iteratees, orders);
 
-        result = _(numericDictionary).chain().sortByOrder<{a: number}, SampleObject>(iteratees);
-        result = _(numericDictionary).chain().sortByOrder<{a: number}, SampleObject>(iteratees, orders);
-        result = _(numericDictionary).chain().sortByOrder<SampleObject>(iteratees);
-        result = _(numericDictionary).chain().sortByOrder<SampleObject>(iteratees, orders);
+        result = _(numericDictionary).chain().orderBy<{a: number}, SampleObject>(iteratees);
+        result = _(numericDictionary).chain().orderBy<{a: number}, SampleObject>(iteratees, orders);
+        result = _(numericDictionary).chain().orderBy<SampleObject>(iteratees);
+        result = _(numericDictionary).chain().orderBy<SampleObject>(iteratees, orders);
 
-        result = _(dictionary).chain().sortByOrder<{a: number}, SampleObject>(iteratees);
-        result = _(dictionary).chain().sortByOrder<{a: number}, SampleObject>(iteratees, orders);
-        result = _(dictionary).chain().sortByOrder<SampleObject>(iteratees);
-        result = _(dictionary).chain().sortByOrder<SampleObject>(iteratees, orders);
+        result = _(dictionary).chain().orderBy<{a: number}, SampleObject>(iteratees);
+        result = _(dictionary).chain().orderBy<{a: number}, SampleObject>(iteratees, orders);
+        result = _(dictionary).chain().orderBy<SampleObject>(iteratees);
+        result = _(dictionary).chain().orderBy<SampleObject>(iteratees, orders);
     }
 }
 
-result = <IStoogesCombined[]>_.where(stoogesCombined, { 'age': 40 });
-result = <IStoogesCombined[]>_.where(stoogesCombined, { 'quotes': ['Poifect!'] });
-
-result = <IStoogesCombined[]>_(stoogesCombined).where({ 'age': 40 }).value();
-result = <IStoogesCombined[]>_(stoogesCombined).where({ 'quotes': ['Poifect!'] }).value();
-
 /********
  * Date *
  ********/
@@ -5418,8 +4627,7 @@ module TestNow {
 /*************
  * Functions *
  *************/
-
-// _after
+// _.after
 module TestAfter {
     interface Func {
         (a: string, b: number): boolean;
@@ -5476,36 +4684,6 @@ module TestAry {
     }
 }
 
-// _.backflow
-module TestBackflow {
-    let Fn1: (n: number) => number;
-    let Fn2: (m: number, n: number) => number;
-
-    {
-        let result: (m: number, n: number) => number;
-
-        result = _.backflow<(m: number, n: number) => number>(Fn1, Fn2);
-        result = _.backflow<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
-        result = _.backflow<(m: number, n: number) => number>(Fn1, Fn1, Fn1, Fn2);
-    }
-
-    {
-        let result: _.LoDashImplicitObjectWrapper<(m: number, n: number) => number>;
-
-        result = _(Fn1).backflow<(m: number, n: number) => number>(Fn2);
-        result = _(Fn1).backflow<(m: number, n: number) => number>(Fn1, Fn2);
-        result = _(Fn1).backflow<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
-    }
-
-    {
-        let result: _.LoDashExplicitObjectWrapper<(m: number, n: number) => number>;
-
-        result = _(Fn1).chain().backflow<(m: number, n: number) => number>(Fn2);
-        result = _(Fn1).chain().backflow<(m: number, n: number) => number>(Fn1, Fn2);
-        result = _(Fn1).chain().backflow<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
-    }
-}
-
 // _.before
 module TestBefore {
     interface Func {
@@ -5735,36 +4913,6 @@ module TestBindKey {
     }
 }
 
-// _.compose
-module TestCompose {
-    let Fn1: (n: number) => number;
-    let Fn2: (m: number, n: number) => number;
-
-    {
-        let result: (m: number, n: number) => number;
-
-        result = _.compose<(m: number, n: number) => number>(Fn1, Fn2);
-        result = _.compose<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
-        result = _.compose<(m: number, n: number) => number>(Fn1, Fn1, Fn1, Fn2);
-    }
-
-    {
-        let result: _.LoDashImplicitObjectWrapper<(m: number, n: number) => number>;
-
-        result = _(Fn1).compose<(m: number, n: number) => number>(Fn2);
-        result = _(Fn1).compose<(m: number, n: number) => number>(Fn1, Fn2);
-        result = _(Fn1).compose<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
-    }
-
-    {
-        let result: _.LoDashExplicitObjectWrapper<(m: number, n: number) => number>;
-
-        result = _(Fn1).chain().compose<(m: number, n: number) => number>(Fn2);
-        result = _(Fn1).chain().compose<(m: number, n: number) => number>(Fn1, Fn2);
-        result = _(Fn1).chain().compose<(m: number, n: number) => number>(Fn1, Fn1, Fn2);
-    }
-}
-
 var createCallbackObj: { [index: string]: string; } = { name: 'Joe' };
 result = <() => any>_.createCallback('name');
 result = <() => boolean>_.createCallback(createCallbackObj);
@@ -5931,6 +5079,33 @@ module TestDelay {
     }
 }
 
+// _.flip
+module TestFlip {
+    interface Func {
+        (a: number, b: string): boolean;
+    }
+
+    let func: Func;
+
+    {
+        let result: Func;
+
+        result = _.flip(func);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<Func>;
+
+        result = _(func).flip();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<Func>;
+
+        result = _(func).chain().flip();
+    }
+}
+
 // _.flow
 module TestFlow {
     let Fn1: (n: number) => number;
@@ -6004,8 +5179,8 @@ result = <TestMemoizedResultFn>_.memoize<TestMemoizedResultFn>(testMemoizeFn, te
 result = <TestMemoizedResultFn>(_(testMemoizeFn).memoize<TestMemoizedResultFn>().value());
 result = <TestMemoizedResultFn>(_(testMemoizeFn).memoize<TestMemoizedResultFn>(testMemoizeResolverFn).value());
 
-// _.modArgs
-module TestModArgs {
+// _.overArgs
+module TestOverArgs {
     type Func1 = (a: boolean) => boolean;
     type Func2 = (a: boolean, b: boolean) => boolean;
 
@@ -6018,43 +5193,43 @@ module TestModArgs {
     {
         let result: (a: string) => boolean;
 
-        result = _.modArgs<Func1, (a: string) => boolean>(func1, transform1);
-        result = _.modArgs<Func1, (a: string) => boolean>(func1, [transform1]);
+        result = _.overArgs<Func1, (a: string) => boolean>(func1, transform1);
+        result = _.overArgs<Func1, (a: string) => boolean>(func1, [transform1]);
     }
 
     {
         let result: (a: string, b: number) => boolean;
 
-        result = _.modArgs<Func2, (a: string, b: number) => boolean>(func2, transform1, transform2);
-        result = _.modArgs<Func2, (a: string, b: number) => boolean>(func2, [transform1, transform2]);
+        result = _.overArgs<Func2, (a: string, b: number) => boolean>(func2, transform1, transform2);
+        result = _.overArgs<Func2, (a: string, b: number) => boolean>(func2, [transform1, transform2]);
     }
 
     {
         let result: _.LoDashImplicitObjectWrapper<(a: string) => boolean>;
 
-        result = _(func1).modArgs<(a: string) => boolean>(transform1);
-        result = _(func1).modArgs<(a: string) => boolean>([transform1]);
+        result = _(func1).overArgs<(a: string) => boolean>(transform1);
+        result = _(func1).overArgs<(a: string) => boolean>([transform1]);
     }
 
     {
         let result: _.LoDashImplicitObjectWrapper<(a: string, b: number) => boolean>;
 
-        result = _(func2).modArgs<(a: string, b: number) => boolean>(transform1, transform2);
-        result = _(func2).modArgs<(a: string, b: number) => boolean>([transform1, transform2]);
+        result = _(func2).overArgs<(a: string, b: number) => boolean>(transform1, transform2);
+        result = _(func2).overArgs<(a: string, b: number) => boolean>([transform1, transform2]);
     }
 
     {
         let result: _.LoDashExplicitObjectWrapper<(a: string) => boolean>;
 
-        result = _(func1).chain().modArgs<(a: string) => boolean>(transform1);
-        result = _(func1).chain().modArgs<(a: string) => boolean>([transform1]);
+        result = _(func1).chain().overArgs<(a: string) => boolean>(transform1);
+        result = _(func1).chain().overArgs<(a: string) => boolean>([transform1]);
     }
 
     {
         let result: _.LoDashExplicitObjectWrapper<(a: string, b: number) => boolean>;
 
-        result = _(func2).chain().modArgs<(a: string, b: number) => boolean>(transform1, transform2);
-        result = _(func2).chain().modArgs<(a: string, b: number) => boolean>([transform1, transform2]);
+        result = _(func2).chain().overArgs<(a: string, b: number) => boolean>(transform1, transform2);
+        result = _(func2).chain().overArgs<(a: string, b: number) => boolean>([transform1, transform2]);
     }
 }
 
@@ -6143,8 +5318,8 @@ result = <string[]>(_.rearg<TestReargResultFn>(testReargFn, [2, 0, 1]))('b', 'c'
 result = <string[]>(_(testReargFn).rearg<TestReargResultFn>(2, 0, 1).value())('b', 'c', 'a');
 result = <string[]>(_(testReargFn).rearg<TestReargResultFn>([2, 0, 1]).value())('b', 'c', 'a');
 
-// _.restParam
-module TestRestParam {
+// _.rest
+module TestRest {
     type Func = (a: string, b: number[]) => boolean;
     type ResultFunc = (a: string, ...b: number[]) => boolean;
 
@@ -6153,25 +5328,25 @@ module TestRestParam {
     {
         let result: ResultFunc;
 
-        result = _.restParam<ResultFunc>(func);
-        result = _.restParam<ResultFunc>(func, 1);
+        result = _.rest<ResultFunc>(func);
+        result = _.rest<ResultFunc>(func, 1);
 
-        result = _.restParam<ResultFunc, Func>(func);
-        result = _.restParam<ResultFunc, Func>(func, 1);
+        result = _.rest<ResultFunc, Func>(func);
+        result = _.rest<ResultFunc, Func>(func, 1);
     }
 
     {
         let result: _.LoDashImplicitObjectWrapper<ResultFunc>;
 
-        result = _(func).restParam<ResultFunc>();
-        result = _(func).restParam<ResultFunc>(1);
+        result = _(func).rest<ResultFunc>();
+        result = _(func).rest<ResultFunc>(1);
     }
 
     {
         let result: _.LoDashExplicitObjectWrapper<ResultFunc>;
 
-        result = _(func).chain().restParam<ResultFunc>();
-        result = _(func).chain().restParam<ResultFunc>(1);
+        result = _(func).chain().rest<ResultFunc>();
+        result = _(func).chain().rest<ResultFunc>(1);
     }
 }
 
@@ -6246,6 +5421,33 @@ module TestThrottle {
     }
 }
 
+// _.unary
+module TestUnary {
+    interface Func {
+        (a: number, b: string): boolean;
+    }
+
+    let func: Func;
+
+    {
+        let result: Func;
+
+        result = _.unary(func);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<Func>;
+
+        result = _(func).unary();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<Func>;
+
+        result = _(func).chain().unary();
+    }
+}
+
 // _.wrap
 module TestWrap {
     type SampleValue = {a: number; b: string; c: boolean}
@@ -6335,87 +5537,79 @@ module TestWrap {
  ********/
 
 // _.clone
+{
+    let result: number;
+    result = _.clone<number>(42);
+    result = _(42).clone();
+}
+{
+    let result: string[];
+    result = _.clone<string[]>([]);
+    result = _<string>([]).clone();
+}
+{
+    let result: {a: {b: number;}};
+    result = _.clone<{a: {b: number;}}>({a: {b: 2}});
+    result = _({a: {b: 2}}).clone();
+}
+
+// _.cloneDeep
+{
+    let result: number;
+    result = _.cloneDeep<number>(42);
+    result = _(42).cloneDeep();
+}
+{
+    let result: string[];
+    result = _.cloneDeep<string[]>([]);
+    result = _<string>([]).cloneDeep();
+}
+{
+    let result: {a: {b: number;}};
+    result = _.cloneDeep<{a: {b: number;}}>({a: {b: 2}});
+    result = _({a: {b: 2}}).cloneDeep();
+}
+
+// _.cloneWith
 interface TestCloneCustomizerFn {
     (value: any): any;
 }
 var testCloneCustomizerFn: TestCloneCustomizerFn;
 {
     let result: number;
-    result = _.clone<number>(42);
-    result = _.clone<number>(42, false);
-    result = _.clone<number>(42, false, testCloneCustomizerFn);
-    result = _.clone<number>(42, false, testCloneCustomizerFn, any);
     result = _.clone<number>(42, testCloneCustomizerFn);
-    result = _.clone<number>(42, testCloneCustomizerFn, any);
-    result = _(42).clone();
-    result = _(42).clone(false);
-    result = _(42).clone(false, testCloneCustomizerFn);
-    result = _(42).clone(false, testCloneCustomizerFn, any);
     result = _(42).clone(testCloneCustomizerFn);
-    result = _(42).clone(testCloneCustomizerFn, any);
 }
 {
     let result: string[];
-    result = _.clone<string[]>([]);
-    result = _.clone<string[]>([], false);
-    result = _.clone<string[]>([], false, testCloneCustomizerFn);
-    result = _.clone<string[]>([], false, testCloneCustomizerFn, any);
     result = _.clone<string[]>([], testCloneCustomizerFn);
-    result = _.clone<string[]>([], testCloneCustomizerFn, any);
-    result = _<string>([]).clone();
-    result = _<string>([]).clone(false);
-    result = _<string>([]).clone(false, testCloneCustomizerFn);
-    result = _<string>([]).clone(false, testCloneCustomizerFn, any);
     result = _<string>([]).clone(testCloneCustomizerFn);
-    result = _<string>([]).clone(testCloneCustomizerFn, any);
 }
 {
     let result: {a: {b: number;}};
-    result = _.clone<{a: {b: number;}}>({a: {b: 2}});
-    result = _.clone<{a: {b: number;}}>({a: {b: 2}}, false);
-    result = _.clone<{a: {b: number;}}>({a: {b: 2}}, false, testCloneCustomizerFn);
-    result = _.clone<{a: {b: number;}}>({a: {b: 2}}, false, testCloneCustomizerFn, any);
     result = _.clone<{a: {b: number;}}>({a: {b: 2}}, testCloneCustomizerFn);
-    result = _.clone<{a: {b: number;}}>({a: {b: 2}}, testCloneCustomizerFn, any);
-    result = _({a: {b: 2}}).clone();
-    result = _({a: {b: 2}}).clone(false);
-    result = _({a: {b: 2}}).clone(false, testCloneCustomizerFn);
-    result = _({a: {b: 2}}).clone(false, testCloneCustomizerFn, any);
     result = _({a: {b: 2}}).clone(testCloneCustomizerFn);
-    result = _({a: {b: 2}}).clone(testCloneCustomizerFn, any);
 }
 
-// _.cloneDeep
+// _.cloneDeepWith
 interface TestCloneDeepCustomizerFn {
     (value: any): any;
 }
 var testCloneDeepCustomizerFn: TestCloneDeepCustomizerFn;
 {
     let result: number;
-    result = _.cloneDeep<number>(42);
     result = _.cloneDeep<number>(42, testCloneDeepCustomizerFn);
-    result = _.cloneDeep<number>(42, testCloneDeepCustomizerFn, any);
-    result = _(42).cloneDeep();
     result = _(42).cloneDeep(testCloneDeepCustomizerFn);
-    result = _(42).cloneDeep(testCloneDeepCustomizerFn, any);
 }
 {
     let result: string[];
-    result = _.cloneDeep<string[]>([]);
     result = _.cloneDeep<string[]>([], testCloneDeepCustomizerFn);
-    result = _.cloneDeep<string[]>([], testCloneDeepCustomizerFn, any);
-    result = _<string>([]).cloneDeep();
     result = _<string>([]).cloneDeep(testCloneDeepCustomizerFn);
-    result = _<string>([]).cloneDeep(testCloneDeepCustomizerFn, any);
 }
 {
     let result: {a: {b: number;}};
-    result = _.cloneDeep<{a: {b: number;}}>({a: {b: 2}});
     result = _.cloneDeep<{a: {b: number;}}>({a: {b: 2}}, testCloneDeepCustomizerFn);
-    result = _.cloneDeep<{a: {b: number;}}>({a: {b: 2}}, testCloneDeepCustomizerFn, any);
-    result = _({a: {b: 2}}).cloneDeep();
     result = _({a: {b: 2}}).cloneDeep(testCloneDeepCustomizerFn);
-    result = _({a: {b: 2}}).cloneDeep(testCloneDeepCustomizerFn, any);
 }
 
 // _.eq
@@ -6426,20 +5620,14 @@ module TestEq {
         let result: boolean;
 
         result = _.eq(any, any);
-        result = _.eq(any, any, customizer);
-        result = _.eq(any, any, customizer, any);
 
         result = _(any).eq(any);
-        result = _(any).eq(any, customizer);
-        result = _(any).eq(any, customizer, any);
     }
 
     {
         let result: _.LoDashExplicitWrapper<boolean>;
 
         result = _(any).chain().eq(any);
-        result = _(any).chain().eq(any, customizer);
-        result = _(any).chain().eq(any, customizer, any);
     }
 }
 
@@ -6550,6 +5738,78 @@ module TestIsArray {
     }
 }
 
+// _.isArrayLike
+module TestIsArrayLike {
+    {
+        let value: number|string[]|boolean[];
+
+        if (_.isArrayLike<string>(value)) {
+            let result: string[] = value;
+        }
+        else {
+            if (_.isArrayLike<boolean>(value)) {
+                let result: boolean[] = value;
+            }
+            else {
+                let result: number = value;
+            }
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isArrayLike(any);
+        result = _(1).isArrayLike();
+        result = _<any>([]).isArrayLike();
+        result = _({}).isArrayLike();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isArrayLike();
+        result = _<any>([]).chain().isArrayLike();
+        result = _({}).chain().isArrayLike();
+    }
+}
+
+// _.isArrayLikeObject
+module TestIsArrayLikeObject {
+    {
+        let value: number|string[]|boolean[];
+
+        if (_.isArrayLikeObject<string>(value)) {
+            let result: string[] = value;
+        }
+        else {
+            if (_.isArrayLikeObject<boolean>(value)) {
+                let result: boolean[] = value;
+            }
+            else {
+                let result: number = value;
+            }
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isArrayLikeObject(any);
+        result = _(1).isArrayLikeObject();
+        result = _<any>([]).isArrayLikeObject();
+        result = _({}).isArrayLikeObject();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isArrayLikeObject();
+        result = _<any>([]).chain().isArrayLikeObject();
+        result = _({}).chain().isArrayLikeObject();
+    }
+}
+
 // _.isBoolean
 module TestIsBoolean {
     {
@@ -6649,20 +5909,33 @@ module TestIsEqual {
         let result: boolean;
 
         result = _.isEqual(any, any);
-        result = _.isEqual(any, any, customizer);
-        result = _.isEqual(any, any, customizer, any);
 
         result = _(any).isEqual(any);
-        result = _(any).isEqual(any, customizer);
-        result = _(any).isEqual(any, customizer, any);
     }
 
     {
         let result: _.LoDashExplicitWrapper<boolean>;
 
         result = _(any).chain().isEqual(any);
-        result = _(any).chain().isEqual(any, customizer);
-        result = _(any).chain().isEqual(any, customizer, any);
+    }
+}
+
+// _.isEqualWith
+module TestIsEqualWith {
+    let customizer: (value: any, other: any, indexOrKey?: number|string) => boolean;
+
+    {
+        let result: boolean;
+
+        result = _.isEqualWith(any, any, customizer);
+
+        result = _(any).isEqualWith(any, customizer);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(any).chain().isEqualWith(any, customizer);
     }
 }
 
@@ -6761,14 +6034,69 @@ module TestIsFunction {
     }
 }
 
+// _.isInteger
+module TestIsInteger {
+    {
+        let result: boolean;
+
+        result = _.isInteger(any);
+
+        result = _(1).isInteger();
+        result = _<any>([]).isInteger();
+        result = _({}).isInteger();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isInteger();
+        result = _<any>([]).chain().isInteger();
+        result = _({}).chain().isInteger();
+    }
+}
+
+// _.isLength
+module TestIsLength {
+    {
+        let result: boolean;
+
+        result = _.isLength(any);
+
+        result = _(1).isLength();
+        result = _<any>([]).isLength();
+        result = _({}).isLength();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isLength();
+        result = _<any>([]).chain().isLength();
+        result = _({}).chain().isLength();
+    }
+}
+
 // _.isMatch
-var testIsMatchCustiomizerFn: (value: any, other: any, indexOrKey: number|string) => boolean;
-result = <boolean>_.isMatch({}, {});
-result = <boolean>_.isMatch({}, {}, testIsMatchCustiomizerFn);
-result = <boolean>_.isMatch({}, {}, testIsMatchCustiomizerFn, {});
-result = <boolean>_({}).isMatch({});
-result = <boolean>_({}).isMatch({}, testIsMatchCustiomizerFn);
-result = <boolean>_({}).isMatch({}, testIsMatchCustiomizerFn, {});
+module TestIsMatch {
+    let testIsMatchCustiomizerFn: (value: any, other: any, indexOrKey: number|string) => boolean;
+
+    let result: boolean;
+
+    result = <boolean>_.isMatch({}, {});
+    result = <boolean>_({}).isMatch({});
+}
+
+
+// _.isMatchWith
+module TestIsMatchWith {
+    let testIsMatchCustiomizerFn: (value: any, other: any, indexOrKey: number|string) => boolean;
+
+    let result: boolean;
+
+    result = <boolean>_.isMatchWith({}, {}, testIsMatchCustiomizerFn);
+    result = <boolean>_({}).isMatchWith({}, testIsMatchCustiomizerFn);
+
+}
 
 // _.isNaN
 module TestIsNaN {
@@ -6823,6 +6151,27 @@ module TestIsNative {
     }
 }
 
+// _.isNil
+module TestIsNil {
+    {
+        let result: boolean;
+
+        result = _.isNil(any);
+
+        result = _(1).isNil();
+        result = _<any>([]).isNil();
+        result = _({}).isNil();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isNil();
+        result = _<any>([]).chain().isNil();
+        result = _({}).chain().isNil();
+    }
+}
+
 // _.isNull
 module TestIsNull {
     {
@@ -6896,6 +6245,26 @@ module TestIsObject {
     }
 }
 
+// _.isObjectLike
+module TestIsObjectLike {
+    {
+        let result: boolean;
+
+        result = _.isObjectLike(any);
+        result = _(1).isObjectLike();
+        result = _<any>([]).isObjectLike();
+        result = _({}).isObjectLike();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isObjectLike();
+        result = _<any>([]).chain().isObjectLike();
+        result = _({}).chain().isObjectLike();
+    }
+}
+
 // _.isPlainObject
 module TestIsPlainObject {
     {
@@ -6947,6 +6316,27 @@ module TestIsRegExp {
     }
 }
 
+// _.isSafeInteger
+module TestIsSafeInteger {
+    {
+        let result: boolean;
+
+        result = _.isSafeInteger(any);
+
+        result = _(1).isSafeInteger();
+        result = _<any>([]).isSafeInteger();
+        result = _({}).isSafeInteger();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isSafeInteger();
+        result = _<any>([]).chain().isSafeInteger();
+        result = _({}).chain().isSafeInteger();
+    }
+}
+
 // _.isString
 module TestIsString {
     {
@@ -6978,6 +6368,27 @@ module TestIsString {
     }
 }
 
+// _.isSymbol
+module TestIsSymbol {
+    {
+        let result: boolean;
+
+        result = _.isSymbol(any);
+
+        result = _(1).isSymbol();
+        result = _<any>([]).isSymbol();
+        result = _({}).isSymbol();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isSymbol();
+        result = _<any>([]).chain().isSymbol();
+        result = _({}).chain().isSymbol();
+    }
+}
+
 // _.isTypedArray
 module TestIsTypedArray {
     {
@@ -7112,21 +6523,119 @@ module TestToArray {
 
 // _.toPlainObject
 module TestToPlainObject {
-    let result: TResult;
 
-    result = _.toPlainObject<TResult>();
-    result = _.toPlainObject<TResult>(true);
-    result = _.toPlainObject<TResult>(1);
-    result = _.toPlainObject<TResult>('a');
-    result = _.toPlainObject<TResult>([]);
-    result = _.toPlainObject<TResult>({});
+    {
+        let result: TResult;
+        result = _.toPlainObject<TResult>();
+        result = _.toPlainObject<TResult>(true);
+        result = _.toPlainObject<TResult>(1);
+        result = _.toPlainObject<TResult>('a');
+        result = _.toPlainObject<TResult>([]);
+        result = _.toPlainObject<TResult>({});
+    }
 
-    result = _(true).toPlainObject<TResult>().value();
-    result = _(1).toPlainObject<TResult>().value();
-    result = _('a').toPlainObject<TResult>().value();
-    result = _([1]).toPlainObject<TResult>().value();
-    result = _<string>([]).toPlainObject<TResult>().value();
-    result = _({}).toPlainObject<TResult>().value();
+    {
+        let result: _.LoDashImplicitObjectWrapper<TResult>;
+
+        result = _(true).toPlainObject<TResult>();
+        result = _(1).toPlainObject<TResult>();
+        result = _('a').toPlainObject<TResult>();
+        result = _([1]).toPlainObject<TResult>();
+        result = _<string>([]).toPlainObject<TResult>();
+        result = _({}).toPlainObject<TResult>();
+    }
+}
+
+// _.toInteger
+module TestToInteger {
+   {
+       let result: number;
+       result = _.toInteger(true);
+       result = _.toInteger(1);
+       result = _.toInteger('a');
+       result = _.toInteger([]);
+       result = _.toInteger({});
+   }
+
+   {
+       let result: _.LoDashImplicitWrapper<number>;
+
+       result = _(true).toInteger();
+       result = _(1).toInteger();
+       result = _('a').toInteger();
+       result = _([1]).toInteger();
+       result = _<string>([]).toInteger();
+       result = _({}).toInteger();
+   }
+}
+
+// _.toLength
+module TestToLength {
+   {
+       let result: number;
+       result = _.toLength(true);
+       result = _.toLength(1);
+       result = _.toLength('a');
+       result = _.toLength([]);
+       result = _.toLength({});
+   }
+
+   {
+       let result: _.LoDashImplicitWrapper<number>;
+
+       result = _(true).toLength();
+       result = _(1).toLength();
+       result = _('a').toLength();
+       result = _([1]).toLength();
+       result = _<string>([]).toLength();
+       result = _({}).toLength();
+   }
+}
+
+// _.toNumber
+module TestToNumber {
+   {
+       let result: number;
+       result = _.toNumber(true);
+       result = _.toNumber(1);
+       result = _.toNumber('a');
+       result = _.toNumber([]);
+       result = _.toNumber({});
+   }
+
+   {
+       let result: _.LoDashImplicitWrapper<number>;
+
+       result = _(true).toNumber();
+       result = _(1).toNumber();
+       result = _('a').toNumber();
+       result = _([1]).toNumber();
+       result = _<string>([]).toNumber();
+       result = _({}).toNumber();
+   }
+}
+
+// _.toSafeInteger
+module TestToSafeInteger {
+   {
+       let result: number;
+       result = _.toSafeInteger(true);
+       result = _.toSafeInteger(1);
+       result = _.toSafeInteger('a');
+       result = _.toSafeInteger([]);
+       result = _.toSafeInteger({});
+   }
+
+   {
+       let result: _.LoDashImplicitWrapper<number>;
+
+       result = _(true).toSafeInteger();
+       result = _(1).toSafeInteger();
+       result = _('a').toSafeInteger();
+       result = _([1]).toSafeInteger();
+       result = _<string>([]).toSafeInteger();
+       result = _({}).toSafeInteger();
+   }
 }
 
 /********
@@ -7196,52 +6705,18 @@ module TestFloor {
 module TestMax {
     let array: number[];
     let list: _.List<number>;
-    let dictionary: _.Dictionary<number>;
-
-    let listIterator: (value: number, index: number, collection: _.List<number>) => number;
-    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => number;
 
     let result: number;
 
     result = _.max<number>(array);
-    result = _.max<number>(array, listIterator);
-    result = _.max<number>(array, listIterator, any);
-    result = _.max<number>(array, '');
-    result = _.max<{a: number}, number>(array, {a: 42});
-
     result = _.max<number>(list);
-    result = _.max<number>(list, listIterator);
-    result = _.max<number>(list, listIterator, any);
-    result = _.max<number>(list, '');
-    result = _.max<{a: number}, number>(list, {a: 42});
-
-    result = _.max<number>(dictionary);
-    result = _.max<number>(dictionary, dictionaryIterator);
-    result = _.max<number>(dictionary, dictionaryIterator, any);
-    result = _.max<number>(dictionary, '');
-    result = _.max<{a: number}, number>(dictionary, {a: 42});
 
     result = _(array).max();
-    result = _(array).max(listIterator);
-    result = _(array).max(listIterator, any);
-    result = _(array).max('');
-    result = _(array).max<{a: number}>({a: 42});
-
     result = _(list).max<number>();
-    result = _(list).max<number>(listIterator);
-    result = _(list).max<number>(listIterator, any);
-    result = _(list).max<number>('');
-    result = _(list).max<{a: number}, number>({a: 42});
-
-    result = _(dictionary).max<number>();
-    result = _(dictionary).max<number>(dictionaryIterator);
-    result = _(dictionary).max<number>(dictionaryIterator, any);
-    result = _(dictionary).max<number>('');
-    result = _(dictionary).max<{a: number}, number>({a: 42});
 }
 
-// _.min
-module TestMin {
+// _.maxBy
+module TestMaxBy {
     let array: number[];
     let list: _.List<number>;
     let dictionary: _.Dictionary<number>;
@@ -7251,41 +6726,104 @@ module TestMin {
 
     let result: number;
 
+    result = _.maxBy<number>(array);
+    result = _.maxBy<number>(array, listIterator);
+    result = _.maxBy<number>(array, '');
+    result = _.maxBy<{a: number}, number>(array, {a: 42});
+
+    result = _.maxBy<number>(list);
+    result = _.maxBy<number>(list, listIterator);
+    result = _.maxBy<number>(list, '');
+    result = _.maxBy<{a: number}, number>(list, {a: 42});
+
+    result = _.maxBy<number>(dictionary);
+    result = _.maxBy<number>(dictionary, dictionaryIterator);
+    result = _.maxBy<number>(dictionary, '');
+    result = _.maxBy<{a: number}, number>(dictionary, {a: 42});
+
+    result = _(array).maxBy();
+    result = _(array).maxBy(listIterator);
+    result = _(array).maxBy('');
+    result = _(array).maxBy<{a: number}>({a: 42});
+
+    result = _(list).maxBy<number>();
+    result = _(list).maxBy<number>(listIterator);
+    result = _(list).maxBy<number>('');
+    result = _(list).maxBy<{a: number}, number>({a: 42});
+
+    result = _(dictionary).maxBy<number>();
+    result = _(dictionary).maxBy<number>(dictionaryIterator);
+    result = _(dictionary).maxBy<number>('');
+    result = _(dictionary).maxBy<{a: number}, number>({a: 42});
+}
+
+// _.mean
+module TestMean {
+    let array: number[];
+
+    let result: number;
+
+    result = _.mean<number>(array);
+
+    result = _(array).mean();
+
+}
+
+// _.min
+module TestMin {
+    let array: number[];
+    let list: _.List<number>;
+
+    let result: number;
+
     result = _.min<number>(array);
-    result = _.min<number>(array, listIterator);
-    result = _.min<number>(array, listIterator, any);
-    result = _.min<number>(array, '');
-    result = _.min<{a: number}, number>(array, {a: 42});
-
     result = _.min<number>(list);
-    result = _.min<number>(list, listIterator);
-    result = _.min<number>(list, listIterator, any);
-    result = _.min<number>(list, '');
-    result = _.min<{a: number}, number>(list, {a: 42});
-
-    result = _.min<number>(dictionary);
-    result = _.min<number>(dictionary, dictionaryIterator);
-    result = _.min<number>(dictionary, dictionaryIterator, any);
-    result = _.min<number>(dictionary, '');
-    result = _.min<{a: number}, number>(dictionary, {a: 42});
 
     result = _(array).min();
-    result = _(array).min(listIterator);
-    result = _(array).min(listIterator, any);
-    result = _(array).min('');
-    result = _(array).min<{a: number}>({a: 42});
-
     result = _(list).min<number>();
-    result = _(list).min<number>(listIterator);
-    result = _(list).min<number>(listIterator, any);
-    result = _(list).min<number>('');
-    result = _(list).min<{a: number}, number>({a: 42});
 
-    result = _(dictionary).min<number>();
-    result = _(dictionary).min<number>(dictionaryIterator);
-    result = _(dictionary).min<number>(dictionaryIterator, any);
-    result = _(dictionary).min<number>('');
-    result = _(dictionary).min<{a: number}, number>({a: 42});
+}
+
+// _.minBy
+module TestMinBy {
+    let array: number[];
+    let list: _.List<number>;
+    let dictionary: _.Dictionary<number>;
+
+    let listIterator: (value: number, index: number, collection: _.List<number>) => number;
+    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => number;
+
+    let result: number;
+
+    result = _.minBy<number>(array);
+    result = _.minBy<number>(array, listIterator);
+    result = _.minBy<number>(array, '');
+    result = _.minBy<{a: number}, number>(array, {a: 42});
+
+    result = _.minBy<number>(list);
+    result = _.minBy<number>(list, listIterator);
+    result = _.minBy<number>(list, '');
+    result = _.minBy<{a: number}, number>(list, {a: 42});
+
+    result = _.minBy<number>(dictionary);
+    result = _.minBy<number>(dictionary, dictionaryIterator);
+    result = _.minBy<number>(dictionary, '');
+    result = _.minBy<{a: number}, number>(dictionary, {a: 42});
+
+    result = _(array).minBy();
+    result = _(array).minBy(listIterator);
+    result = _(array).minBy('');
+    result = _(array).minBy<{a: number}>({a: 42});
+
+    result = _(list).minBy<number>();
+    result = _(list).minBy<number>(listIterator);
+    result = _(list).minBy<number>('');
+    result = _(list).minBy<{a: number}, number>({a: 42});
+
+    result = _(dictionary).minBy<number>();
+    result = _(dictionary).minBy<number>(dictionaryIterator);
+    result = _(dictionary).minBy<number>('');
+    result = _(dictionary).minBy<{a: number}, number>({a: 42});
 }
 
 // _.round
@@ -7322,58 +6860,74 @@ module TestSum {
 
         result = _.sum(array);
         result = _.sum<number>(array);
-        result = _.sum<number>(array, listIterator);
-        result = _.sum<number>(array, listIterator, any);
-        result = _.sum<number>(array, '');
-
 
         result = _.sum(list);
         result = _.sum<number>(list);
-        result = _.sum<number>(list, listIterator);
-        result = _.sum<number>(list, listIterator, any);
-        result = _.sum<number>(list, '');
-
-        result = _.sum(dictionary);
-        result = _.sum<number>(dictionary);
-        result = _.sum<number>(dictionary, dictionaryIterator);
-        result = _.sum<number>(dictionary, dictionaryIterator, any);
-        result = _.sum<number>(dictionary, '');
 
         result = _(array).sum();
-        result = _(array).sum(listIterator);
-        result = _(array).sum(listIterator, any);
-        result = _(array).sum('');
-
 
         result = _(list).sum();
-        result = _(list).sum<number>(listIterator);
-        result = _(list).sum<number>(listIterator, any);
-        result = _(list).sum('');
 
         result = _(dictionary).sum();
-        result = _(dictionary).sum<number>(dictionaryIterator);
-        result = _(dictionary).sum<number>(dictionaryIterator, any);
-        result = _(dictionary).sum('');
     }
 
     {
         let result: _.LoDashExplicitWrapper<number>;
 
         result = _(array).chain().sum();
-        result = _(array).chain().sum(listIterator);
-        result = _(array).chain().sum(listIterator, any);
-        result = _(array).chain().sum('');
-
 
         result = _(list).chain().sum();
-        result = _(list).chain().sum<number>(listIterator);
-        result = _(list).chain().sum<number>(listIterator, any);
-        result = _(list).chain().sum('');
 
         result = _(dictionary).chain().sum();
-        result = _(dictionary).chain().sum<number>(dictionaryIterator);
-        result = _(dictionary).chain().sum<number>(dictionaryIterator, any);
-        result = _(dictionary).chain().sum('');
+    }
+}
+
+// _.sumBy
+module TestSumBy {
+    let array: number[];
+    let list: _.List<number>;
+    let dictionary: _.Dictionary<number>;
+
+    let listIterator: (value: number, index: number, collection: _.List<number>) => number;
+    let dictionaryIterator: (value: number, key: string, collection: _.Dictionary<number>) => number;
+
+    {
+        let result: number;
+
+        result = _.sumBy<number>(array);
+        result = _.sumBy<number>(array, listIterator);
+        result = _.sumBy<number>(array, '');
+
+
+        result = _.sumBy<number>(list);
+        result = _.sumBy<number>(list, listIterator);
+        result = _.sumBy<number>(list, '');
+
+        result = _.sumBy<number>(dictionary);
+        result = _.sumBy<number>(dictionary, dictionaryIterator);
+        result = _.sumBy<number>(dictionary, '');
+
+        result = _(array).sumBy(listIterator);
+        result = _(array).sumBy('');
+
+        result = _(list).sumBy<number>(listIterator);
+        result = _(list).sumBy('');
+
+        result = _(dictionary).sumBy<number>(dictionaryIterator);
+        result = _(dictionary).sumBy('');
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(array).chain().sumBy(listIterator);
+        result = _(array).chain().sumBy('');
+
+        result = _(list).chain().sumBy<number>(listIterator);
+        result = _(list).chain().sumBy('');
+
+        result = _(dictionary).chain().sumBy<number>(dictionaryIterator);
+        result = _(dictionary).chain().sumBy('');
     }
 }
 
@@ -7381,6 +6935,40 @@ module TestSum {
  * Number *
  **********/
 
+ // _.subtract
+ module subtract {
+     {
+         let result: number;
+
+         result = _.subtract(3, 2);
+
+         result = _(3).subtract(2);
+     }
+
+     {
+         let result: _.LoDashExplicitWrapper<number>;
+
+         result = _(3).chain().subtract(2);
+     }
+ }
+
+// _.clamp
+module TestInClamp {
+    {
+        let result: number;
+
+        result = _.clamp(3, 2, 4);
+
+        result = _(3).clamp(2, 4);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<number>;
+
+        result = _(3).chain().clamp(2, 4);
+    }
+}
+
 // _.inRange
 module TestInRange {
     {
@@ -7463,40 +7051,30 @@ module TestAssign {
         let result: {a: number};
 
         result = _.assign<Obj, S1, {a: number}>(obj, s1);
-        result = _.assign<Obj, S1, {a: number}>(obj, s1, customizer);
-        result = _.assign<Obj, S1, {a: number}>(obj, s1, customizer, any);
     }
 
     {
         let result: {a: number, b: number};
 
         result = _.assign<Obj, S1, S2, {a: number, b: number}>(obj, s1, s2);
-        result = _.assign<Obj, S1, S2, {a: number, b: number}>(obj, s1, s2, customizer);
-        result = _.assign<Obj, S1, S2, {a: number, b: number}>(obj, s1, s2, customizer, any);
     }
 
     {
         let result: {a: number, b: number, c: number};
 
         result = _.assign<Obj, S1, S2, S3, {a: number, b: number, c: number}>(obj, s1, s2, s3);
-        result = _.assign<Obj, S1, S2, S3, {a: number, b: number, c: number}>(obj, s1, s2, s3, customizer);
-        result = _.assign<Obj, S1, S2, S3, {a: number, b: number, c: number}>(obj, s1, s2, s3, customizer, any);
     }
 
     {
         let result: {a: number, b: number, c: number, d: number};
 
         result = _.assign<Obj, S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(obj, s1, s2, s3, s4);
-        result = _.assign<Obj, S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(obj, s1, s2, s3, s4, customizer);
-        result = _.assign<Obj, S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(obj, s1, s2, s3, s4, customizer, any);
     }
 
     {
         let result: {a: number, b: number, c: number, d: number, e: number};
 
         result = _.assign<Obj, {a: number, b: number, c: number, d: number, e: number}>(obj, s1, s2, s3, s4, s5);
-        result = _.assign<Obj, {a: number, b: number, c: number, d: number, e: number}>(obj, s1, s2, s3, s4, s5, customizer);
-        result = _.assign<Obj, {a: number, b: number, c: number, d: number, e: number}>(obj, s1, s2, s3, s4, s5, customizer, any);
     }
 
     {
@@ -7509,40 +7087,30 @@ module TestAssign {
         let result: _.LoDashImplicitObjectWrapper<{a: number}>;
 
         result = _(obj).assign<S1, {a: number}>(s1);
-        result = _(obj).assign<S1, {a: number}>(s1, customizer);
-        result = _(obj).assign<S1, {a: number}>(s1, customizer, any);
     }
 
     {
         let result: _.LoDashImplicitObjectWrapper<{a: number, b: number}>;
 
         result = _(obj).assign<S1, S2, {a: number, b: number}>(s1, s2);
-        result = _(obj).assign<S1, S2, {a: number, b: number}>(s1, s2, customizer);
-        result = _(obj).assign<S1, S2, {a: number, b: number}>(s1, s2, customizer, any);
     }
 
     {
         let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number}>;
 
         result = _(obj).assign<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3);
-        result = _(obj).assign<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3, customizer);
-        result = _(obj).assign<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3, customizer, any);
     }
 
     {
         let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number, d: number}>;
 
         result = _(obj).assign<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4);
-        result = _(obj).assign<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4, customizer);
-        result = _(obj).assign<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4, customizer, any);
     }
 
     {
         let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number, d: number, e: number}>;
 
         result = _(obj).assign<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5);
-        result = _(obj).assign<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5, customizer);
-        result = _(obj).assign<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5, customizer, any);
     }
 
     {
@@ -7555,40 +7123,381 @@ module TestAssign {
         let result: _.LoDashExplicitObjectWrapper<{a: number}>;
 
         result = _(obj).chain().assign<S1, {a: number}>(s1);
-        result = _(obj).chain().assign<S1, {a: number}>(s1, customizer);
-        result = _(obj).chain().assign<S1, {a: number}>(s1, customizer, any);
     }
 
     {
         let result: _.LoDashExplicitObjectWrapper<{a: number, b: number}>;
 
         result = _(obj).chain().assign<S1, S2, {a: number, b: number}>(s1, s2);
-        result = _(obj).chain().assign<S1, S2, {a: number, b: number}>(s1, s2, customizer);
-        result = _(obj).chain().assign<S1, S2, {a: number, b: number}>(s1, s2, customizer, any);
     }
 
     {
         let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number}>;
 
         result = _(obj).chain().assign<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3);
-        result = _(obj).chain().assign<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3, customizer);
-        result = _(obj).chain().assign<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3, customizer, any);
     }
 
     {
         let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number, d: number}>;
 
         result = _(obj).chain().assign<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4);
-        result = _(obj).chain().assign<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4, customizer);
-        result = _(obj).chain().assign<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4, customizer, any);
     }
 
     {
         let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number, d: number, e: number}>;
 
         result = _(obj).chain().assign<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5);
-        result = _(obj).chain().assign<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5, customizer);
-        result = _(obj).chain().assign<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5, customizer, any);
+    }
+}
+
+// _.assignWith
+module TestAssignWith {
+    interface Obj {a: string};
+    interface S1 {a: number};
+    interface S2 {b: number};
+    interface S3 {c: number};
+    interface S4 {d: number};
+    interface S5 {e: number};
+
+    let obj: Obj;
+    let s1: S1;
+    let s2: S2;
+    let s3: S3;
+    let s4: S4;
+    let s5: S5;
+
+    let customizer: (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}) => any;
+
+    {
+        let result: Obj;
+
+        result = _.assignWith<Obj>(obj);
+    }
+
+    {
+        let result: {a: number};
+        result = _.assignWith<Obj, S1, {a: number}>(obj, s1, customizer);
+    }
+
+    {
+        let result: {a: number, b: number};
+        result = _.assignWith<Obj, S1, S2, {a: number, b: number}>(obj, s1, s2, customizer);
+    }
+
+    {
+        let result: {a: number, b: number, c: number};
+        result = _.assignWith<Obj, S1, S2, S3, {a: number, b: number, c: number}>(obj, s1, s2, s3, customizer);
+    }
+
+    {
+        let result: {a: number, b: number, c: number, d: number};
+        result = _.assignWith<Obj, S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(obj, s1, s2, s3, s4, customizer);
+    }
+
+    {
+        let result: {a: number, b: number, c: number, d: number, e: number};
+        result = _.assignWith<Obj, {a: number, b: number, c: number, d: number, e: number}>(obj, s1, s2, s3, s4, s5, customizer);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<Obj>;
+
+        result = _(obj).assignWith();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number}>;
+        result = _(obj).assignWith<S1, {a: number}>(s1, customizer);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number}>;
+        result = _(obj).assignWith<S1, S2, {a: number, b: number}>(s1, s2, customizer);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number}>;
+        result = _(obj).assignWith<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3, customizer);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number, d: number}>;
+        result = _(obj).assignWith<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4, customizer);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number, d: number, e: number}>;
+        result = _(obj).assignWith<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5, customizer);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<Obj>;
+
+        result = _(obj).chain().assignWith();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number}>;
+        result = _(obj).chain().assignWith<S1, {a: number}>(s1, customizer);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number}>;
+        result = _(obj).chain().assignWith<S1, S2, {a: number, b: number}>(s1, s2, customizer);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number}>;
+        result = _(obj).chain().assignWith<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3, customizer);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number, d: number}>;
+        result = _(obj).chain().assignWith<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4, customizer);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number, d: number, e: number}>;
+        result = _(obj).chain().assignWith<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5, customizer);
+    }
+}
+
+// _.assignIn
+module TestAssignIn {
+    interface Obj {a: string};
+    interface S1 {a: number};
+    interface S2 {b: number};
+    interface S3 {c: number};
+    interface S4 {d: number};
+    interface S5 {e: number};
+
+    let obj: Obj;
+    let s1: S1;
+    let s2: S2;
+    let s3: S3;
+    let s4: S4;
+    let s5: S5;
+
+    let customizer: (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}) => any;
+
+    {
+        let result: Obj;
+
+        result = _.assignIn<Obj>(obj);
+    }
+
+    {
+        let result: {a: number};
+
+        result = _.assignIn<Obj, S1, {a: number}>(obj, s1);
+    }
+
+    {
+        let result: {a: number, b: number};
+
+        result = _.assignIn<Obj, S1, S2, {a: number, b: number}>(obj, s1, s2);
+    }
+
+    {
+        let result: {a: number, b: number, c: number};
+
+        result = _.assignIn<Obj, S1, S2, S3, {a: number, b: number, c: number}>(obj, s1, s2, s3);
+    }
+
+    {
+        let result: {a: number, b: number, c: number, d: number};
+
+        result = _.assignIn<Obj, S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(obj, s1, s2, s3, s4);
+    }
+
+    {
+        let result: {a: number, b: number, c: number, d: number, e: number};
+
+        result = _.assignIn<Obj, {a: number, b: number, c: number, d: number, e: number}>(obj, s1, s2, s3, s4, s5);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<Obj>;
+
+        result = _(obj).assignIn();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number}>;
+
+        result = _(obj).assignIn<S1, {a: number}>(s1);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number}>;
+
+        result = _(obj).assignIn<S1, S2, {a: number, b: number}>(s1, s2);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number}>;
+
+        result = _(obj).assignIn<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number, d: number}>;
+
+        result = _(obj).assignIn<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number, d: number, e: number}>;
+
+        result = _(obj).assignIn<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<Obj>;
+
+        result = _(obj).chain().assignIn();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number}>;
+
+        result = _(obj).chain().assignIn<S1, {a: number}>(s1);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number}>;
+
+        result = _(obj).chain().assignIn<S1, S2, {a: number, b: number}>(s1, s2);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number}>;
+
+        result = _(obj).chain().assignIn<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number, d: number}>;
+
+        result = _(obj).chain().assignIn<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number, d: number, e: number}>;
+
+        result = _(obj).chain().assignIn<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5);
+    }
+}
+
+// _.assignInWith
+module TestAssignInWith {
+    interface Obj {a: string};
+    interface S1 {a: number};
+    interface S2 {b: number};
+    interface S3 {c: number};
+    interface S4 {d: number};
+    interface S5 {e: number};
+
+    let obj: Obj;
+    let s1: S1;
+    let s2: S2;
+    let s3: S3;
+    let s4: S4;
+    let s5: S5;
+
+    let customizer: (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}) => any;
+
+    {
+        let result: Obj;
+
+        result = _.assignInWith<Obj>(obj);
+    }
+
+    {
+        let result: {a: number};
+        result = _.assignInWith<Obj, S1, {a: number}>(obj, s1, customizer);
+    }
+
+    {
+        let result: {a: number, b: number};
+        result = _.assignInWith<Obj, S1, S2, {a: number, b: number}>(obj, s1, s2, customizer);
+    }
+
+    {
+        let result: {a: number, b: number, c: number};
+        result = _.assignInWith<Obj, S1, S2, S3, {a: number, b: number, c: number}>(obj, s1, s2, s3, customizer);
+    }
+
+    {
+        let result: {a: number, b: number, c: number, d: number};
+        result = _.assignInWith<Obj, S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(obj, s1, s2, s3, s4, customizer);
+    }
+
+    {
+        let result: {a: number, b: number, c: number, d: number, e: number};
+        result = _.assignInWith<Obj, {a: number, b: number, c: number, d: number, e: number}>(obj, s1, s2, s3, s4, s5, customizer);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<Obj>;
+
+        result = _(obj).assignInWith();
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number}>;
+        result = _(obj).assignInWith<S1, {a: number}>(s1, customizer);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number}>;
+        result = _(obj).assignInWith<S1, S2, {a: number, b: number}>(s1, s2, customizer);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number}>;
+        result = _(obj).assignInWith<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3, customizer);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number, d: number}>;
+        result = _(obj).assignInWith<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4, customizer);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<{a: number, b: number, c: number, d: number, e: number}>;
+        result = _(obj).assignInWith<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5, customizer);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<Obj>;
+
+        result = _(obj).chain().assignInWith();
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number}>;
+        result = _(obj).chain().assignInWith<S1, {a: number}>(s1, customizer);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number}>;
+        result = _(obj).chain().assignInWith<S1, S2, {a: number, b: number}>(s1, s2, customizer);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number}>;
+        result = _(obj).chain().assignInWith<S1, S2, S3, {a: number, b: number, c: number}>(s1, s2, s3, customizer);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number, d: number}>;
+        result = _(obj).chain().assignInWith<S1, S2, S3, S4, {a: number, b: number, c: number, d: number}>(s1, s2, s3, s4, customizer);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<{a: number, b: number, c: number, d: number, e: number}>;
+        result = _(obj).chain().assignInWith<{a: number, b: number, c: number, d: number, e: number}>(s1, s2, s3, s4, s5, customizer);
     }
 }
 
@@ -8243,6 +8152,31 @@ module TestFunctions {
     }
 }
 
+// _.functionsIn
+module TestFunctionsIn {
+    type SampleObject = {a: number; b: string; c: boolean;};
+
+    let object: SampleObject;
+
+    {
+        let result: string[];
+
+        result = _.functionsIn<SampleObject>(object);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _(object).functionsIn();
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _(object).chain().functionsIn();
+    }
+}
+
 // _.get
 result = <number>_.get<number>({ 'a': [{ 'b': { 'c': 3 } }] }, 'a[0].b.c');
 
@@ -8288,6 +8222,36 @@ module TestHas {
     }
 }
 
+// _.hasIn
+module TestHasIn {
+    type SampleObject = {a: number; b: string; c: boolean;};
+
+    let object: SampleObject;
+
+    {
+        let result: boolean;
+
+        result = _.hasIn<SampleObject>(object, '');
+        result = _.hasIn<SampleObject>(object, 42);
+        result = _.hasIn<SampleObject>(object, true);
+        result = _.hasIn<SampleObject>(object, ['', 42, true]);
+
+        result = _(object).hasIn('');
+        result = _(object).hasIn(42);
+        result = _(object).hasIn(true);
+        result = _(object).hasIn(['', 42, true]);
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(object).chain().hasIn('');
+        result = _(object).chain().hasIn(42);
+        result = _(object).chain().hasIn(true);
+        result = _(object).chain().hasIn(['', 42, true]);
+    }
+}
+
 // _.invert
 module TestInvert {
     {
@@ -8457,32 +8421,19 @@ module TestMerge {
     type ExpectedResult = { a: number, b: string };
     let result: ExpectedResult;
 
-    let customizer: (value: any, srcValue: any, key?: string, object?: InitialValue, source?: MergingValue) => any;
-
     // Test for basic merging
 
     result = _.merge(initialValue, mergingValue);
-    result = _.merge(initialValue, mergingValue, customizer);
-    result = _.merge(initialValue, mergingValue, customizer, any);
 
     result = _.merge(initialValue, {}, mergingValue);
-    result = _.merge(initialValue, {}, mergingValue, customizer);
-    result = _.merge(initialValue, {}, mergingValue, customizer, any);
 
     result = _.merge(initialValue, {}, {}, mergingValue);
-    result = _.merge(initialValue, {}, {}, mergingValue, customizer);
-    result = _.merge(initialValue, {}, {}, mergingValue, customizer, any);
 
     result = _.merge(initialValue, {}, {}, {}, mergingValue);
-    result = _.merge(initialValue, {}, {}, {}, mergingValue, customizer);
-    result = _.merge(initialValue, {}, {}, {}, mergingValue, customizer, any);
 
     // Once we get to the varargs version, you have to specify the result explicitly
     result = _.merge<ExpectedResult>(initialValue, {}, {}, {}, {}, mergingValue);
-    result = _.merge<ExpectedResult>(initialValue, {}, {}, {}, {}, mergingValue, customizer);
-    result = _.merge<ExpectedResult>(initialValue, {}, {}, {}, {}, mergingValue, customizer, any);
 
-    // Test for multiple combinations of many types
 
     type ComplicatedExpectedType = { a: number, b: string, c: {}, d: number[], e: boolean };
 
@@ -8504,25 +8455,15 @@ module TestMerge {
     // Tests for basic chaining with merge
 
     result = _(initialValue).merge(mergingValue).value();
-    result = _(initialValue).merge(mergingValue, customizer).value();
-    result = _(initialValue).merge(mergingValue, customizer, any).value();
 
     result = _(initialValue).merge({}, mergingValue).value();
-    result = _(initialValue).merge({}, mergingValue, customizer).value();
-    result = _(initialValue).merge({}, mergingValue, customizer, any).value();
 
     result = _(initialValue).merge({}, {}, mergingValue).value();
-    result = _(initialValue).merge({}, {}, mergingValue, customizer).value();
-    result = _(initialValue).merge({}, {}, mergingValue, customizer, any).value();
 
     result = _(initialValue).merge({}, {}, {}, mergingValue).value();
-    result = _(initialValue).merge({}, {}, {}, mergingValue, customizer).value();
-    result = _(initialValue).merge({}, {}, {}, mergingValue, customizer, any).value();
 
     // Once we get to the varargs version, you have to specify the result explicitly
     result = _(initialValue).merge<ExpectedResult>({}, {}, {}, {}, mergingValue).value();
-    result = _(initialValue).merge<ExpectedResult>({}, {}, {}, {}, mergingValue, customizer).value();
-    result = _(initialValue).merge<ExpectedResult>({}, {}, {}, {}, mergingValue, customizer, any).value();
 
     // Test complex multiple combinations with chaining
 
@@ -8540,64 +8481,56 @@ module TestMerge {
 
     {
         let result: _.LoDashExplicitObjectWrapper<ExpectedResult>;
-
-        result = _(initialValue).chain().merge(mergingValue);
-        result = _(initialValue).chain().merge(mergingValue, customizer);
-        result = _(initialValue).chain().merge(mergingValue, customizer, any);
-
-        result = _(initialValue).chain().merge({}, mergingValue);
-        result = _(initialValue).chain().merge({}, mergingValue, customizer);
-        result = _(initialValue).chain().merge({}, mergingValue, customizer, any);
-
-        result = _(initialValue).chain().merge({}, {}, mergingValue);
-        result = _(initialValue).chain().merge({}, {}, mergingValue, customizer);
-        result = _(initialValue).chain().merge({}, {}, mergingValue, customizer, any);
-
-        result = _(initialValue).chain().merge({}, {}, {}, mergingValue);
-        result = _(initialValue).chain().merge({}, {}, {}, mergingValue, customizer);
-        result = _(initialValue).chain().merge({}, {}, {}, mergingValue, customizer, any);
-
-        result = _(initialValue).chain().merge<ExpectedResult>({}, {}, {}, {}, mergingValue);
-        result = _(initialValue).chain().merge<ExpectedResult>({}, {}, {}, {}, mergingValue, customizer);
-        result = _(initialValue).chain().merge<ExpectedResult>({}, {}, {}, {}, mergingValue, customizer, any);
+        // result = _(initialValue).chain().merge(mergingValue);
+        // result = _(initialValue).chain().merge({}, mergingValue);
+        // result = _(initialValue).chain().merge({}, {}, mergingValue);
+        // result = _(initialValue).chain().merge({}, {}, {}, mergingValue);
+        // result = _(initialValue).chain().merge<ExpectedResult>({}, {}, {}, {}, mergingValue);
     }
 
     {
         let result: _.LoDashExplicitObjectWrapper<ComplicatedExpectedType>;
 
-        result = _({ a: 1 }).chain().merge({ b: "string" }, { c: {} }, { d: [1] }, { e: true });
+        //result = _({ a: 1 }).chain().merge({ b: "string" }, { c: {} }, { d: [1] }, { e: true });
     }
 
     {
         let result: _.LoDashExplicitObjectWrapper<ExpectedTypeAfterOverriding>;
 
-        result = _({ a: 1 }).chain().merge({ a: "string" }, { a: {} }, { a: [1] }, { a: true });
+        //result = _({ a: 1 }).chain().merge({ a: "string" }, { a: {} }, { a: [1] }, { a: true });
     }
 }
 
-// _.methods
-module TestFunctions {
-    type SampleObject = {a: number; b: string; c: boolean;};
+// _.mergeWith
+module TestMergeWith {
+    type InitialValue = { a : number };
+    type MergingValue = { b : string };
 
-    let object: SampleObject;
+    var initialValue  = { a : 1 };
+    var mergingValue  = { b : "hi" };
 
-    {
-        let result: string[];
+    type ExpectedResult = { a: number, b: string };
+    let result: ExpectedResult;
 
-        result = _.methods<SampleObject>(object);
-    }
+    let customizer: (value: any, srcValue: any, key?: string, object?: InitialValue, source?: MergingValue) => any;
 
-    {
-        let result: _.LoDashImplicitArrayWrapper<string>;
+    // Test for basic merging
+    result = _.mergeWith(initialValue, mergingValue, customizer);
+    result = _.mergeWith(initialValue, {}, mergingValue, customizer);
+    result = _.mergeWith(initialValue, {}, {}, mergingValue, customizer);
+    result = _.mergeWith(initialValue, {}, {}, {}, mergingValue, customizer);
 
-        result = _(object).methods();
-    }
+    // Once we get to the varargs version, you have to specify the result explicitl
+    result = _.mergeWith<ExpectedResult>(initialValue, {}, {}, {}, {}, mergingValue, customizer);
 
-    {
-        let result: _.LoDashExplicitArrayWrapper<string>;
+    // Tests for basic chaining with mergeWith
+    result = _(initialValue).mergeWith(mergingValue, customizer).value();
+    result = _(initialValue).mergeWith({}, mergingValue, customizer).value();
+    result = _(initialValue).mergeWith({}, {}, mergingValue, customizer).value();
+    result = _(initialValue).mergeWith({}, {}, {}, mergingValue, customizer).value();
 
-        result = _(object).chain().methods();
-    }
+    // Once we get to the varargs version, you have to specify the result explicitl
+    result = _(initialValue).mergeWith<ExpectedResult>({}, {}, {}, {}, mergingValue, customizer).value();
 }
 
 // _.omit
@@ -8611,8 +8544,6 @@ module TestOmit {
         result = _.omit<TResult, Object>({}, 0, 'a');
         result = _.omit<TResult, Object>({}, true, 0, 'a');
         result = _.omit<TResult, Object>({}, ['b', 1, false], true, 0, 'a');
-        result = _.omit<TResult, Object>({}, predicate);
-        result = _.omit<TResult, Object>({}, predicate, any);
     }
 
     {
@@ -8622,8 +8553,6 @@ module TestOmit {
         result = _({}).omit<TResult>(0, 'a');
         result = _({}).omit<TResult>(true, 0, 'a');
         result = _({}).omit<TResult>(['b', 1, false], true, 0, 'a');
-        result = _({}).omit<TResult>(predicate);
-        result = _({}).omit<TResult>(predicate, any);
     }
 
     {
@@ -8633,49 +8562,70 @@ module TestOmit {
         result = _({}).chain().omit<TResult>(0, 'a');
         result = _({}).chain().omit<TResult>(true, 0, 'a');
         result = _({}).chain().omit<TResult>(['b', 1, false], true, 0, 'a');
-        result = _({}).chain().omit<TResult>(predicate);
-        result = _({}).chain().omit<TResult>(predicate, any);
     }
 }
 
-// _.pairs
-module TestPairs {
+// _.omitBy
+module TestOmitBy {
+    let predicate: (element: any, key: string, collection: any) => boolean;
+
+    {
+        let result: TResult;
+
+        result = _.omitBy<TResult, Object>({}, predicate);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<TResult>;
+
+        result = _({}).omitBy<TResult>(predicate);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<TResult>;
+
+        result = _({}).chain().omitBy<TResult>(predicate);
+    }
+}
+
+// _.toPairs
+module TestToPairs {
     let object: _.Dictionary<string>;
 
     {
         let result: any[][];
 
-        result = _.pairs<_.Dictionary<string>>(object);
+        result = _.toPairs<_.Dictionary<string>>(object);
     }
 
     {
         let result: string[][];
 
-        result = _.pairs<_.Dictionary<string>, string>(object);
+        result = _.toPairs<_.Dictionary<string>, string>(object);
     }
 
     {
         let result: _.LoDashImplicitArrayWrapper<string[]>;
 
-        result = _(object).pairs<string>();
+        result = _(object).toPairs<string>();
     }
 
     {
         let result: _.LoDashImplicitArrayWrapper<any[]>;
 
-        result = _(object).pairs();
+        result = _(object).toPairs();
     }
 
     {
         let result: _.LoDashExplicitArrayWrapper<string[]>;
 
-        result = _(object).chain().pairs<string>();
+        result = _(object).chain().toPairs<string>();
     }
 
     {
         let result: _.LoDashExplicitArrayWrapper<any[]>;
 
-        result = _(object).chain().pairs();
+        result = _(object).chain().toPairs();
     }
 }
 
@@ -8690,8 +8640,6 @@ module TestPick {
         result = _.pick<TResult, Object>({}, 0, 'a');
         result = _.pick<TResult, Object>({}, true, 0, 'a');
         result = _.pick<TResult, Object>({}, ['b', 1, false], true, 0, 'a');
-        result = _.pick<TResult, Object>({}, predicate);
-        result = _.pick<TResult, Object>({}, predicate, any);
     }
 
     {
@@ -8701,8 +8649,6 @@ module TestPick {
         result = _({}).pick<TResult>(0, 'a');
         result = _({}).pick<TResult>(true, 0, 'a');
         result = _({}).pick<TResult>(['b', 1, false], true, 0, 'a');
-        result = _({}).pick<TResult>(predicate);
-        result = _({}).pick<TResult>(predicate, any);
     }
 
     {
@@ -8712,8 +8658,29 @@ module TestPick {
         result = _({}).chain().pick<TResult>(0, 'a');
         result = _({}).chain().pick<TResult>(true, 0, 'a');
         result = _({}).chain().pick<TResult>(['b', 1, false], true, 0, 'a');
-        result = _({}).chain().pick<TResult>(predicate);
-        result = _({}).chain().pick<TResult>(predicate, any);
+    }
+}
+
+// _.pickBy
+module TestPickBy {
+    let predicate: (element: any, key: string, collection: any) => boolean;
+
+    {
+        let result: TResult;
+
+        result = _.pickBy<TResult, Object>({}, predicate);
+    }
+
+    {
+        let result: _.LoDashImplicitObjectWrapper<TResult>;
+
+        result = _({}).pickBy<TResult>(predicate);
+    }
+
+    {
+        let result: _.LoDashExplicitObjectWrapper<TResult>;
+
+        result = _({}).chain().pickBy<TResult>(predicate);
     }
 }
 
@@ -8998,6 +8965,38 @@ module TestKebabCase {
     }
 }
 
+// _.lowerCase
+module TestLowerCase {
+    {
+        let result: string;
+
+        result = _.lowerCase('Foo Bar');
+        result = _('Foo Bar').lowerCase();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('Foo Bar').chain().lowerCase();
+    }
+}
+
+// _.lowerFirst
+module TestLowerFirst {
+    {
+        let result: string;
+
+        result = _.lowerFirst('Foo Bar');
+        result = _('Foo Bar').lowerFirst();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('Foo Bar').chain().lowerFirst();
+    }
+}
+
 // _.pad
 module TestPad {
     {
@@ -9021,49 +9020,49 @@ module TestPad {
     }
 }
 
-// _.padLeft
-module TestPadLeft {
+// _.padStart
+module TestPadStart {
     {
         let result: string;
 
-        result = _.padLeft('abc');
-        result = _.padLeft('abc', 6);
-        result = _.padLeft('abc', 6, '_-');
+        result = _.padStart('abc');
+        result = _.padStart('abc', 6);
+        result = _.padStart('abc', 6, '_-');
 
-        result = _('abc').padLeft();
-        result = _('abc').padLeft(6);
-        result = _('abc').padLeft(6, '_-');
+        result = _('abc').padStart();
+        result = _('abc').padStart(6);
+        result = _('abc').padStart(6, '_-');
     }
 
     {
         let result: _.LoDashExplicitWrapper<string>;
 
-        result = _('abc').chain().padLeft();
-        result = _('abc').chain().padLeft(6);
-        result = _('abc').chain().padLeft(6, '_-');
+        result = _('abc').chain().padStart();
+        result = _('abc').chain().padStart(6);
+        result = _('abc').chain().padStart(6, '_-');
     }
 }
 
-// _.padRight
-module TestPadRight {
+// _.padEnd
+module TestPadEnd {
     {
         let result: string;
 
-        result = _.padRight('abc');
-        result = _.padRight('abc', 6);
-        result = _.padRight('abc', 6, '_-');
+        result = _.padEnd('abc');
+        result = _.padEnd('abc', 6);
+        result = _.padEnd('abc', 6, '_-');
 
-        result = _('abc').padRight();
-        result = _('abc').padRight(6);
-        result = _('abc').padRight(6, '_-');
+        result = _('abc').padEnd();
+        result = _('abc').padEnd(6);
+        result = _('abc').padEnd(6, '_-');
     }
 
     {
         let result: _.LoDashExplicitWrapper<string>;
 
-        result = _('abc').chain().padRight();
-        result = _('abc').chain().padRight(6);
-        result = _('abc').chain().padRight(6, '_-');
+        result = _('abc').chain().padEnd();
+        result = _('abc').chain().padEnd(6);
+        result = _('abc').chain().padEnd(6, '_-');
     }
 }
 
@@ -9193,6 +9192,38 @@ module TestTemplate {
     }
 }
 
+// _.toLower
+module TestToLower {
+    {
+        let result: string;
+
+        result = _.toLower('fred, barney, &amp; pebbles');
+        result = _('fred, barney, &amp; pebbles').toLower();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('fred, barney, &amp; pebbles').chain().toLower();
+    }
+}
+
+// _.toUpper
+module TestToUpper {
+    {
+        let result: string;
+
+        result = _.toUpper('fred, barney, &amp; pebbles');
+        result = _('fred, barney, &amp; pebbles').toUpper();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('fred, barney, &amp; pebbles').chain().toUpper();
+    }
+}
+
 // _.trim
 module TestTrim {
     {
@@ -9214,75 +9245,106 @@ module TestTrim {
     }
 }
 
-// _.trimLeft
-module TestTrimLeft {
+// _.trimStart
+module TestTrimStart {
     {
         let result: string;
 
-        result = _.trimLeft();
-        result = _.trimLeft('  abc  ');
-        result = _.trimLeft('-_-abc-_-', '_-');
+        result = _.trimStart();
+        result = _.trimStart('  abc  ');
+        result = _.trimStart('-_-abc-_-', '_-');
 
-        result = _('-_-abc-_-').trimLeft();
-        result = _('-_-abc-_-').trimLeft('_-');
+        result = _('-_-abc-_-').trimStart();
+        result = _('-_-abc-_-').trimStart('_-');
     }
 
     {
         let result: _.LoDashExplicitWrapper<string>;
 
-        result = _('-_-abc-_-').chain().trimLeft();
-        result = _('-_-abc-_-').chain().trimLeft('_-');
+        result = _('-_-abc-_-').chain().trimStart();
+        result = _('-_-abc-_-').chain().trimStart('_-');
     }
 }
 
-// _.trimRight
-
-module TestTrimRight {
+// _.trimEnd
+module TestTrimEnd {
     {
         let result: string;
 
-        result = _.trimRight();
-        result = _.trimRight('  abc  ');
-        result = _.trimRight('-_-abc-_-', '_-');
+        result = _.trimEnd();
+        result = _.trimEnd('  abc  ');
+        result = _.trimEnd('-_-abc-_-', '_-');
 
-        result = _('-_-abc-_-').trimRight();
-        result = _('-_-abc-_-').trimRight('_-');
+        result = _('-_-abc-_-').trimEnd();
+        result = _('-_-abc-_-').trimEnd('_-');
     }
 
     {
         let result: _.LoDashExplicitWrapper<string>;
 
-        result = _('-_-abc-_-').chain().trimRight();
-        result = _('-_-abc-_-').chain().trimRight('_-');
+        result = _('-_-abc-_-').chain().trimEnd();
+        result = _('-_-abc-_-').chain().trimEnd('_-');
     }
 }
 
-// _.trunc
-module TestTrunc {
+// _.truncate
+module Testtruncate {
     {
         let result: string;
 
-        result = _.trunc('hi-diddly-ho there, neighborino');
-        result = _.trunc('hi-diddly-ho there, neighborino', 24);
-        result = _.trunc('hi-diddly-ho there, neighborino', { 'length': 24, 'separator': ' ' });
-        result = _.trunc('hi-diddly-ho there, neighborino', { 'length': 24, 'separator': /,? +/ });
-        result = _.trunc('hi-diddly-ho there, neighborino', { 'omission': ' […]' });
+        result = _.truncate('hi-diddly-ho there, neighborino');
+        result = _.truncate('hi-diddly-ho there, neighborino', 24);
+        result = _.truncate('hi-diddly-ho there, neighborino', { 'length': 24, 'separator': ' ' });
+        result = _.truncate('hi-diddly-ho there, neighborino', { 'length': 24, 'separator': /,? +/ });
+        result = _.truncate('hi-diddly-ho there, neighborino', { 'omission': ' […]' });
 
-        result = _('hi-diddly-ho there, neighborino').trunc();
-        result = _('hi-diddly-ho there, neighborino').trunc(24);
-        result = _('hi-diddly-ho there, neighborino').trunc({ 'length': 24, 'separator': ' ' });
-        result = _('hi-diddly-ho there, neighborino').trunc({ 'length': 24, 'separator': /,? +/ });
-        result = _('hi-diddly-ho there, neighborino').trunc({ 'omission': ' […]' });
+        result = _('hi-diddly-ho there, neighborino').truncate();
+        result = _('hi-diddly-ho there, neighborino').truncate(24);
+        result = _('hi-diddly-ho there, neighborino').truncate({ 'length': 24, 'separator': ' ' });
+        result = _('hi-diddly-ho there, neighborino').truncate({ 'length': 24, 'separator': /,? +/ });
+        result = _('hi-diddly-ho there, neighborino').truncate({ 'omission': ' […]' });
     }
 
     {
         let result: _.LoDashExplicitWrapper<string>;
 
-        result = _('hi-diddly-ho there, neighborino').chain().trunc();
-        result = _('hi-diddly-ho there, neighborino').chain().trunc(24);
-        result = _('hi-diddly-ho there, neighborino').chain().trunc({ 'length': 24, 'separator': ' ' });
-        result = _('hi-diddly-ho there, neighborino').chain().trunc({ 'length': 24, 'separator': /,? +/ });
-        result = _('hi-diddly-ho there, neighborino').chain().trunc({ 'omission': ' […]' });
+        result = _('hi-diddly-ho there, neighborino').chain().truncate();
+        result = _('hi-diddly-ho there, neighborino').chain().truncate(24);
+        result = _('hi-diddly-ho there, neighborino').chain().truncate({ 'length': 24, 'separator': ' ' });
+        result = _('hi-diddly-ho there, neighborino').chain().truncate({ 'length': 24, 'separator': /,? +/ });
+        result = _('hi-diddly-ho there, neighborino').chain().truncate({ 'omission': ' […]' });
+    }
+}
+
+// _.upperCase
+module TestUpperCase {
+    {
+        let result: string;
+
+        result = _.upperCase('fred, barney, &amp; pebbles');
+        result = _('fred, barney, &amp; pebbles').upperCase();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('fred, barney, &amp; pebbles').chain().upperCase();
+    }
+}
+
+// _.upperFirst
+module TestUpperFirst {
+    {
+        let result: string;
+
+        result = _.upperFirst('fred, barney, &amp; pebbles');
+        result = _('fred, barney, &amp; pebbles').upperFirst();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<string>;
+
+        result = _('fred, barney, &amp; pebbles').chain().upperFirst();
     }
 }
 
@@ -9344,72 +9406,6 @@ module TestAttempt {
     }
 }
 
-// _.callback
-module TestCallback {
-    {
-        let result: (...args: any[]) => TResult;
-
-        result = _.callback<TResult>(Function);
-        result = _.callback<TResult>(Function, any);
-    }
-
-    {
-        let result: (object: any) => TResult;
-
-        result = _.callback<TResult>('');
-        result = _.callback<TResult>('', any);
-    }
-
-    {
-        let result: (object: any) => boolean;
-
-        result = _.callback({});
-        result = _.callback({}, any);
-    }
-
-    {
-        let result: _.LoDashImplicitObjectWrapper<(...args: any[]) => TResult>;
-
-        result = _(Function).callback<TResult>();
-        result = _(Function).callback<TResult>(any);
-    }
-
-    {
-        let result: _.LoDashImplicitObjectWrapper<(object: any) => TResult>;
-
-        result = _('').callback<TResult>();
-        result = _('').callback<TResult>(any);
-    }
-
-    {
-        let result: _.LoDashImplicitObjectWrapper<(object: any) => boolean>;
-
-        result = _({}).callback();
-        result = _({}).callback(any);
-    }
-
-    {
-        let result: _.LoDashExplicitObjectWrapper<(...args: any[]) => TResult>;
-
-        result = _(Function).chain().callback<TResult>();
-        result = _(Function).chain().callback<TResult>(any);
-    }
-
-    {
-        let result: _.LoDashExplicitObjectWrapper<(object: any) => TResult>;
-
-        result = _('').chain().callback<TResult>();
-        result = _('').chain().callback<TResult>(any);
-    }
-
-    {
-        let result: _.LoDashExplicitObjectWrapper<(object: any) => boolean>;
-
-        result = _({}).chain().callback();
-        result = _({}).chain().callback(any);
-    }
-}
-
 // _.constant
 module TestConstant {
     {
@@ -9921,6 +9917,33 @@ module TestRange {
     }
 }
 
+// _.rangeRight
+module TestRangeRight {
+    {
+        let result: number[];
+
+        result = _.rangeRight(10);
+        result = _.rangeRight(1, 11);
+        result = _.rangeRight(0, 30, 5);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<number>;
+
+        result = _(10).rangeRight();
+        result = _(1).rangeRight(11);
+        result = _(0).rangeRight(30, 5);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<number>;
+
+        result = _(10).chain().rangeRight();
+        result = _(1).chain().rangeRight(11);
+        result = _(0).chain().rangeRight(30, 5);
+    }
+}
+
 // _.runInContext
 {
     let result: typeof _;
@@ -9973,6 +9996,29 @@ module TestTimes {
     }
 }
 
+// _.toPath
+module TestToPath {
+   {
+       let result: string[];
+       result = _.toPath(true);
+       result = _.toPath(1);
+       result = _.toPath('a');
+       result = _.toPath(["a"]);
+       result = _.toPath({});
+   }
+
+   {
+       let result: _.LoDashImplicitWrapper<string[]>;
+
+       result = _(true).toPath();
+       result = _(1).toPath();
+       result = _('a').toPath();
+       result = _([1]).toPath();
+       result = _<string>(["a"]).toPath();
+       result = _({}).toPath();
+   }
+}
+
 // _.uniqueId
 module TestUniqueId {
     {
@@ -9992,7 +10038,6 @@ module TestUniqueId {
 }
 
 result = <string>_.VERSION;
-result = <_.Support>_.support;
 result = <_.TemplateSettings>_.templateSettings;
 
 // _.partial & _.partialRight
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 9d42b9d5d..f9249d16b 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -3,6 +3,239 @@
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
+
+/**
+### 4.0.0 Changelog (https://github.com/lodash/lodash/wiki/Changelog)
+
+#### TODO:
+removed:
+- [x] Removed _.support
+- [x] Removed _.findWhere in favor of _.find with iteratee shorthand
+- [x] Removed _.where in favor of _.filter with iteratee shorthand
+- [x] Removed _.pluck in favor of _.map with iteratee shorthand
+
+renamed:
+- [x] Renamed _.first to _.head
+- [x] Renamed _.indexBy to _.keyBy
+- [x] Renamed _.invoke to _.invokeMap
+- [x] Renamed _.overArgs to _.overArgs
+- [x] Renamed _.padLeft & _.padRight to _.padStart & _.padEnd
+- [x] Renamed _.pairs to _.toPairs
+- [x] Renamed _.rest to _.tail
+- [x] Renamed _.restParam to _.rest
+- [x] Renamed _.sortByOrder to _.orderBy
+- [x] Renamed _.trimLeft & _.trimRight to _.trimStart & _.trimEnd
+- [x] Renamed _.trunc to _.truncate
+
+split:
+- [x] Split _.indexOf & _.lastIndexOf into _.sortedIndexOf & _.sortedLastIndexOf
+- [x] Split _.max & _.min into _.maxBy & _.minBy
+- [x] Split _.omit & _.pick into _.omitBy & _.pickBy
+- [x] Split _.sample into _.sampleSize
+- [x] Split _.sortedIndex into _.sortedIndexBy
+- [x] Split _.sortedLastIndex into _.sortedLastIndexBy
+- [x] Split _.uniq into _.sortedUniq, _.sortedUniqBy, & _.uniqBy
+
+changes:
+- [x] Absorbed _.sortByAll into _.sortBy
+- [x] Changed the category of _.at to “Object”
+- [x] Changed the category of _.bindAll to “Utility”
+- [x] Made _.capitalize uppercase the first character & lowercase the rest
+- [x] Made _.functions return only own method names
+
+
+added 23 array methods:
+- [x] _.concat
+- [x] _.differenceBy
+- [x] _.differenceWith
+- [x] _.flatMap
+- [x] _.fromPairs
+- [x] _.intersectionBy
+- [x] _.intersectionWith
+- [x] _.join
+- [x] _.pullAll
+- [x] _.pullAllBy
+- [x] _.reverse
+- [x] _.sortedIndexBy
+- [x] _.sortedIndexOf
+- [x] _.sortedLastIndexBy
+- [x] _.sortedLastIndexOf
+- [x] _.sortedUniq
+- [x] _.sortedUniqBy
+- [x] _.unionBy
+- [x] _.unionWith
+- [x] _.uniqBy
+- [x] _.uniqWith
+- [x] _.xorBy
+- [x] _.xorWith
+
+added 18 lang methods:
+- [x] _.cloneDeepWith
+- [x] _.cloneWith
+- [x] _.eq
+- [x] _.isArrayLike
+- [x] _.isArrayLikeObject
+- [x] _.isEqualWith
+- [x] _.isInteger
+- [x] _.isLength
+- [x] _.isMatchWith
+- [x] _.isNil
+- [x] _.isObjectLike
+- [x] _.isSafeInteger
+- [x] _.isSymbol
+- [x] _.toInteger
+- [x] _.toLength
+- [x] _.toNumber
+- [x] _.toSafeInteger
+- [x] _.toString
+
+added 13 object methods:
+- [x] _.assignIn
+- [x] _.assignInWith
+- [x] _.assignWith
+- [x] _.functionsIn
+- [x] _.hasIn
+- [x] _.mergeWith
+- [x] _.omitBy
+- [x] _.pickBy
+
+
+added 8 string methods:
+- [x] _.lowerCase
+- [x] _.lowerFirst
+- [x] _.upperCase
+- [x] _.upperFirst
+- [x] _.toLower
+- [x] _.toUpper
+
+added 8 utility methods:
+- [x] _.toPath
+
+added 4 math methods:
+- [x] _.maxBy
+- [x] _.mean
+- [x] _.minBy
+- [x] _.sumBy
+
+added 2 function methods:
+- [x] _.flip
+- [x] _.unary
+
+added 2 number methods:
+- [x] _.clamp
+- [x] _.subtract
+
+added collection method:
+- [x] _.sampleSize
+
+Added 3 aliases
+
+- [x] _.first as an alias of _.head
+
+Removed 17 aliases
+- [x] Removed aliase _.all
+- [x] Removed aliase _.any
+- [x] Removed aliase _.backflow
+- [x] Removed aliase _.callback
+- [x] Removed aliase _.collect
+- [x] Removed aliase _.compose
+- [x] Removed aliase _.contains
+- [x] Removed aliase _.detect
+- [x] Removed aliase _.foldl
+- [x] Removed aliase _.foldr
+- [x] Removed aliase _.include
+- [x] Removed aliase _.inject
+- [x] Removed aliase _.methods
+- [x] Removed aliase _.object
+- [x] Removed aliase _.run
+- [x] Removed aliase _.select
+- [x] Removed aliase _.unique
+
+Other changes
+- [x] Added support for array buffers to _.isEqual
+- [x] Added support for converting iterators to _.toArray
+- [x] Added support for deep paths to _.zipObject
+- [x] Changed UMD to export to window or self when available regardless of other exports
+- [x] Ensured debounce cancel clears args & thisArg references
+- [x] Ensured _.add, _.subtract, & _.sum don’t skip NaN values
+- [x] Ensured _.clone treats generators like functions
+- [x] Ensured _.clone produces clones with the source’s [[Prototype]]
+- [x] Ensured _.defaults assigns properties that shadow Object.prototype
+- [x] Ensured _.defaultsDeep doesn’t merge a string into an array
+- [x] Ensured _.defaultsDeep & _.merge don’t modify sources
+- [x] Ensured _.defaultsDeep works with circular references
+- [x] Ensured _.keys skips “length” on strict mode arguments objects in Safari 9
+- [x] Ensured _.merge doesn’t convert strings to arrays
+- [x] Ensured _.merge merges plain-objects onto non plain-objects
+- [x] Ensured _#plant resets iterator data of cloned sequences
+- [x] Ensured _.random swaps min & max if min is greater than max
+- [x] Ensured _.range preserves the sign of start of -0
+- [x] Ensured _.reduce & _.reduceRight use getIteratee in their array branch
+- [x] Fixed rounding issue with the precision param of _.floor
+
+** LATER **
+Misc:
+- [ ] Made _.forEach, _.forIn, _.forOwn, & _.times implicitly end a chain sequence
+- [ ] Removed thisArg params from most methods
+- [ ] Made “By” methods provide a single param to iteratees
+- [ ] Made _.words chainable by default
+- [ ] Removed isDeep params from _.clone & _.flatten
+- [ ] Removed _.bindAll support for binding all methods when no names are provided
+- [ ] Removed func-first param signature from _.before & _.after
+- [ ] _.extend as an alias of _.assignIn
+- [ ] _.extendWith as an alias of _.assignInWith
+- [ ] Added clear method to _.memoize.Cache
+- [ ] Added flush method to debounced & throttled functions
+- [ ] Added support for ES6 maps, sets, & symbols to _.clone, _.isEqual, & _.toArray
+- [ ] Enabled _.flow & _.flowRight to accept an array of functions
+- [ ] Ensured “Collection” methods treat functions as objects
+- [ ] Ensured _.assign, _.defaults, & _.merge coerce object values to objects
+- [ ] Ensured _.bindKey bound functions call object[key] when called with the new operator
+- [ ] Ensured _.isFunction returns true for generator functions
+- [ ] Ensured _.merge assigns typed arrays directly
+- [ ] Made _(...) an iterator & iterable
+- [ ] Made _.drop, _.take, & right forms coerce n of undefined to 0
+
+Methods:
+- [ ] _.concat
+- [ ] _.differenceBy
+- [ ] _.differenceWith
+- [ ] _.flatMap
+- [ ] _.fromPairs
+- [ ] _.intersectionBy
+- [ ] _.intersectionWith
+- [ ] _.join
+- [ ] _.pullAll
+- [ ] _.pullAllBy
+- [ ] _.reverse
+- [ ] _.sortedLastIndexOf
+- [ ] _.unionBy
+- [ ] _.unionWith
+- [ ] _.uniqWith
+- [ ] _.xorBy
+- [ ] _.xorWith
+- [ ] _.toString
+
+- [ ] _.invoke
+- [ ] _.setWith
+- [ ] _.toPairs
+- [ ] _.toPairsIn
+- [ ] _.unset
+
+- [ ] _.replace
+- [ ] _.split
+
+- [ ] _.cond
+- [ ] _.conforms
+- [ ] _.nthArg
+- [ ] _.over
+- [ ] _.overEvery
+- [ ] _.overSome
+- [ ] _.rangeRight
+
+- [ ] _.next
+*/
+
 declare var _: _.LoDashStatic;
 
 declare module _ {
@@ -20,7 +253,7 @@ declare module _ {
         * after, assign, bind, bindAll, bindKey, chain, chunk, compact, compose, concat, countBy,
         * createCallback, curry, debounce, defaults, defer, delay, difference, filter, flatten,
         * forEach, forEachRight, forIn, forInRight, forOwn, forOwnRight, functions, groupBy,
-        * indexBy, initial, intersection, invert, invoke, keys, map, max, memoize, merge, min,
+        * keyBy, initial, intersection, invert, invoke, keys, map, max, memoize, merge, min,
         * object, omit, once, pairs, partial, partialRight, pick, pluck, pull, push, range, reject,
         * remove, rest, reverse, sample, shuffle, slice, sort, sortBy, splice, tap, throttle, times,
         * toArray, transform, union, uniq, unshift, unzip, values, where, without, wrap, and zip
@@ -51,11 +284,6 @@ declare module _ {
         **/
         VERSION: string;
 
-        /**
-        * An object used to flag environments features.
-        **/
-        support: Support;
-
         /**
         * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby
         * (ERB). Change the following template settings to use alternative delimiters.
@@ -128,89 +356,6 @@ declare module _ {
         set(key: string, value: any): _.Dictionary<any>;
     }
 
-    /**
-    * An object used to flag environments features.
-    **/
-    interface Support {
-        /**
-        * Detect if an arguments object's [[Class]] is resolvable (all but Firefox < 4, IE < 9).
-        **/
-        argsClass: boolean;
-
-        /**
-        * Detect if arguments objects are Object objects (all but Narwhal and Opera < 10.5).
-        **/
-        argsObject: boolean;
-
-        /**
-        * Detect if name or message properties of Error.prototype are enumerable by default.
-        * (IE < 9, Safari < 5.1)
-        **/
-        enumErrorProps: boolean;
-
-        /**
-        * Detect if prototype properties are enumerable by default.
-        *
-        * Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1 (if the prototype or a property on the
-        * prototype has been set) incorrectly set the [[Enumerable]] value of a function’s prototype property to true.
-        **/
-        enumPrototypes: boolean;
-
-        /**
-        * Detect if Function#bind exists and is inferred to be fast (all but V8).
-        **/
-        fastBind: boolean;
-
-        /**
-        * Detect if functions can be decompiled by Function#toString (all but PS3 and older Opera
-        * mobile browsers & avoided in Windows 8 apps).
-        **/
-        funcDecomp: boolean;
-
-        /**
-        * Detect if Function#name is supported (all but IE).
-        **/
-        funcNames: boolean;
-
-        /**
-        * Detect if arguments object indexes are non-enumerable (Firefox < 4, IE < 9, PhantomJS,
-        * Safari < 5.1).
-        **/
-        nonEnumArgs: boolean;
-
-        /**
-        * Detect if properties shadowing those on Object.prototype are non-enumerable.
-        *
-        * In IE < 9 an objects own properties, shadowing non-enumerable ones, are made
-        * non-enumerable as well (a.k.a the JScript [[DontEnum]] bug).
-        **/
-        nonEnumShadows: boolean;
-
-        /**
-        * Detect if own properties are iterated after inherited properties (all but IE < 9).
-        **/
-        ownLast: boolean;
-
-        /**
-        * Detect if Array#shift and Array#splice augment array-like objects correctly.
-        *
-        * Firefox < 10, IE compatibility mode, and IE < 9 have buggy Array shift() and splice()
-        * functions that fail to remove the last element, value[0], of array-like objects even
-        * though the length property is set to 0. The shift() method is buggy in IE 8 compatibility
-        * mode, while splice() is buggy regardless of mode in IE < 9 and buggy in compatibility mode
-        * in IE 9.
-        **/
-        spliceObjects: boolean;
-
-        /**
-        * Detect lack of support for accessing string characters by index.
-        *
-        * IE < 8 can't access characters by index and IE 8 can only access characters by index on
-        * string literals.
-        **/
-        unindexedChars: boolean;
-    }
-
     interface LoDashWrapperBase<T, TWrapper> { }
 
     interface LoDashImplicitWrapperBase<T, TWrapper> extends LoDashWrapperBase<T, TWrapper> { }
@@ -334,6 +479,32 @@ declare module _ {
         compact<TResult>(): LoDashExplicitArrayWrapper<TResult>;
     }
 
+    //_.concat DUMMY
+    interface LoDashStatic {
+        /**
+         * Creates a new array concatenating `array` with any additional arrays
+         * and/or values.
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to concatenate.
+         * @param {...*} [values] The values to concatenate.
+         * @returns {Array} Returns the new concatenated array.
+         * @example
+         *
+         * var array = [1];
+         * var other = _.concat(array, 2, [3], [[4]]);
+         *
+         * console.log(other);
+         * // => [1, 2, 3, [4]]
+         *
+         * console.log(array);
+         * // => [1]
+         */
+         concat<T>(...values: (T[]|List<T>)[]) : T[];
+    }
+
     //_.difference
     interface LoDashStatic {
         /**
@@ -345,8 +516,8 @@ declare module _ {
          * @return Returns the new array of filtered values.
          */
         difference<T>(
-            array: T[]|List<T>,
-            ...values: (T[]|List<T>)[]
+            array: any[]|List<any>,
+            ...values: any[]
         ): T[];
     }
 
@@ -378,6 +549,54 @@ declare module _ {
         difference<TValue>(...values: (TValue[]|List<TValue>)[]): LoDashExplicitArrayWrapper<TValue>;
     }
 
+    //_.differenceBy DUMMY
+    interface LoDashStatic {
+        /**
+         * Creates an array of unique `array` values not included in the other
+         * provided arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+         * for equality comparisons.
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to inspect.
+         * @param {...Array} [values] The values to exclude.
+         * @returns {Array} Returns the new array of filtered values.
+         * @example
+         *
+         * _.difference([3, 2, 1], [4, 2]);
+         * // => [3, 1]
+         */
+        differenceBy(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
+    //_.differenceWith DUMMY
+    interface LoDashStatic {
+        /**
+         * Creates an array of unique `array` values not included in the other
+         * provided arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+         * for equality comparisons.
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to inspect.
+         * @param {...Array} [values] The values to exclude.
+         * @returns {Array} Returns the new array of filtered values.
+         * @example
+         *
+         * _.difference([3, 2, 1], [4, 2]);
+         * // => [3, 1]
+         */
+        differenceWith(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
     //_.drop
     interface LoDashStatic {
         /**
@@ -1113,27 +1332,22 @@ declare module _ {
 
     //_.first
     interface LoDashStatic {
-        /**
-         * Gets the first element of array.
-         *
-         * @alias _.head
-         *
-         * @param array The array to query.
-         * @return Returns the first element of array.
+		/**
+         * @see _.head
          */
         first<T>(array: List<T>): T;
     }
 
     interface LoDashImplicitArrayWrapper<T> {
         /**
-         * @see _.first
+         * @see _.head
          */
         first(): T;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
-         * @see _.first
+         * @see _.head
          */
         first<TResult>(): TResult;
     }
@@ -1141,6 +1355,34 @@ declare module _ {
     interface RecursiveArray<T> extends Array<T|RecursiveArray<T>> {}
     interface ListOfRecursiveArraysOrValues<T> extends List<T|RecursiveArray<T>> {}
 
+    //_.flatMap DUMMY
+    interface LoDashStatic {
+        /**
+         * Creates an array of flattened values by running each element in `array`
+         * through `iteratee` and concating its result to the other mapped values.
+         * The iteratee is invoked with three arguments: (value, index|key, array).
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to iterate over.
+         * @param {Function|Object|string} [iteratee=_.identity] The function invoked per iteration.
+         * @returns {Array} Returns the new array.
+         * @example
+         *
+         * function duplicate(n) {
+         *   return [n, n];
+         * }
+         *
+         * _.flatMap([1, 2], duplicate);
+         * // => [1, 1, 2, 2]
+         */
+        flatMap(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
     //_.flatten
     interface LoDashStatic {
         /**
@@ -1259,10 +1501,36 @@ declare module _ {
         flattenDeep<T>(): LoDashExplicitArrayWrapper<T>;
     }
 
+    //_.fromPairs DUMMY
+    interface LoDashStatic {
+        /**
+         * The inverse of `_.toPairs`; this method returns an object composed
+         * from key-value `pairs`.
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} pairs The key-value pairs.
+         * @returns {Object} Returns the new object.
+         * @example
+         *
+         * _.fromPairs([['fred', 30], ['barney', 40]]);
+         * // => { 'fred': 30, 'barney': 40 }
+         */
+        fromPairs(
+            array: any[]|List<any>
+        ): any[];
+    }
+
     //_.head
     interface LoDashStatic {
         /**
-         * @see _.first
+         * Gets the first element of array.
+         *
+         * @alias _.first
+         *
+         * @param array The array to query.
+         * @return Returns the first element of array.
          */
         head<T>(array: List<T>): T;
     }
@@ -1284,14 +1552,27 @@ declare module _ {
     //_.indexOf
     interface LoDashStatic {
         /**
-         * Gets the index at which the first occurrence of value is found in array using SameValueZero for equality
-         * comparisons. If fromIndex is negative, it’s used as the offset from the end of array. If array is sorted
-         * providing true for fromIndex performs a faster binary search.
+         * Gets the index at which the first occurrence of `value` is found in `array`
+         * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+         * for equality comparisons. If `fromIndex` is negative, it's used as the offset
+         * from the end of `array`. If `array` is sorted providing `true` for `fromIndex`
+         * performs a faster binary search.
          *
-         * @param array The array to search.
-         * @param value The value to search for.
-         * @param fromIndex The index to search from or true to perform a binary search on a sorted array.
-         * @return The index to search from or true to perform a binary search on a sorted array.
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to search.
+         * @param {*} value The value to search for.
+         * @param {number} [fromIndex=0] The index to search from.
+         * @returns {number} Returns the index of the matched value, else `-1`.
+         * @example
+         *
+         * _.indexOf([1, 2, 1, 2], 2);
+         * // => 1
+         *
+         * // using `fromIndex`
+         * _.indexOf([1, 2, 1, 2], 2, 2);
+         * // => 3
          */
         indexOf<T>(
             array: List<T>,
@@ -1340,6 +1621,227 @@ declare module _ {
         ): LoDashExplicitWrapper<number>;
     }
 
+    //_.intersectionBy DUMMY
+    interface LoDashStatic {
+        /**
+         * This method is like `_.intersection` except that it accepts `iteratee`
+         * which is invoked for each element of each `arrays` to generate the criterion
+         * by which uniqueness is computed. The iteratee is invoked with one argument: (value).
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {...Array} [arrays] The arrays to inspect.
+         * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+         * @returns {Array} Returns the new array of shared values.
+         * @example
+         *
+         * _.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
+         * // => [2.1]
+         *
+         * // using the `_.property` iteratee shorthand
+         * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
+         * // => [{ 'x': 1 }]
+         */
+        intersectionBy(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
+    //_.intersectionWith DUMMY
+    interface LoDashStatic {
+        /**
+         * This method is like `_.intersection` except that it accepts `comparator`
+         * which is invoked to compare elements of `arrays`. The comparator is invoked
+         * with two arguments: (arrVal, othVal).
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {...Array} [arrays] The arrays to inspect.
+         * @param {Function} [comparator] The comparator invoked per element.
+         * @returns {Array} Returns the new array of shared values.
+         * @example
+         *
+         * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+         * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
+         *
+         * _.intersectionWith(objects, others, _.isEqual);
+         * // => [{ 'x': 1, 'y': 2 }]
+         */
+        intersectionWith(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
+    //_.join DUMMY
+    interface LoDashStatic {
+        /**
+         * Converts all elements in `array` into a string separated by `separator`.
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to convert.
+         * @param {string} [separator=','] The element separator.
+         * @returns {string} Returns the joined string.
+         * @example
+         *
+         * _.join(['a', 'b', 'c'], '~');
+         * // => 'a~b~c'
+         */
+        join(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
+    //_.pullAll DUMMY
+    interface LoDashStatic {
+        /**
+         * This method is like `_.pull` except that it accepts an array of values to remove.
+         *
+         * **Note:** Unlike `_.difference`, this method mutates `array`.
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to modify.
+         * @param {Array} values The values to remove.
+         * @returns {Array} Returns `array`.
+         * @example
+         *
+         * var array = [1, 2, 3, 1, 2, 3];
+         *
+         * _.pull(array, [2, 3]);
+         * console.log(array);
+         * // => [1, 1]
+         */
+        pullAll(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
+    //_.pullAllBy DUMMY
+    interface LoDashStatic {
+        /**
+         * This method is like `_.pullAll` except that it accepts `iteratee` which is
+         * invoked for each element of `array` and `values` to to generate the criterion
+         * by which uniqueness is computed. The iteratee is invoked with one argument: (value).
+         *
+         * **Note:** Unlike `_.differenceBy`, this method mutates `array`.
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to modify.
+         * @param {Array} values The values to remove.
+         * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+         * @returns {Array} Returns `array`.
+         * @example
+         *
+         * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
+         *
+         * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
+         * console.log(array);
+         * // => [{ 'x': 2 }]
+         */
+        pullAllBy(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
+    //_.reverse DUMMY
+    interface LoDashStatic {
+        /**
+         * Reverses `array` so that the first element becomes the last, the second
+         * element becomes the second to last, and so on.
+         *
+         * **Note:** This method mutates `array` and is based on
+         * [`Array#reverse`](https://mdn.io/Array/reverse).
+         *
+         * @memberOf _
+         * @category Array
+         * @returns {Array} Returns `array`.
+         * @example
+         *
+         * var array = [1, 2, 3];
+         *
+         * _.reverse(array);
+         * // => [3, 2, 1]
+         *
+         * console.log(array);
+         * // => [3, 2, 1]
+         */
+        reverse(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
+    //_.sortedIndexOf
+    interface LoDashStatic {
+        /**
+         * This method is like `_.indexOf` except that it performs a binary
+         * search on a sorted `array`.
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to search.
+         * @param {*} value The value to search for.
+         * @returns {number} Returns the index of the matched value, else `-1`.
+         * @example
+         *
+         * _.sortedIndexOf([1, 1, 2, 2], 2);
+         * // => 2
+         */
+        sortedIndexOf<T>(
+            array: List<T>,
+            value: T
+        ): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedIndexOf
+         */
+        sortedIndexOf(
+            value: T
+        ): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedIndexOf
+         */
+        sortedIndexOf<TValue>(
+            value: TValue
+        ): number;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedIndexOf
+         */
+        sortedIndexOf(
+            value: T
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedIndexOf
+         */
+        sortedIndexOf<TValue>(
+            value: TValue
+        ): LoDashExplicitWrapper<number>;
+    }
+
     //_.initial
     interface LoDashStatic {
         /**
@@ -1515,125 +2017,6 @@ declare module _ {
         ): LoDashExplicitWrapper<number>;
     }
 
-    //_.object
-    interface LoDashStatic {
-        /**
-         * @see _.zipObject
-         */
-        object<TValues, TResult extends {}>(
-            props: List<StringRepresentable>|List<List<any>>,
-            values?: List<TValues>
-        ): TResult;
-
-        /**
-         * @see _.zipObject
-         */
-        object<TResult extends {}>(
-            props: List<StringRepresentable>|List<List<any>>,
-            values?: List<any>
-        ): TResult;
-
-        /**
-         * @see _.zipObject
-         */
-        object(
-            props: List<StringRepresentable>|List<List<any>>,
-            values?: List<any>
-        ): _.Dictionary<any>;
-    }
-
-    interface LoDashImplicitArrayWrapper<T> {
-        /**
-         * @see _.zipObject
-         */
-        object<TValues, TResult extends {}>(
-            values?: List<TValues>
-        ): _.LoDashImplicitObjectWrapper<TResult>;
-
-        /**
-         * @see _.zipObject
-         */
-        object<TResult extends {}>(
-            values?: List<any>
-        ): _.LoDashImplicitObjectWrapper<TResult>;
-
-        /**
-         * @see _.zipObject
-         */
-        object(
-            values?: List<any>
-        ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.zipObject
-         */
-        object<TValues, TResult extends {}>(
-            values?: List<TValues>
-        ): _.LoDashImplicitObjectWrapper<TResult>;
-
-        /**
-         * @see _.zipObject
-         */
-        object<TResult extends {}>(
-            values?: List<any>
-        ): _.LoDashImplicitObjectWrapper<TResult>;
-
-        /**
-         * @see _.zipObject
-         */
-        object(
-            values?: List<any>
-        ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
-    }
-
-    interface LoDashExplicitArrayWrapper<T> {
-        /**
-         * @see _.zipObject
-         */
-        object<TValues, TResult extends {}>(
-            values?: List<TValues>
-        ): _.LoDashExplicitObjectWrapper<TResult>;
-
-        /**
-         * @see _.zipObject
-         */
-        object<TResult extends {}>(
-            values?: List<any>
-        ): _.LoDashExplicitObjectWrapper<TResult>;
-
-        /**
-         * @see _.zipObject
-         */
-        object(
-            values?: List<any>
-        ): _.LoDashExplicitObjectWrapper<_.Dictionary<any>>;
-    }
-
-    interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.zipObject
-         */
-        object<TValues, TResult extends {}>(
-            values?: List<TValues>
-        ): _.LoDashExplicitObjectWrapper<TResult>;
-
-        /**
-         * @see _.zipObject
-         */
-        object<TResult extends {}>(
-            values?: List<any>
-        ): _.LoDashExplicitObjectWrapper<TResult>;
-
-        /**
-         * @see _.zipObject
-         */
-        object(
-            values?: List<any>
-        ): _.LoDashExplicitObjectWrapper<_.Dictionary<any>>;
-    }
-
     //_.pull
     interface LoDashStatic {
         /**
@@ -1879,7 +2262,7 @@ declare module _ {
         ): LoDashExplicitArrayWrapper<TResult>;
     }
 
-    //_.rest
+    //_.tail
     interface LoDashStatic {
         /**
          * Gets all but the first element of array.
@@ -1889,35 +2272,35 @@ declare module _ {
          * @param array The array to query.
          * @return Returns the slice of array.
          */
-        rest<T>(array: List<T>): T[];
+        tail<T>(array: List<T>): T[];
     }
 
     interface LoDashImplicitArrayWrapper<T> {
         /**
-         * @see _.rest
+         * @see _.tail
          */
-        rest(): LoDashImplicitArrayWrapper<T>;
+        tail(): LoDashImplicitArrayWrapper<T>;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
-         * @see _.rest
+         * @see _.tail
          */
-        rest<T>(): LoDashImplicitArrayWrapper<T>;
+        tail<T>(): LoDashImplicitArrayWrapper<T>;
     }
 
     interface LoDashExplicitArrayWrapper<T> {
         /**
-         * @see _.rest
+         * @see _.tail
          */
-        rest(): LoDashExplicitArrayWrapper<T>;
+        tail(): LoDashExplicitArrayWrapper<T>;
     }
 
     interface LoDashExplicitObjectWrapper<T> {
         /**
-         * @see _.rest
+         * @see _.tail
          */
-        rest<T>(): LoDashExplicitArrayWrapper<T>;
+        tail<T>(): LoDashExplicitArrayWrapper<T>;
     }
 
     //_.slice
@@ -1960,24 +2343,26 @@ declare module _ {
     //_.sortedIndex
     interface LoDashStatic {
         /**
-         * Uses a binary search to determine the lowest index at which value should be inserted into array in order to maintain its sort order. If an iteratee function is provided it’s invoked for value and each element of array to compute their sort ranking. The iteratee is bound to thisArg and invoked with one argument; (value).
+         * Uses a binary search to determine the lowest index at which `value` should
+         * be inserted into `array` in order to maintain its sort order.
          *
-         * If a property name is provided for iteratee the created _.property style callback returns the property value of the given element.
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The sorted array to inspect.
+         * @param {*} value The value to evaluate.
+         * @returns {number} Returns the index at which `value` should be inserted into `array`.
+         * @example
          *
-         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for elements that have a matching property value, else false.
+         * _.sortedIndex([30, 50], 40);
+         * // => 1
          *
-         * If an object is provided for iteratee the created _.matches style callback returns true for elements that have the properties of the given object, else false.
-         *
-         * @param array The sorted array to inspect.
-         * @param value The value to evaluate.
-         * @param iteratee The function invoked per iteration.
-         * @return The this binding of iteratee.
+         * _.sortedIndex([4, 5], 4);
+         * // => 0
          */
         sortedIndex<T, TSort>(
             array: List<T>,
-            value: T,
-            iteratee?: (x: T) => TSort,
-            thisArg?: any
+            value: T
         ): number;
 
         /**
@@ -1985,9 +2370,7 @@ declare module _ {
          */
         sortedIndex<T>(
             array: List<T>,
-            value: T,
-            iteratee?: (x: T) => any,
-            thisArg?: any
+            value: T
         ): number;
 
         /**
@@ -1995,8 +2378,7 @@ declare module _ {
          */
         sortedIndex<T>(
             array: List<T>,
-            value: T,
-            iteratee: string
+            value: T
         ): number;
 
         /**
@@ -2004,8 +2386,7 @@ declare module _ {
          */
         sortedIndex<W, T>(
             array: List<T>,
-            value: T,
-            iteratee: W
+            value: T
         ): number;
 
         /**
@@ -2013,8 +2394,7 @@ declare module _ {
          */
         sortedIndex<T>(
             array: List<T>,
-            value: T,
-            iteratee: Object
+            value: T
         ): number;
     }
 
@@ -2023,9 +2403,7 @@ declare module _ {
          * @see _.sortedIndex
          */
         sortedIndex<TSort>(
-            value: string,
-            iteratee?: (x: string) => TSort,
-            thisArg?: any
+            value: string
         ): number;
     }
 
@@ -2034,25 +2412,14 @@ declare module _ {
          * @see _.sortedIndex
          */
         sortedIndex<TSort>(
-            value: T,
-            iteratee?: (x: T) => TSort,
-            thisArg?: any
+            value: T
         ): number;
 
         /**
          * @see _.sortedIndex
          */
         sortedIndex(
-            value: T,
-            iteratee: string
-        ): number;
-
-        /**
-         * @see _.sortedIndex
-         */
-        sortedIndex<W>(
-            value: T,
-            iteratee: W
+            value: T
         ): number;
     }
 
@@ -2061,42 +2428,21 @@ declare module _ {
          * @see _.sortedIndex
          */
         sortedIndex<T, TSort>(
-            value: T,
-            iteratee?: (x: T) => TSort,
-            thisArg?: any
+            value: T
         ): number;
 
         /**
          * @see _.sortedIndex
          */
         sortedIndex<T>(
-            value: T,
-            iteratee?: (x: T) => any,
-            thisArg?: any
-        ): number;
-
-        /**
-         * @see _.sortedIndex
-         */
-        sortedIndex<T>(
-            value: T,
-            iteratee: string
+            value: T
         ): number;
 
         /**
          * @see _.sortedIndex
          */
         sortedIndex<W, T>(
-            value: T,
-            iteratee: W
-        ): number;
-
-        /**
-         * @see _.sortedIndex
-         */
-        sortedIndex<T>(
-            value: T,
-            iteratee: Object
+            value: T
         ): number;
     }
 
@@ -2105,9 +2451,7 @@ declare module _ {
          * @see _.sortedIndex
          */
         sortedIndex<TSort>(
-            value: string,
-            iteratee?: (x: string) => TSort,
-            thisArg?: any
+            value: string
         ): LoDashExplicitWrapper<number>;
     }
 
@@ -2116,25 +2460,21 @@ declare module _ {
          * @see _.sortedIndex
          */
         sortedIndex<TSort>(
-            value: T,
-            iteratee?: (x: T) => TSort,
-            thisArg?: any
+            value: T
         ): LoDashExplicitWrapper<number>;
 
         /**
          * @see _.sortedIndex
          */
         sortedIndex(
-            value: T,
-            iteratee: string
+            value: T
         ): LoDashExplicitWrapper<number>;
 
         /**
          * @see _.sortedIndex
          */
         sortedIndex<W>(
-            value: T,
-            iteratee: W
+            value: T
         ): LoDashExplicitWrapper<number>;
     }
 
@@ -2143,40 +2483,245 @@ declare module _ {
          * @see _.sortedIndex
          */
         sortedIndex<T, TSort>(
-            value: T,
-            iteratee?: (x: T) => TSort,
-            thisArg?: any
+            value: T
         ): LoDashExplicitWrapper<number>;
 
         /**
          * @see _.sortedIndex
          */
         sortedIndex<T>(
-            value: T,
-            iteratee?: (x: T) => any,
-            thisArg?: any
-        ): LoDashExplicitWrapper<number>;
-
-        /**
-         * @see _.sortedIndex
-         */
-        sortedIndex<T>(
-            value: T,
-            iteratee: string
+            value: T
         ): LoDashExplicitWrapper<number>;
 
         /**
          * @see _.sortedIndex
          */
         sortedIndex<W, T>(
+            value: T
+        ): LoDashExplicitWrapper<number>;
+
+
+    }
+
+    //_.sortedIndexBy
+    interface LoDashStatic {
+        /**
+         * This method is like `_.sortedIndex` except that it accepts `iteratee`
+         * which is invoked for `value` and each element of `array` to compute their
+         * sort ranking. The iteratee is invoked with one argument: (value).
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The sorted array to inspect.
+         * @param {*} value The value to evaluate.
+         * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+         * @returns {number} Returns the index at which `value` should be inserted into `array`.
+         * @example
+         *
+         * var dict = { 'thirty': 30, 'forty': 40, 'fifty': 50 };
+         *
+         * _.sortedIndexBy(['thirty', 'fifty'], 'forty', _.propertyOf(dict));
+         * // => 1
+         *
+         * // using the `_.property` iteratee shorthand
+         * _.sortedIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x');
+         * // => 0
+         */
+        sortedIndexBy<T, TSort>(
+            array: List<T>,
+            value: T,
+            iteratee: (x: T) => TSort
+        ): number;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<T>(
+            array: List<T>,
+            value: T,
+            iteratee: (x: T) => any
+        ): number;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<T>(
+            array: List<T>,
+            value: T,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<W, T>(
+            array: List<T>,
+            value: T,
+            iteratee: W
+        ): number;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<T>(
+            array: List<T>,
+            value: T,
+            iteratee: Object
+        ): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<TSort>(
+            value: string,
+            iteratee: (x: string) => TSort
+        ): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<TSort>(
+            value: T,
+            iteratee: (x: T) => TSort
+        ): number;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy(
+            value: T,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<W>(
+            value: T,
+            iteratee: W
+        ): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<T, TSort>(
+            value: T,
+            iteratee: (x: T) => TSort
+        ): number;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<T>(
+            value: T,
+            iteratee: (x: T) => any
+        ): number;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<T>(
+            value: T,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<W, T>(
+            value: T,
+            iteratee: W
+        ): number;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<T>(
+            value: T,
+            iteratee: Object
+        ): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<TSort>(
+            value: string,
+            iteratee: (x: string) => TSort
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<TSort>(
+            value: T,
+            iteratee: (x: T) => TSort
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy(
+            value: T,
+            iteratee: string
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<W>(
+            value: T,
+            iteratee: W
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<T, TSort>(
+            value: T,
+            iteratee: (x: T) => TSort
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<T>(
+            value: T,
+            iteratee: (x: T) => any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<T>(
+            value: T,
+            iteratee: string
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedIndexBy
+         */
+        sortedIndexBy<W, T>(
             value: T,
             iteratee: W
         ): LoDashExplicitWrapper<number>;
 
         /**
-         * @see _.sortedIndex
+         * @see _.sortedIndexBy
          */
-        sortedIndex<T>(
+        sortedIndexBy<T>(
             value: T,
             iteratee: Object
         ): LoDashExplicitWrapper<number>;
@@ -2185,20 +2730,24 @@ declare module _ {
     //_.sortedLastIndex
     interface LoDashStatic {
         /**
-         * This method is like _.sortedIndex except that it returns the highest index at which value should be
-         * inserted into array in order to maintain its sort order.
+         * This method is like `_.sortedIndex` except that it returns the highest
+         * index at which `value` should be inserted into `array` in order to
+         * maintain its sort order.
          *
-         * @param array The sorted array to inspect.
-         * @param value The value to evaluate.
-         * @param iteratee The function invoked per iteration.
-         * @param thisArg The this binding of iteratee.
-         * @return Returns the index at which value should be inserted into array.
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The sorted array to inspect.
+         * @param {*} value The value to evaluate.
+         * @returns {number} Returns the index at which `value` should be inserted into `array`.
+         * @example
+         *
+         * _.sortedLastIndex([4, 5], 4);
+         * // => 1
          */
         sortedLastIndex<T, TSort>(
             array: List<T>,
-            value: T,
-            iteratee?: (x: T) => TSort,
-            thisArg?: any
+            value: T
         ): number;
 
         /**
@@ -2206,9 +2755,7 @@ declare module _ {
          */
         sortedLastIndex<T>(
             array: List<T>,
-            value: T,
-            iteratee?: (x: T) => any,
-            thisArg?: any
+            value: T
         ): number;
 
         /**
@@ -2216,8 +2763,7 @@ declare module _ {
          */
         sortedLastIndex<T>(
             array: List<T>,
-            value: T,
-            iteratee: string
+            value: T
         ): number;
 
         /**
@@ -2225,8 +2771,7 @@ declare module _ {
          */
         sortedLastIndex<W, T>(
             array: List<T>,
-            value: T,
-            iteratee: W
+            value: T
         ): number;
 
         /**
@@ -2234,8 +2779,7 @@ declare module _ {
          */
         sortedLastIndex<T>(
             array: List<T>,
-            value: T,
-            iteratee: Object
+            value: T
         ): number;
     }
 
@@ -2244,9 +2788,7 @@ declare module _ {
          * @see _.sortedLastIndex
          */
         sortedLastIndex<TSort>(
-            value: string,
-            iteratee?: (x: string) => TSort,
-            thisArg?: any
+            value: string
         ): number;
     }
 
@@ -2255,25 +2797,21 @@ declare module _ {
          * @see _.sortedLastIndex
          */
         sortedLastIndex<TSort>(
-            value: T,
-            iteratee?: (x: T) => TSort,
-            thisArg?: any
+            value: T
         ): number;
 
         /**
          * @see _.sortedLastIndex
          */
         sortedLastIndex(
-            value: T,
-            iteratee: string
+            value: T
         ): number;
 
         /**
          * @see _.sortedLastIndex
          */
         sortedLastIndex<W>(
-            value: T,
-            iteratee: W
+            value: T
         ): number;
     }
 
@@ -2282,42 +2820,21 @@ declare module _ {
          * @see _.sortedLastIndex
          */
         sortedLastIndex<T, TSort>(
-            value: T,
-            iteratee?: (x: T) => TSort,
-            thisArg?: any
+            value: T
         ): number;
 
         /**
          * @see _.sortedLastIndex
          */
         sortedLastIndex<T>(
-            value: T,
-            iteratee?: (x: T) => any,
-            thisArg?: any
-        ): number;
-
-        /**
-         * @see _.sortedLastIndex
-         */
-        sortedLastIndex<T>(
-            value: T,
-            iteratee: string
+            value: T
         ): number;
 
         /**
          * @see _.sortedLastIndex
          */
         sortedLastIndex<W, T>(
-            value: T,
-            iteratee: W
-        ): number;
-
-        /**
-         * @see _.sortedLastIndex
-         */
-        sortedLastIndex<T>(
-            value: T,
-            iteratee: Object
+            value: T
         ): number;
     }
 
@@ -2326,9 +2843,7 @@ declare module _ {
          * @see _.sortedLastIndex
          */
         sortedLastIndex<TSort>(
-            value: string,
-            iteratee?: (x: string) => TSort,
-            thisArg?: any
+            value: string
         ): LoDashExplicitWrapper<number>;
     }
 
@@ -2337,25 +2852,14 @@ declare module _ {
          * @see _.sortedLastIndex
          */
         sortedLastIndex<TSort>(
-            value: T,
-            iteratee?: (x: T) => TSort,
-            thisArg?: any
+            value: T
         ): LoDashExplicitWrapper<number>;
 
         /**
          * @see _.sortedLastIndex
          */
         sortedLastIndex(
-            value: T,
-            iteratee: string
-        ): LoDashExplicitWrapper<number>;
-
-        /**
-         * @see _.sortedLastIndex
-         */
-        sortedLastIndex<W>(
-            value: T,
-            iteratee: W
+            value: T
         ): LoDashExplicitWrapper<number>;
     }
 
@@ -2364,45 +2868,266 @@ declare module _ {
          * @see _.sortedLastIndex
          */
         sortedLastIndex<T, TSort>(
-            value: T,
-            iteratee?: (x: T) => TSort,
-            thisArg?: any
+            value: T
         ): LoDashExplicitWrapper<number>;
 
         /**
          * @see _.sortedLastIndex
          */
         sortedLastIndex<T>(
-            value: T,
-            iteratee?: (x: T) => any,
-            thisArg?: any
-        ): LoDashExplicitWrapper<number>;
-
-        /**
-         * @see _.sortedLastIndex
-         */
-        sortedLastIndex<T>(
-            value: T,
-            iteratee: string
+            value: T
         ): LoDashExplicitWrapper<number>;
 
         /**
          * @see _.sortedLastIndex
          */
         sortedLastIndex<W, T>(
+            value: T
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    //_.sortedLastIndexBy
+    interface LoDashStatic {
+        /**
+         * This method is like `_.sortedLastIndex` except that it accepts `iteratee`
+         * which is invoked for `value` and each element of `array` to compute their
+         * sort ranking. The iteratee is invoked with one argument: (value).
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The sorted array to inspect.
+         * @param {*} value The value to evaluate.
+         * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+         * @returns {number} Returns the index at which `value` should be inserted into `array`.
+         * @example
+         *
+         * // using the `_.property` iteratee shorthand
+         * _.sortedLastIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x');
+         * // => 1
+         */
+        sortedLastIndexBy<T, TSort>(
+            array: List<T>,
+            value: T,
+            iteratee: (x: T) => TSort
+        ): number;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<T>(
+            array: List<T>,
+            value: T,
+            iteratee: (x: T) => any
+        ): number;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<T>(
+            array: List<T>,
+            value: T,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<W, T>(
+            array: List<T>,
+            value: T,
+            iteratee: W
+        ): number;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<T>(
+            array: List<T>,
+            value: T,
+            iteratee: Object
+        ): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<TSort>(
+            value: string,
+            iteratee: (x: string) => TSort
+        ): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<TSort>(
+            value: T,
+            iteratee: (x: T) => TSort
+        ): number;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy(
+            value: T,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<W>(
+            value: T,
+            iteratee: W
+        ): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<T, TSort>(
+            value: T,
+            iteratee: (x: T) => TSort
+        ): number;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<T>(
+            value: T,
+            iteratee: (x: T) => any
+        ): number;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<T>(
+            value: T,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<W, T>(
+            value: T,
+            iteratee: W
+        ): number;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<T>(
+            value: T,
+            iteratee: Object
+        ): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<TSort>(
+            value: string,
+            iteratee: (x: string) => TSort
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<TSort>(
+            value: T,
+            iteratee: (x: T) => TSort
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy(
+            value: T,
+            iteratee: string
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<W>(
+            value: T,
+            iteratee: W
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<T, TSort>(
+            value: T,
+            iteratee: (x: T) => TSort
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<T>(
+            value: T,
+            iteratee: (x: T) => any
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<T>(
+            value: T,
+            iteratee: string
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sortedLastIndexBy
+         */
+        sortedLastIndexBy<W, T>(
             value: T,
             iteratee: W
         ): LoDashExplicitWrapper<number>;
 
         /**
-         * @see _.sortedLastIndex
+         * @see _.sortedLastIndexBy
          */
-        sortedLastIndex<T>(
+        sortedLastIndexBy<T>(
             value: T,
             iteratee: Object
         ): LoDashExplicitWrapper<number>;
     }
 
+    //_.sortedLastIndexOf DUMMY
+    interface LoDashStatic {
+        /**
+         * This method is like `_.lastIndexOf` except that it performs a binary
+         * search on a sorted `array`.
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to search.
+         * @param {*} value The value to search for.
+         * @returns {number} Returns the index of the matched value, else `-1`.
+         * @example
+         *
+         * _.sortedLastIndexOf([1, 1, 2, 2], 2);
+         * // => 3
+         */
+        sortedLastIndexOf(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
     //_.tail
     interface LoDashStatic {
         /**
@@ -2866,115 +3591,30 @@ declare module _ {
     //_.uniq
     interface LoDashStatic {
         /**
-         * Creates a duplicate-free version of an array, using SameValueZero for equality comparisons, in which only
-         * the first occurrence of each element is kept. Providing true for isSorted performs a faster search
-         * algorithm for sorted arrays. If an iteratee function is provided it’s invoked for each element in the
-         * array to generate the criterion by which uniqueness is computed. The iteratee is bound to thisArg and
-         * invoked with three arguments: (value, index, array).
+         * Creates a duplicate-free version of an array, using
+         * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+         * for equality comparisons, in which only the first occurrence of each element
+         * is kept.
          *
-         * If a property name is provided for iteratee the created _.property style callback returns the property
-         * value of the given element.
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to inspect.
+         * @returns {Array} Returns the new duplicate free array.
+         * @example
          *
-         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
-         * elements that have a matching property value, else false.
-         *
-         * If an object is provided for iteratee the created _.matches style callback returns true for elements that
-         * have the properties of the given object, else false.
-         *
-         * @alias _.unique
-         *
-         * @param array The array to inspect.
-         * @param isSorted Specify the array is sorted.
-         * @param iteratee The function invoked per iteration.
-         * @param thisArg iteratee
-         * @return Returns the new duplicate-value-free array.
+         * _.uniq([2, 1, 2]);
+         * // => [2, 1]
          */
         uniq<T>(
-            array: List<T>,
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
+            array: List<T>
         ): T[];
 
         /**
          * @see _.uniq
          */
         uniq<T, TSort>(
-            array: List<T>,
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            array: List<T>,
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T, TSort>(
-            array: List<T>,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            array: List<T>,
-            isSorted?: boolean,
-            iteratee?: string,
-            thisArg?: any
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            array: List<T>,
-            iteratee?: string,
-            thisArg?: any
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            array: List<T>,
-            isSorted?: boolean,
-            iteratee?: Object
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        uniq<TWhere extends {}, T>(
-            array: List<T>,
-            isSorted?: boolean,
-            iteratee?: TWhere
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            array: List<T>,
-            iteratee?: Object
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        uniq<TWhere extends {}, T>(
-            array: List<T>,
-            iteratee?: TWhere
+            array: List<T>
         ): T[];
     }
 
@@ -2982,694 +3622,618 @@ declare module _ {
         /**
          * @see _.uniq
          */
-        uniq<TSort>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
+        uniq<TSort>(): LoDashImplicitArrayWrapper<T>;
     }
 
     interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.uniq
          */
-        uniq<TSort>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
+        uniq<TSort>(): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.uniq
          */
-        uniq<TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq(
-            isSorted?: boolean,
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq(
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<TWhere extends {}>(
-            isSorted?: boolean,
-            iteratee?: TWhere
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<TWhere extends {}>(
-            iteratee?: TWhere
-        ): LoDashImplicitArrayWrapper<T>;
+        uniq(): LoDashImplicitArrayWrapper<T>;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
-        uniq<T>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
+        uniq<T>(): LoDashImplicitArrayWrapper<T>;
 
         /**
          * @see _.uniq
          */
-        uniq<T, TSort>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T, TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            isSorted?: boolean,
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            isSorted?: boolean,
-            iteratee?: Object
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<TWhere extends {}, T>(
-            isSorted?: boolean,
-            iteratee?: TWhere
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            iteratee?: Object
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<TWhere extends {}, T>(
-            iteratee?: TWhere
-        ): LoDashImplicitArrayWrapper<T>;
+        uniq<T, TSort>(): LoDashImplicitArrayWrapper<T>;
     }
 
     interface LoDashExplicitWrapper<T> {
         /**
          * @see _.uniq
          */
-        uniq<TSort>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
+        uniq<TSort>(): LoDashExplicitArrayWrapper<T>;
     }
 
     interface LoDashExplicitArrayWrapper<T> {
         /**
          * @see _.uniq
          */
-        uniq<TSort>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
+        uniq<TSort>(): LoDashExplicitArrayWrapper<T>;
 
         /**
          * @see _.uniq
          */
-        uniq<TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq(
-            isSorted?: boolean,
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq(
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<TWhere extends {}>(
-            isSorted?: boolean,
-            iteratee?: TWhere
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<TWhere extends {}>(
-            iteratee?: TWhere
-        ): LoDashExplicitArrayWrapper<T>;
+        uniq(): LoDashExplicitArrayWrapper<T>;
     }
 
     interface LoDashExplicitObjectWrapper<T> {
-        uniq<T>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(): LoDashExplicitArrayWrapper<T>;
 
         /**
          * @see _.uniq
          */
-        uniq<T, TSort>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T, TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            isSorted?: boolean,
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            isSorted?: boolean,
-            iteratee?: Object
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<TWhere extends {}, T>(
-            isSorted?: boolean,
-            iteratee?: TWhere
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(
-            iteratee?: Object
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        uniq<TWhere extends {}, T>(
-            iteratee?: TWhere
-        ): LoDashExplicitArrayWrapper<T>;
+        uniq<T, TSort>(): LoDashExplicitArrayWrapper<T>;
     }
 
-    //_.unique
+    //_.uniqBy
     interface LoDashStatic {
         /**
-         * @see _.uniq
+         * This method is like `_.uniq` except that it accepts `iteratee` which is
+         * invoked for each element in `array` to generate the criterion by which
+         * uniqueness is computed. The iteratee is invoked with one argument: (value).
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to inspect.
+         * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+         * @returns {Array} Returns the new duplicate free array.
+         * @example
+         *
+         * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
+         * // => [2.1, 1.2]
+         *
+         * // using the `_.property` iteratee shorthand
+         * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+         * // => [{ 'x': 1 }, { 'x': 2 }]
          */
-        unique<T>(
+        uniqBy<T>(
             array: List<T>,
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
+            iteratee: ListIterator<T, any>
         ): T[];
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<T, TSort>(
+        uniqBy<T, TSort>(
             array: List<T>,
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+            iteratee: ListIterator<T, TSort>
         ): T[];
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<T>(
+        uniqBy<T>(
             array: List<T>,
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
+            iteratee: string
         ): T[];
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<T, TSort>(
+        uniqBy<T>(
             array: List<T>,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+            iteratee: Object
         ): T[];
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<T>(
+        uniqBy<TWhere extends {}, T>(
             array: List<T>,
-            isSorted?: boolean,
-            iteratee?: string,
-            thisArg?: any
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        unique<T>(
-            array: List<T>,
-            iteratee?: string,
-            thisArg?: any
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        unique<T>(
-            array: List<T>,
-            isSorted?: boolean,
-            iteratee?: Object
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        unique<TWhere extends {}, T>(
-            array: List<T>,
-            isSorted?: boolean,
-            iteratee?: TWhere
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        unique<T>(
-            array: List<T>,
-            iteratee?: Object
-        ): T[];
-
-        /**
-         * @see _.uniq
-         */
-        unique<TWhere extends {}, T>(
-            array: List<T>,
-            iteratee?: TWhere
+            iteratee: TWhere
         ): T[];
     }
 
     interface LoDashImplicitWrapper<T> {
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<TSort>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique<TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+        uniqBy<TSort>(
+            iteratee: ListIterator<T, TSort>
         ): LoDashImplicitArrayWrapper<T>;
     }
 
     interface LoDashImplicitArrayWrapper<T> {
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<TSort>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+        uniqBy<TSort>(
+            iteratee: ListIterator<T, TSort>
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+        uniqBy(
+            iteratee: string
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique(
-            isSorted?: boolean,
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique(
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique<TWhere extends {}>(
-            isSorted?: boolean,
-            iteratee?: TWhere
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique<TWhere extends {}>(
-            iteratee?: TWhere
+        uniqBy<TWhere extends {}>(
+            iteratee: TWhere
         ): LoDashImplicitArrayWrapper<T>;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
-        unique<T>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
+        /**
+         * @see _.uniqBy
+         */
+        uniqBy<T>(
+            iteratee: ListIterator<T, any>
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<T, TSort>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+        uniqBy<T, TSort>(
+            iteratee: ListIterator<T, TSort>
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<T>(
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
+        uniqBy<T>(
+            iteratee: string
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<T, TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+        uniqBy<T>(
+            iteratee: Object
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<T>(
-            isSorted?: boolean,
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique<T>(
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique<T>(
-            isSorted?: boolean,
-            iteratee?: Object
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique<TWhere extends {}, T>(
-            isSorted?: boolean,
-            iteratee?: TWhere
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique<T>(
-            iteratee?: Object
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique<TWhere extends {}, T>(
-            iteratee?: TWhere
+        uniqBy<TWhere extends {}, T>(
+            iteratee: TWhere
         ): LoDashImplicitArrayWrapper<T>;
     }
 
     interface LoDashExplicitWrapper<T> {
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<TSort>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique<TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+        uniqBy<TSort>(
+            iteratee: ListIterator<T, TSort>
         ): LoDashExplicitArrayWrapper<T>;
     }
 
     interface LoDashExplicitArrayWrapper<T> {
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<TSort>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+        uniqBy<TSort>(
+            iteratee: ListIterator<T, TSort>
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+        uniqBy(
+            iteratee: string
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique(
-            isSorted?: boolean,
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique(
-            iteratee?: string,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique<TWhere extends {}>(
-            isSorted?: boolean,
-            iteratee?: TWhere
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.uniq
-         */
-        unique<TWhere extends {}>(
-            iteratee?: TWhere
+        uniqBy<TWhere extends {}>(
+            iteratee: TWhere
         ): LoDashExplicitArrayWrapper<T>;
     }
 
     interface LoDashExplicitObjectWrapper<T> {
-        unique<T>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
+        /**
+         * @see _.uniqBy
+         */
+        uniqBy<T>(
+            iteratee: ListIterator<T, any>
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<T, TSort>(
-            isSorted?: boolean,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+        uniqBy<T, TSort>(
+            iteratee: ListIterator<T, TSort>
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<T>(
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
+        uniqBy<T>(
+            iteratee: string
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<T, TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+        uniqBy<T>(
+            iteratee: Object
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.uniqBy
          */
-        unique<T>(
-            isSorted?: boolean,
-            iteratee?: string,
-            thisArg?: any
+        uniqBy<TWhere extends {}, T>(
+            iteratee: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.sortedUniq
+    interface LoDashStatic {
+        /**
+         * This method is like `_.uniq` except that it's designed and optimized
+         * for sorted arrays.
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to inspect.
+         * @returns {Array} Returns the new duplicate free array.
+         * @example
+         *
+         * _.sortedUniq([1, 1, 2]);
+         * // => [1, 2]
+         */
+        sortedUniq<T>(
+            array: List<T>
+        ): T[];
+
+        /**
+         * @see _.sortedUniq
+         */
+        sortedUniq<T, TSort>(
+            array: List<T>
+        ): T[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.sortedUniq
+         */
+        sortedUniq<TSort>(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedUniq
+         */
+        sortedUniq<TSort>(): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortedUniq
+         */
+        sortedUniq(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        sortedUniq<T>(): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortedUniq
+         */
+        sortedUniq<T, TSort>(): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.sortedUniq
+         */
+        sortedUniq<TSort>(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedUniq
+         */
+        sortedUniq<TSort>(): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortedUniq
+         */
+        sortedUniq(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedUniq
+         */
+        sortedUniq<T>(): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortedUniq
+         */
+        sortedUniq<T, TSort>(): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.sortedUniqBy
+    interface LoDashStatic {
+        /**
+         * This method is like `_.uniqBy` except that it's designed and optimized
+         * for sorted arrays.
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to inspect.
+         * @param {Function} [iteratee] The iteratee invoked per element.
+         * @returns {Array} Returns the new duplicate free array.
+         * @example
+         *
+         * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
+         * // => [1.1, 2.2]
+         */
+        sortedUniqBy<T>(
+            array: List<T>,
+            iteratee: ListIterator<T, any>
+        ): T[];
+
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<T, TSort>(
+            array: List<T>,
+            iteratee: ListIterator<T, TSort>
+        ): T[];
+
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<T>(
+            array: List<T>,
+            iteratee: string
+        ): T[];
+
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<T>(
+            array: List<T>,
+            iteratee: Object
+        ): T[];
+
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<TWhere extends {}, T>(
+            array: List<T>,
+            iteratee: TWhere
+        ): T[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<TSort>(
+            iteratee: ListIterator<T, TSort>
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<TSort>(
+            iteratee: ListIterator<T, TSort>
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy(
+            iteratee: string
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<TWhere extends {}>(
+            iteratee: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<T>(
+            iteratee: ListIterator<T, any>
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<T, TSort>(
+            iteratee: ListIterator<T, TSort>
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<T>(
+            iteratee: string
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<T>(
+            iteratee: Object
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<TWhere extends {}, T>(
+            iteratee: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<TSort>(
+            iteratee: ListIterator<T, TSort>
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<TSort>(
+            iteratee: ListIterator<T, TSort>
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.sortedUniqBy
          */
-        unique<T>(
-            iteratee?: string,
-            thisArg?: any
+        sortedUniqBy(
+            iteratee: string
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.sortedUniqBy
          */
-        unique<T>(
-            isSorted?: boolean,
-            iteratee?: Object
+        sortedUniqBy<TWhere extends {}>(
+            iteratee: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<T>(
+            iteratee: ListIterator<T, any>
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.sortedUniqBy
          */
-        unique<TWhere extends {}, T>(
-            isSorted?: boolean,
-            iteratee?: TWhere
+        sortedUniqBy<T, TSort>(
+            iteratee: ListIterator<T, TSort>
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.sortedUniqBy
          */
-        unique<T>(
-            iteratee?: Object
+        sortedUniqBy<T>(
+            iteratee: string
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.uniq
+         * @see _.sortedUniqBy
          */
-        unique<TWhere extends {}, T>(
-            iteratee?: TWhere
+        sortedUniqBy<T>(
+            iteratee: Object
         ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortedUniqBy
+         */
+        sortedUniqBy<TWhere extends {}, T>(
+            iteratee: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.unionBy DUMMY
+    interface LoDashStatic {
+        /**
+         * This method is like `_.union` except that it accepts `iteratee` which is
+         * invoked for each element of each `arrays` to generate the criterion by which
+         * uniqueness is computed. The iteratee is invoked with one argument: (value).
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {...Array} [arrays] The arrays to inspect.
+         * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+         * @returns {Array} Returns the new array of combined values.
+         * @example
+         *
+         * _.unionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
+         * // => [2.1, 1.2, 4.3]
+         *
+         * // using the `_.property` iteratee shorthand
+         * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
+         * // => [{ 'x': 1 }, { 'x': 2 }]
+         */
+        unionBy(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
+    //_.unionWith DUMMY
+    interface LoDashStatic {
+        /**
+         * This method is like `_.union` except that it accepts `comparator` which
+         * is invoked to compare elements of `arrays`. The comparator is invoked
+         * with two arguments: (arrVal, othVal).
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {...Array} [arrays] The arrays to inspect.
+         * @param {Function} [comparator] The comparator invoked per element.
+         * @returns {Array} Returns the new array of combined values.
+         * @example
+         *
+         * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+         * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
+         *
+         * _.unionWith(objects, others, _.isEqual);
+         * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
+         */
+        unionWith(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
+    //_.uniqWith DUMMY
+    interface LoDashStatic {
+        /**
+         * This method is like `_.uniq` except that it accepts `comparator` which
+         * is invoked to compare elements of `array`. The comparator is invoked with
+         * two arguments: (arrVal, othVal).
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {Array} array The array to inspect.
+         * @param {Function} [comparator] The comparator invoked per element.
+         * @returns {Array} Returns the new duplicate free array.
+         * @example
+         *
+         * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 },  { 'x': 1, 'y': 2 }];
+         *
+         * _.uniqWith(objects, _.isEqual);
+         * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
+         */
+        uniqWith(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
     }
 
     //_.unzip
@@ -3833,6 +4397,61 @@ declare module _ {
         xor<T>(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>;
     }
 
+    //_.xorBy DUMMY
+    interface LoDashStatic {
+        /**
+         * This method is like `_.xor` except that it accepts `iteratee` which is
+         * invoked for each element of each `arrays` to generate the criterion by which
+         * uniqueness is computed. The iteratee is invoked with one argument: (value).
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {...Array} [arrays] The arrays to inspect.
+         * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+         * @returns {Array} Returns the new array of values.
+         * @example
+         *
+         * _.xorBy([2.1, 1.2], [4.3, 2.4], Math.floor);
+         * // => [1.2, 4.3]
+         *
+         * // using the `_.property` iteratee shorthand
+         * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
+         * // => [{ 'x': 2 }]
+         */
+        xorBy(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
+    //_.xorWith DUMMY
+    interface LoDashStatic {
+        /**
+         * This method is like `_.xor` except that it accepts `comparator` which is
+         * invoked to compare elements of `arrays`. The comparator is invoked with
+         * two arguments: (arrVal, othVal).
+         *
+         * @static
+         * @memberOf _
+         * @category Array
+         * @param {...Array} [arrays] The arrays to inspect.
+         * @param {Function} [comparator] The comparator invoked per element.
+         * @returns {Array} Returns the new array of values.
+         * @example
+         *
+         * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+         * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
+         *
+         * _.xorWith(objects, others, _.isEqual);
+         * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
+         */
+        xorWith(
+            array: any[]|List<any>,
+            ...values: any[]
+        ): any[];
+    }
+
     //_.zip
     interface LoDashStatic {
         /**
@@ -3880,8 +4499,6 @@ declare module _ {
          * Provide either a single two dimensional array, e.g. [[key1, value1], [key2, value2]] or two arrays, one of
          * property names and one of corresponding values.
          *
-         * @alias _.object
-         *
          * @param props The property names.
          * @param values The property values.
          * @return Returns the new object.
@@ -4346,14 +4963,6 @@ declare module _ {
         reverse(): LoDashExplicitArrayWrapper<T>;
     }
 
-    //_.prototype.run
-    interface LoDashWrapperBase<T, TWrapper> {
-        /**
-         * @see _.value
-         */
-        run(): T;
-    }
-
     //_.prototype.toJSON
     interface LoDashWrapperBase<T, TWrapper> {
         /**
@@ -4377,7 +4986,7 @@ declare module _ {
         /**
          * Executes the chained sequence to extract the unwrapped value.
          *
-         * @alias _.run, _.toJSON, _.valueOf
+         * @alias _.toJSON, _.valueOf
          *
          * @return Returns the resolved unwrapped value.
          */
@@ -4396,291 +5005,6 @@ declare module _ {
      * Collection *
      **************/
 
-    //_.all
-    interface LoDashStatic {
-        /**
-         * @see _.every
-         */
-        all<T>(
-            collection: List<T>,
-            predicate?: ListIterator<T, boolean>,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.every
-         */
-        all<T>(
-            collection: Dictionary<T>,
-            predicate?: DictionaryIterator<T, boolean>,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.every
-         */
-        all<T>(
-            collection: List<T>|Dictionary<T>,
-            predicate?: string,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.every
-         */
-        all<TObject extends {}, T>(
-            collection: List<T>|Dictionary<T>,
-            predicate?: TObject
-        ): boolean;
-    }
-
-    interface LoDashImplicitArrayWrapper<T> {
-        /**
-         * @see _.every
-         */
-        all(
-            predicate?: ListIterator<T, boolean>,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.every
-         */
-        all(
-            predicate?: string,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.every
-         */
-        all<TObject extends {}>(
-            predicate?: TObject
-        ): boolean;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.every
-         */
-        all<TResult>(
-            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.every
-         */
-        all(
-            predicate?: string,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.every
-         */
-        all<TObject extends {}>(
-            predicate?: TObject
-        ): boolean;
-    }
-
-    interface LoDashExplicitArrayWrapper<T> {
-        /**
-         * @see _.every
-         */
-        all(
-            predicate?: ListIterator<T, boolean>,
-            thisArg?: any
-        ): LoDashExplicitWrapper<boolean>;
-
-        /**
-         * @see _.every
-         */
-        all(
-            predicate?: string,
-            thisArg?: any
-        ): LoDashExplicitWrapper<boolean>;
-
-        /**
-         * @see _.every
-         */
-        all<TObject extends {}>(
-            predicate?: TObject
-        ): LoDashExplicitWrapper<boolean>;
-    }
-
-    interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.every
-         */
-        all<TResult>(
-            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>,
-            thisArg?: any
-        ): LoDashExplicitWrapper<boolean>;
-
-        /**
-         * @see _.every
-         */
-        all(
-            predicate?: string,
-            thisArg?: any
-        ): LoDashExplicitWrapper<boolean>;
-
-        /**
-         * @see _.every
-         */
-        all<TObject extends {}>(
-            predicate?: TObject
-        ): LoDashExplicitWrapper<boolean>;
-    }
-
-    //_.any
-    interface LoDashStatic {
-        /**
-         * @see _.some
-         */
-        any<T>(
-            collection: List<T>,
-            predicate?: ListIterator<T, boolean>,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.some
-         */
-        any<T>(
-            collection: Dictionary<T>,
-            predicate?: DictionaryIterator<T, boolean>,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.some
-         */
-        any<T>(
-            collection: NumericDictionary<T>,
-            predicate?: NumericDictionaryIterator<T, boolean>,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.some
-         */
-        any<T>(
-            collection: List<T>|Dictionary<T>|NumericDictionary<T>,
-            predicate?: string,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.some
-         */
-        any<TObject extends {}, T>(
-            collection: List<T>|Dictionary<T>|NumericDictionary<T>,
-            predicate?: TObject
-        ): boolean;
-    }
-
-    interface LoDashImplicitArrayWrapper<T> {
-        /**
-         * @see _.some
-         */
-        any(
-            predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean>,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.some
-         */
-        any(
-            predicate?: string,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.some
-         */
-        any<TObject extends {}>(
-            predicate?: TObject
-        ): boolean;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.some
-         */
-        any<TResult>(
-            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean>,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.some
-         */
-        any(
-            predicate?: string,
-            thisArg?: any
-        ): boolean;
-
-        /**
-         * @see _.some
-         */
-        any<TObject extends {}>(
-            predicate?: TObject
-        ): boolean;
-    }
-
-    interface LoDashExplicitArrayWrapper<T> {
-        /**
-         * @see _.some
-         */
-        any(
-            predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean>,
-            thisArg?: any
-        ): LoDashExplicitWrapper<boolean>;
-
-        /**
-         * @see _.some
-         */
-        any(
-            predicate?: string,
-            thisArg?: any
-        ): LoDashExplicitWrapper<boolean>;
-
-        /**
-         * @see _.some
-         */
-        any<TObject extends {}>(
-            predicate?: TObject
-        ): LoDashExplicitWrapper<boolean>;
-    }
-
-    interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.some
-         */
-        any<TResult>(
-            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean>,
-            thisArg?: any
-        ): LoDashExplicitWrapper<boolean>;
-
-        /**
-         * @see _.some
-         */
-        any(
-            predicate?: string,
-            thisArg?: any
-        ): LoDashExplicitWrapper<boolean>;
-
-        /**
-         * @see _.some
-         */
-        any<TObject extends {}>(
-            predicate?: TObject
-        ): LoDashExplicitWrapper<boolean>;
-    }
-
     //_.at
     interface LoDashStatic {
         /**
@@ -4725,220 +5049,6 @@ declare module _ {
         at<T>(...props: (number|string|(number|string)[])[]): LoDashExplicitArrayWrapper<T>;
     }
 
-    //_.collect
-    interface LoDashStatic {
-        /**
-         * @see _.map
-         */
-        collect<T, TResult>(
-            collection: List<T>,
-            iteratee?: ListIterator<T, TResult>,
-            thisArg?: any
-        ): TResult[];
-
-        /**
-         * @see _.map
-         */
-        collect<T extends {}, TResult>(
-            collection: Dictionary<T>,
-            iteratee?: DictionaryIterator<T, TResult>,
-            thisArg?: any
-        ): TResult[];
-
-        /**
-         * @see _.map
-         */
-        collect<T, TResult>(
-            collection: List<T>|Dictionary<T>,
-            iteratee?: string
-        ): TResult[];
-
-        /**
-         * @see _.map
-         */
-        collect<T, TObject extends {}>(
-            collection: List<T>|Dictionary<T>,
-            iteratee?: TObject
-        ): boolean[];
-    }
-
-    interface LoDashImplicitArrayWrapper<T> {
-        /**
-         * @see _.map
-         */
-        collect<TResult>(
-            iteratee?: ListIterator<T, TResult>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<TResult>;
-
-        /**
-         * @see _.map
-         */
-        collect<TResult>(
-            iteratee?: string
-        ): LoDashImplicitArrayWrapper<TResult>;
-
-        /**
-         * @see _.map
-         */
-        collect<TObject extends {}>(
-            iteratee?: TObject
-        ): LoDashImplicitArrayWrapper<boolean>;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.map
-         */
-        collect<TValue, TResult>(
-            iteratee?: ListIterator<TValue, TResult>|DictionaryIterator<TValue, TResult>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<TResult>;
-
-        /**
-         * @see _.map
-         */
-        collect<TValue, TResult>(
-            iteratee?: string
-        ): LoDashImplicitArrayWrapper<TResult>;
-
-        /**
-         * @see _.map
-         */
-        collect<TObject extends {}>(
-            iteratee?: TObject
-        ): LoDashImplicitArrayWrapper<boolean>;
-    }
-
-    interface LoDashExplicitArrayWrapper<T> {
-        /**
-         * @see _.map
-         */
-        collect<TResult>(
-            iteratee?: ListIterator<T, TResult>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<TResult>;
-
-        /**
-         * @see _.map
-         */
-        collect<TResult>(
-            iteratee?: string
-        ): LoDashExplicitArrayWrapper<TResult>;
-
-        /**
-         * @see _.map
-         */
-        collect<TObject extends {}>(
-            iteratee?: TObject
-        ): LoDashExplicitArrayWrapper<boolean>;
-    }
-
-    interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.map
-         */
-        collect<TValue, TResult>(
-            iteratee?: ListIterator<TValue, TResult>|DictionaryIterator<TValue, TResult>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<TResult>;
-
-        /**
-         * @see _.map
-         */
-        collect<TValue, TResult>(
-            iteratee?: string
-        ): LoDashExplicitArrayWrapper<TResult>;
-
-        /**
-         * @see _.map
-         */
-        collect<TObject extends {}>(
-            iteratee?: TObject
-        ): LoDashExplicitArrayWrapper<boolean>;
-    }
-
-    //_.contains
-    interface LoDashStatic {
-        /**
-         * @see _.includes
-         */
-        contains<T>(
-            collection: List<T>|Dictionary<T>,
-            target: T,
-            fromIndex?: number
-        ): boolean;
-
-        /**
-         * @see _.includes
-         */
-        contains(
-            collection: string,
-            target: string,
-            fromIndex?: number
-        ): boolean;
-    }
-
-    interface LoDashImplicitArrayWrapper<T> {
-        /**
-         * @see _.includes
-         */
-        contains(
-            target: T,
-            fromIndex?: number
-        ): boolean;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.includes
-         */
-        contains<TValue>(
-            target: TValue,
-            fromIndex?: number
-        ): boolean;
-    }
-
-    interface LoDashImplicitWrapper<T> {
-        /**
-         * @see _.includes
-         */
-        contains(
-            target: string,
-            fromIndex?: number
-        ): boolean;
-    }
-
-    interface LoDashExplicitArrayWrapper<T> {
-        /**
-         * @see _.includes
-         */
-        contains(
-            target: T,
-            fromIndex?: number
-        ): LoDashExplicitWrapper<boolean>;
-    }
-
-    interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.includes
-         */
-        contains<TValue>(
-            target: TValue,
-            fromIndex?: number
-        ): LoDashExplicitWrapper<boolean>;
-    }
-
-    interface LoDashExplicitWrapper<T> {
-        /**
-         * @see _.includes
-         */
-        contains(
-            target: string,
-            fromIndex?: number
-        ): LoDashExplicitWrapper<boolean>;
-    }
-
     //_.countBy
     interface LoDashStatic {
         /**
@@ -5131,94 +5241,6 @@ declare module _ {
         ): LoDashExplicitObjectWrapper<Dictionary<number>>;
     }
 
-    //_.detect
-    interface LoDashStatic {
-        /**
-         * @see _.find
-         */
-        detect<T>(
-            collection: List<T>,
-            predicate?: ListIterator<T, boolean>,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.find
-         */
-        detect<T>(
-            collection: Dictionary<T>,
-            predicate?: DictionaryIterator<T, boolean>,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.find
-         */
-        detect<T>(
-            collection: List<T>|Dictionary<T>,
-            predicate?: string,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.find
-         */
-        detect<TObject extends {}, T>(
-            collection: List<T>|Dictionary<T>,
-            predicate?: TObject
-        ): T;
-    }
-
-    interface LoDashImplicitArrayWrapper<T> {
-        /**
-         * @see _.find
-         */
-        detect(
-            predicate?: ListIterator<T, boolean>,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.find
-         */
-        detect(
-            predicate?: string,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.find
-         */
-        detect<TObject extends {}>(
-            predicate?: TObject
-        ): T;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.find
-         */
-        detect<TResult>(
-            predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>,
-            thisArg?: any
-        ): TResult;
-
-        /**
-         * @see _.find
-         */
-        detect<TResult>(
-            predicate?: string,
-            thisArg?: any
-        ): TResult;
-
-        /**
-         * @see _.find
-         */
-        detect<TObject extends {}, TResult>(
-            predicate?: TObject
-        ): TResult;
-    }
-
     //_.each
     interface LoDashStatic {
         /**
@@ -5450,8 +5472,6 @@ declare module _ {
          * If an object is provided for predicate the created _.matches style callback returns true for elements that
          * have the properties of the given object, else false.
          *
-         * @alias _.all
-         *
          * @param collection The collection to iterate over.
          * @param predicate The function invoked per iteration.
          * @param thisArg The this binding of predicate.
@@ -5605,8 +5625,6 @@ declare module _ {
          * If an object is provided for predicate the created _.matches style callback returns true for elements that
          * have the properties of the given object, else false.
          *
-         * @alias _.select
-         *
          * @param collection The collection to iterate over.
          * @param predicate The function invoked per iteration.
          * @param thisArg The this binding of predicate.
@@ -5781,8 +5799,6 @@ declare module _ {
          * If an object is provided for predicate the created _.matches style callback returns true for elements that
          * have the properties of the given object, else false.
          *
-         * @alias _.detect
-         *
          * @param collection The collection to search.
          * @param predicate The function invoked per iteration.
          * @param thisArg The this binding of predicate.
@@ -5871,81 +5887,6 @@ declare module _ {
         ): TResult;
     }
 
-    //_.findWhere
-    interface LoDashStatic {
-        /**
-        * @see _.find
-        **/
-        findWhere<T>(
-            collection: Array<T>,
-            callback: ListIterator<T, boolean>,
-            thisArg?: any): T;
-
-        /**
-        * @see _.find
-        **/
-        findWhere<T>(
-            collection: List<T>,
-            callback: ListIterator<T, boolean>,
-            thisArg?: any): T;
-
-        /**
-        * @see _.find
-        **/
-        findWhere<T>(
-            collection: Dictionary<T>,
-            callback: DictionaryIterator<T, boolean>,
-            thisArg?: any): T;
-
-        /**
-        * @see _.find
-        * @param _.matches style callback
-        **/
-        findWhere<W, T>(
-            collection: Array<T>,
-            whereValue: W): T;
-
-        /**
-        * @see _.find
-        * @param _.matches style callback
-        **/
-        findWhere<W, T>(
-            collection: List<T>,
-            whereValue: W): T;
-
-        /**
-        * @see _.find
-        * @param _.matches style callback
-        **/
-        findWhere<W, T>(
-            collection: Dictionary<T>,
-            whereValue: W): T;
-
-        /**
-        * @see _.find
-        * @param _.property style callback
-        **/
-        findWhere<T>(
-            collection: Array<T>,
-            pluckValue: string): T;
-
-        /**
-        * @see _.find
-        * @param _.property style callback
-        **/
-        findWhere<T>(
-            collection: List<T>,
-            pluckValue: string): T;
-
-        /**
-        * @see _.find
-        * @param _.property style callback
-        **/
-        findWhere<T>(
-            collection: Dictionary<T>,
-            pluckValue: string): T;
-    }
-
     //_.findLast
     interface LoDashStatic {
         /**
@@ -6537,95 +6478,12 @@ declare module _ {
         ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
     }
 
-    //_.include
-    interface LoDashStatic {
-        /**
-         * @see _.includes
-         */
-        include<T>(
-            collection: List<T>|Dictionary<T>,
-            target: T,
-            fromIndex?: number
-        ): boolean;
-
-        /**
-         * @see _.includes
-         */
-        include(
-            collection: string,
-            target: string,
-            fromIndex?: number
-        ): boolean;
-    }
-
-    interface LoDashImplicitArrayWrapper<T> {
-        /**
-         * @see _.includes
-         */
-        include(
-            target: T,
-            fromIndex?: number
-        ): boolean;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.includes
-         */
-        include<TValue>(
-            target: TValue,
-            fromIndex?: number
-        ): boolean;
-    }
-
-    interface LoDashImplicitWrapper<T> {
-        /**
-         * @see _.includes
-         */
-        include(
-            target: string,
-            fromIndex?: number
-        ): boolean;
-    }
-
-    interface LoDashExplicitArrayWrapper<T> {
-        /**
-         * @see _.includes
-         */
-        include(
-            target: T,
-            fromIndex?: number
-        ): LoDashExplicitWrapper<boolean>;
-    }
-
-    interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.includes
-         */
-        include<TValue>(
-            target: TValue,
-            fromIndex?: number
-        ): LoDashExplicitWrapper<boolean>;
-    }
-
-    interface LoDashExplicitWrapper<T> {
-        /**
-         * @see _.includes
-         */
-        include(
-            target: string,
-            fromIndex?: number
-        ): LoDashExplicitWrapper<boolean>;
-    }
-
     //_.includes
     interface LoDashStatic {
         /**
          * Checks if target is in collection using SameValueZero for equality comparisons. If fromIndex is negative,
          * it’s used as the offset from the end of collection.
          *
-         * @alias _.contains, _.include
-         *
          * @param collection The collection to search.
          * @param target The value to search for.
          * @param fromIndex The index to search from.
@@ -6707,7 +6565,7 @@ declare module _ {
         ): LoDashExplicitWrapper<boolean>;
     }
 
-    //_.indexBy
+    //_.keyBy
     interface LoDashStatic {
         /**
          * Creates an object composed of keys generated from the results of running each element of collection through
@@ -6729,51 +6587,51 @@ declare module _ {
          * @param thisArg The this binding of iteratee.
          * @return Returns the composed aggregate object.
          */
-        indexBy<T>(
+        keyBy<T>(
             collection: List<T>,
             iteratee?: ListIterator<T, any>,
             thisArg?: any
         ): Dictionary<T>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<T>(
+        keyBy<T>(
             collection: NumericDictionary<T>,
             iteratee?: NumericDictionaryIterator<T, any>,
             thisArg?: any
         ): Dictionary<T>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<T>(
+        keyBy<T>(
             collection: Dictionary<T>,
             iteratee?: DictionaryIterator<T, any>,
             thisArg?: any
         ): Dictionary<T>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<T>(
+        keyBy<T>(
             collection: List<T>|NumericDictionary<T>|Dictionary<T>,
             iteratee?: string,
             thisArg?: any
         ): Dictionary<T>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<W extends Object, T>(
+        keyBy<W extends Object, T>(
             collection: List<T>|NumericDictionary<T>|Dictionary<T>,
             iteratee?: W
         ): Dictionary<T>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<T>(
+        keyBy<T>(
             collection: List<T>|NumericDictionary<T>|Dictionary<T>,
             iteratee?: Object
         ): Dictionary<T>;
@@ -6781,9 +6639,9 @@ declare module _ {
 
     interface LoDashImplicitWrapper<T> {
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy(
+        keyBy(
             iteratee?: ListIterator<T, any>,
             thisArg?: any
         ): LoDashImplicitObjectWrapper<Dictionary<T>>;
@@ -6791,66 +6649,66 @@ declare module _ {
 
     interface LoDashImplicitArrayWrapper<T> {
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy(
+        keyBy(
             iteratee?: ListIterator<T, any>,
             thisArg?: any
         ): LoDashImplicitObjectWrapper<Dictionary<T>>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy(
+        keyBy(
             iteratee?: string,
             thisArg?: any
         ): LoDashImplicitObjectWrapper<Dictionary<T>>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<W extends Object>(
+        keyBy<W extends Object>(
             iteratee?: W
         ): LoDashImplicitObjectWrapper<Dictionary<T>>;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<T>(
+        keyBy<T>(
             iteratee?: ListIterator<T, any>|NumericDictionaryIterator<T, any>|DictionaryIterator<T, any>,
             thisArg?: any
         ): LoDashImplicitObjectWrapper<Dictionary<T>>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<T>(
+        keyBy<T>(
             iteratee?: string,
             thisArg?: any
         ): LoDashImplicitObjectWrapper<Dictionary<T>>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<W extends Object, T>(
+        keyBy<W extends Object, T>(
             iteratee?: W
         ): LoDashImplicitObjectWrapper<Dictionary<T>>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<T>(
+        keyBy<T>(
             iteratee?: Object
         ): LoDashImplicitObjectWrapper<Dictionary<T>>;
     }
 
     interface LoDashExplicitWrapper<T> {
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy(
+        keyBy(
             iteratee?: ListIterator<T, any>,
             thisArg?: any
         ): LoDashExplicitObjectWrapper<Dictionary<T>>;
@@ -6858,62 +6716,62 @@ declare module _ {
 
     interface LoDashExplicitArrayWrapper<T> {
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy(
+        keyBy(
             iteratee?: ListIterator<T, any>,
             thisArg?: any
         ): LoDashExplicitObjectWrapper<Dictionary<T>>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy(
+        keyBy(
             iteratee?: string,
             thisArg?: any
         ): LoDashExplicitObjectWrapper<Dictionary<T>>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<W extends Object>(
+        keyBy<W extends Object>(
             iteratee?: W
         ): LoDashExplicitObjectWrapper<Dictionary<T>>;
     }
 
     interface LoDashExplicitObjectWrapper<T> {
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<T>(
+        keyBy<T>(
             iteratee?: ListIterator<T, any>|NumericDictionaryIterator<T, any>|DictionaryIterator<T, any>,
             thisArg?: any
         ): LoDashExplicitObjectWrapper<Dictionary<T>>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<T>(
+        keyBy<T>(
             iteratee?: string,
             thisArg?: any
         ): LoDashExplicitObjectWrapper<Dictionary<T>>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<W extends Object, T>(
+        keyBy<W extends Object, T>(
             iteratee?: W
         ): LoDashExplicitObjectWrapper<Dictionary<T>>;
 
         /**
-         * @see _.indexBy
+         * @see _.keyBy
          */
-        indexBy<T>(
+        keyBy<T>(
             iteratee?: Object
         ): LoDashExplicitObjectWrapper<Dictionary<T>>;
     }
 
-    //_.invoke
+    //_.invokeMap
     interface LoDashStatic {
         /**
         * Invokes the method named by methodName on each element in the collection returning
@@ -6924,47 +6782,47 @@ declare module _ {
         * @param methodName The name of the method to invoke.
         * @param args Arguments to invoke the method with.
         **/
-        invoke<T extends {}>(
+        invokeMap<T extends {}>(
             collection: Array<T>,
             methodName: string,
             ...args: any[]): any;
 
         /**
-        * @see _.invoke
+        * @see _.invokeMap
         **/
-        invoke<T extends {}>(
+        invokeMap<T extends {}>(
             collection: List<T>,
             methodName: string,
             ...args: any[]): any;
 
         /**
-        * @see _.invoke
+        * @see _.invokeMap
         **/
-        invoke<T extends {}>(
+        invokeMap<T extends {}>(
             collection: Dictionary<T>,
             methodName: string,
             ...args: any[]): any;
 
         /**
-        * @see _.invoke
+        * @see _.invokeMap
         **/
-        invoke<T extends {}>(
+        invokeMap<T extends {}>(
             collection: Array<T>,
             method: Function,
             ...args: any[]): any;
 
         /**
-        * @see _.invoke
+        * @see _.invokeMap
         **/
-        invoke<T extends {}>(
+        invokeMap<T extends {}>(
             collection: List<T>,
             method: Function,
             ...args: any[]): any;
 
         /**
-        * @see _.invoke
+        * @see _.invokeMap
         **/
-        invoke<T extends {}>(
+        invokeMap<T extends {}>(
             collection: Dictionary<T>,
             method: Function,
             ...args: any[]): any;
@@ -6993,8 +6851,6 @@ declare module _ {
          * min, parseInt, slice, sortBy, take, takeRight, template, trim, trimLeft, trimRight, trunc, random, range,
          * sample, some, sum, uniq, and words
          *
-         * @alias _.collect
-         *
          * @param collection The collection to iterate over.
          * @param iteratee The function invoked per iteration.
          * @param thisArg The this binding of iteratee.
@@ -7276,57 +7132,6 @@ declare module _ {
             pluckValue: string): LoDashImplicitArrayWrapper<TResult[]>;
     }
 
-    //_.pluck
-    interface LoDashStatic {
-        /**
-         * Gets the property value of path from all elements in collection.
-         *
-         * @param collection The collection to iterate over.
-         * @param path The path of the property to pluck.
-         * @return A new array of property values.
-         */
-        pluck<T extends {}>(
-            collection: List<T>|Dictionary<T>,
-            path: StringRepresentable|StringRepresentable[]
-        ): any[];
-
-        /**
-         * @see _.pluck
-         */
-        pluck<T extends {}, TResult>(
-            collection: List<T>|Dictionary<T>,
-            path: StringRepresentable|StringRepresentable[]
-        ): TResult[];
-    }
-
-    interface LoDashImplicitArrayWrapper<T> {
-        /**
-         * @see _.pluck
-         */
-        pluck<TResult>(path: StringRepresentable|StringRepresentable[]): LoDashImplicitArrayWrapper<TResult>;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.pluck
-         */
-        pluck<TResult>(path: StringRepresentable|StringRepresentable[]): LoDashImplicitArrayWrapper<TResult>;
-    }
-
-    interface LoDashExplicitArrayWrapper<T> {
-        /**
-         * @see _.pluck
-         */
-        pluck<TResult>(path: StringRepresentable|StringRepresentable[]): LoDashExplicitArrayWrapper<TResult>;
-    }
-
-    interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.pluck
-         */
-        pluck<TResult>(path: StringRepresentable|StringRepresentable[]): LoDashExplicitArrayWrapper<TResult>;
-    }
-
     //_.reduce
     interface LoDashStatic {
         /**
@@ -7389,107 +7194,6 @@ declare module _ {
             callback: MemoIterator<T, TResult>,
             thisArg?: any): TResult;
 
-        /**
-        * @see _.reduce
-        **/
-        inject<T, TResult>(
-            collection: Array<T>,
-            callback: MemoIterator<T, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        inject<T, TResult>(
-            collection: List<T>,
-            callback: MemoIterator<T, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        inject<T, TResult>(
-            collection: Dictionary<T>,
-            callback: MemoIterator<T, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        inject<T, TResult>(
-            collection: Array<T>,
-            callback: MemoIterator<T, TResult>,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        inject<T, TResult>(
-            collection: List<T>,
-            callback: MemoIterator<T, TResult>,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        inject<T, TResult>(
-            collection: Dictionary<T>,
-            callback: MemoIterator<T, TResult>,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        foldl<T, TResult>(
-            collection: Array<T>,
-            callback: MemoIterator<T, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        foldl<T, TResult>(
-            collection: List<T>,
-            callback: MemoIterator<T, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        foldl<T, TResult>(
-            collection: Dictionary<T>,
-            callback: MemoIterator<T, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        foldl<T, TResult>(
-            collection: Array<T>,
-            callback: MemoIterator<T, TResult>,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        foldl<T, TResult>(
-            collection: List<T>,
-            callback: MemoIterator<T, TResult>,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        foldl<T, TResult>(
-            collection: Dictionary<T>,
-            callback: MemoIterator<T, TResult>,
-            thisArg?: any): TResult;
     }
 
     interface LoDashImplicitArrayWrapper<T> {
@@ -7507,36 +7211,6 @@ declare module _ {
         reduce<TResult>(
             callback: MemoIterator<T, TResult>,
             thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        inject<TResult>(
-            callback: MemoIterator<T, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        inject<TResult>(
-            callback: MemoIterator<T, TResult>,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        foldl<TResult>(
-            callback: MemoIterator<T, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        foldl<TResult>(
-            callback: MemoIterator<T, TResult>,
-            thisArg?: any): TResult;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
@@ -7554,36 +7228,6 @@ declare module _ {
         reduce<TValue, TResult>(
             callback: MemoIterator<TValue, TResult>,
             thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        inject<TValue, TResult>(
-            callback: MemoIterator<TValue, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        inject<TValue, TResult>(
-            callback: MemoIterator<TValue, TResult>,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        foldl<TValue, TResult>(
-            callback: MemoIterator<TValue, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduce
-        **/
-        foldl<TValue, TResult>(
-            callback: MemoIterator<TValue, TResult>,
-            thisArg?: any): TResult;
     }
 
     //_.reduceRight
@@ -7644,57 +7288,6 @@ declare module _ {
             collection: Dictionary<T>,
             callback: MemoIterator<T, TResult>,
             thisArg?: any): TResult;
-
-        /**
-        * @see _.reduceRight
-        **/
-        foldr<T, TResult>(
-            collection: Array<T>,
-            callback: MemoIterator<T, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduceRight
-        **/
-        foldr<T, TResult>(
-            collection: List<T>,
-            callback: MemoIterator<T, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduceRight
-        **/
-        foldr<T, TResult>(
-            collection: Dictionary<T>,
-            callback: MemoIterator<T, TResult>,
-            accumulator: TResult,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduceRight
-        **/
-        foldr<T, TResult>(
-            collection: Array<T>,
-            callback: MemoIterator<T, TResult>,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduceRight
-        **/
-        foldr<T, TResult>(
-            collection: List<T>,
-            callback: MemoIterator<T, TResult>,
-            thisArg?: any): TResult;
-
-        /**
-        * @see _.reduceRight
-        **/
-        foldr<T, TResult>(
-            collection: Dictionary<T>,
-            callback: MemoIterator<T, TResult>,
-            thisArg?: any): TResult;
     }
 
     //_.reject
@@ -7865,10 +7458,18 @@ declare module _ {
     //_.sample
     interface LoDashStatic {
         /**
-        * Retrieves a random element or n random elements from a collection.
-        * @param collection The collection to sample.
-        * @return Returns the random sample(s) of collection.
-        **/
+         * Gets a random element from `collection`.
+         *
+         * @static
+         * @memberOf _
+         * @category Collection
+         * @param {Array|Object} collection The collection to sample.
+         * @returns {*} Returns the random element.
+         * @example
+         *
+         * _.sample([1, 2, 3, 4]);
+         * // => 2
+         */
         sample<T>(collection: Array<T>): T;
 
         /**
@@ -7880,195 +7481,54 @@ declare module _ {
         * @see _.sample
         **/
         sample<T>(collection: Dictionary<T>): T;
-
-        /**
-        * @see _.sample
-        * @param n The number of elements to sample.
-        **/
-        sample<T>(collection: Array<T>, n: number): T[];
-
-        /**
-        * @see _.sample
-        * @param n The number of elements to sample.
-        **/
-        sample<T>(collection: List<T>, n: number): T[];
-
-        /**
-        * @see _.sample
-        * @param n The number of elements to sample.
-        **/
-        sample<T>(collection: Dictionary<T>, n: number): T[];
     }
 
     interface LoDashImplicitArrayWrapper<T> {
-        /**
-         * @see _.sample
-         **/
-        sample(n: number): LoDashImplicitArrayWrapper<T>;
-
         /**
          * @see _.sample
          **/
         sample(): LoDashImplicitWrapper<T>;
     }
 
-    //_.select
+    //_.sampleSize
     interface LoDashStatic {
         /**
-         * @see _.filter
+         * Gets `n` random elements from `collection`.
+         *
+         * @static
+         * @memberOf _
+         * @category Collection
+         * @param {Array|Object} collection The collection to sample.
+         * @param {number} [n=0] The number of elements to sample.
+         * @returns {Array} Returns the random elements.
+         * @example
+         *
+         * _.sampleSize([1, 2, 3, 4], 2);
+         * // => [3, 1]
          */
-        select<T>(
-            collection: List<T>,
-            predicate?: ListIterator<T, boolean>,
-            thisArg?: any
-        ): T[];
+        sampleSize<T>(collection: Array<T>, n: number): T[];
 
         /**
-         * @see _.filter
-         */
-        select<T>(
-            collection: Dictionary<T>,
-            predicate?: DictionaryIterator<T, boolean>,
-            thisArg?: any
-        ): T[];
+        * @see _.sampleSize
+        **/
+        sampleSize<T>(collection: List<T>, n: number): T[];
 
         /**
-         * @see _.filter
-         */
-        select(
-            collection: string,
-            predicate?: StringIterator<boolean>,
-            thisArg?: any
-        ): string[];
-
-        /**
-         * @see _.filter
-         */
-        select<T>(
-            collection: List<T>|Dictionary<T>,
-            predicate: string,
-            thisArg?: any
-        ): T[];
-
-        /**
-         * @see _.filter
-         */
-        select<W extends {}, T>(
-            collection: List<T>|Dictionary<T>,
-            predicate: W
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<T> {
-        /**
-         * @see _.filter
-         */
-        select(
-            predicate?: StringIterator<boolean>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<string>;
+        * @see _.sampleSize
+        **/
+        sampleSize<T>(collection: Dictionary<T>, n: number): T[];
     }
 
     interface LoDashImplicitArrayWrapper<T> {
         /**
-         * @see _.filter
-         */
-        select(
-            predicate: ListIterator<T, boolean>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
+         * @see _.sampleSize
+         **/
+        sampleSize(n: number): LoDashImplicitArrayWrapper<T>;
 
         /**
-         * @see _.filter
-         */
-        select(
-            predicate: string,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.filter
-         */
-        select<W>(predicate: W): LoDashImplicitArrayWrapper<T>;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.filter
-         */
-        select<T>(
-            predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean>,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.filter
-         */
-        select<T>(
-            predicate: string,
-            thisArg?: any
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.filter
-         */
-        select<W, T>(predicate: W): LoDashImplicitArrayWrapper<T>;
-    }
-
-    interface LoDashExplicitWrapper<T> {
-        /**
-         * @see _.filter
-         */
-        select(
-            predicate?: StringIterator<boolean>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<string>;
-    }
-
-    interface LoDashExplicitArrayWrapper<T> {
-        /**
-         * @see _.filter
-         */
-        select(
-            predicate: ListIterator<T, boolean>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.filter
-         */
-        select(
-            predicate: string,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.filter
-         */
-        select<W>(predicate: W): LoDashExplicitArrayWrapper<T>;
-    }
-
-    interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.filter
-         */
-        select<T>(
-            predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean>,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.filter
-         */
-        select<T>(
-            predicate: string,
-            thisArg?: any
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.filter
-         */
-        select<W, T>(predicate: W): LoDashExplicitArrayWrapper<T>;
+         * @see _.sampleSize
+         **/
+        sampleSize(): LoDashImplicitWrapper<T>;
     }
 
     //_.shuffle
@@ -8204,8 +7664,6 @@ declare module _ {
          * If an object is provided for predicate the created _.matches style callback returns true for elements that
          * have the properties of the given object, else false.
          *
-         * @alias _.any
-         *
          * @param collection The collection to iterate over.
          * @param predicate The function invoked per iteration.
          * @param thisArg The this binding of predicate.
@@ -8356,29 +7814,41 @@ declare module _ {
     //_.sortBy
     interface LoDashStatic {
         /**
-         * Creates an array of elements, sorted in ascending order by the results of running each element in a
-         * collection through iteratee. This method performs a stable sort, that is, it preserves the original sort
-         * order of equal elements. The iteratee is bound to thisArg and invoked with three arguments:
-         * (value, index|key, collection).
+         * Creates an array of elements, sorted in ascending order by the results of
+         * running each element in a collection through each iteratee. This method
+         * performs a stable sort, that is, it preserves the original sort order of
+         * equal elements. The iteratees are invoked with one argument: (value).
          *
-         * If a property name is provided for iteratee the created _.property style callback returns the property
-         * valueof the given element.
+         * @static
+         * @memberOf _
+         * @category Collection
+         * @param {Array|Object} collection The collection to iterate over.
+         * @param {...(Function|Function[]|Object|Object[]|string|string[])} [iteratees=[_.identity]]
+         *  The iteratees to sort by, specified individually or in arrays.
+         * @returns {Array} Returns the new sorted array.
+         * @example
          *
-         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
-         * elements that have a matching property value, else false.
+         * var users = [
+         *   { 'user': 'fred',   'age': 48 },
+         *   { 'user': 'barney', 'age': 36 },
+         *   { 'user': 'fred',   'age': 42 },
+         *   { 'user': 'barney', 'age': 34 }
+         * ];
          *
-         * If an object is provided for iteratee the created _.matches style callback returns true for elements that
-         * have the properties of the given object, else false.
+         * _.sortBy(users, function(o) { return o.user; });
+         * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]
          *
-         * @param collection The collection to iterate over.
-         * @param iteratee The function invoked per iteration.
-         * @param thisArg The this binding of iteratee.
-         * @return Returns the new sorted array.
+         * _.sortBy(users, ['user', 'age']);
+         * // => objects for [['barney', 34], ['barney', 36], ['fred', 42], ['fred', 48]]
+         *
+         * _.sortBy(users, 'user', function(o) {
+         *   return Math.floor(o.age / 10);
+         * });
+         * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]
          */
         sortBy<T, TSort>(
             collection: List<T>,
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+            iteratee?: ListIterator<T, TSort>
         ): T[];
 
         /**
@@ -8386,8 +7856,7 @@ declare module _ {
          */
         sortBy<T, TSort>(
             collection: Dictionary<T>,
-            iteratee?: DictionaryIterator<T, TSort>,
-            thisArg?: any
+            iteratee?: DictionaryIterator<T, TSort>
         ): T[];
 
         /**
@@ -8412,6 +7881,20 @@ declare module _ {
         sortBy<T>(
             collection: List<T>|Dictionary<T>
         ): T[];
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<T>(
+            collection: (Array<T>|List<T>),
+            iteratees: (ListIterator<T, any>|string|Object)[]): T[];
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy<T>(
+            collection: (Array<T>|List<T>),
+            ...iteratees: (ListIterator<T, boolean>|Object|string)[]): T[];
     }
 
     interface LoDashImplicitArrayWrapper<T> {
@@ -8419,8 +7902,7 @@ declare module _ {
          * @see _.sortBy
          */
         sortBy<TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+            iteratee?: ListIterator<T, TSort>
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
@@ -8437,6 +7919,16 @@ declare module _ {
          * @see _.sortBy
          */
         sortBy(): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.sortBy
+         */
+        sortBy(...iteratees: (ListIterator<T, boolean>|Object|string)[]): LoDashImplicitArrayWrapper<T>;
+
+        /**
+        * @see _.sortBy
+        **/
+        sortBy(iteratees: (ListIterator<T, any>|string|Object)[]): LoDashImplicitArrayWrapper<T>;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
@@ -8444,8 +7936,7 @@ declare module _ {
          * @see _.sortBy
          */
         sortBy<T, TSort>(
-            iteratee?: ListIterator<T, TSort>|DictionaryIterator<T, TSort>,
-            thisArg?: any
+            iteratee?: ListIterator<T, TSort>|DictionaryIterator<T, TSort>
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
@@ -8469,8 +7960,7 @@ declare module _ {
          * @see _.sortBy
          */
         sortBy<TSort>(
-            iteratee?: ListIterator<T, TSort>,
-            thisArg?: any
+            iteratee?: ListIterator<T, TSort>
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
@@ -8494,8 +7984,7 @@ declare module _ {
          * @see _.sortBy
          */
         sortBy<T, TSort>(
-            iteratee?: ListIterator<T, TSort>|DictionaryIterator<T, TSort>,
-            thisArg?: any
+            iteratee?: ListIterator<T, TSort>|DictionaryIterator<T, TSort>
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
@@ -8514,255 +8003,81 @@ declare module _ {
         sortBy<T>(): LoDashExplicitArrayWrapper<T>;
     }
 
-    //_.sortByAll
+    //_.orderBy
     interface LoDashStatic {
         /**
-         * This method is like _.sortBy except that it can sort by multiple iteratees or property names.
+         * This method is like `_.sortBy` except that it allows specifying the sort
+         * orders of the iteratees to sort by. If `orders` is unspecified, all values
+         * are sorted in ascending order. Otherwise, specify an order of "desc" for
+         * descending or "asc" for ascending sort order of corresponding values.
          *
-         * If a property name is provided for an iteratee the created _.property style callback returns the property
-         * value of the given element.
+         * @static
+         * @memberOf _
+         * @category Collection
+         * @param {Array|Object} collection The collection to iterate over.
+         * @param {Function[]|Object[]|string[]} [iteratees=[_.identity]] The iteratees to sort by.
+         * @param {string[]} [orders] The sort orders of `iteratees`.
+         * @param- {Object} [guard] Enables use as an iteratee for functions like `_.reduce`.
+         * @returns {Array} Returns the new sorted array.
+         * @example
          *
-         * If an object is provided for an iteratee the created _.matches style callback returns true for elements that
-         * have the properties of the given object, else false.
+         * var users = [
+         *   { 'user': 'fred',   'age': 48 },
+         *   { 'user': 'barney', 'age': 34 },
+         *   { 'user': 'fred',   'age': 42 },
+         *   { 'user': 'barney', 'age': 36 }
+         * ];
          *
-         * @param collection The collection to iterate over.
-         * @param iteratees The iteratees to sort by, specified as individual values or arrays of values.
-         * @return Returns the new sorted array.
+         * // sort by `user` in ascending order and by `age` in descending order
+         * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
+         * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]
          */
-        sortByAll<W extends Object, T>(
-            collection: List<T>,
-            iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[]
-        ): T[];
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<T>(
-            collection: List<T>,
-            iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[]
-        ): T[];
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<W extends Object, T>(
-            collection: NumericDictionary<T>,
-            iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[]
-        ): T[];
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<T>(
-            collection: NumericDictionary<T>,
-            iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[]
-        ): T[];
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<W extends Object, T>(
-            collection: Dictionary<T>,
-            iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[]
-        ): T[];
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<T>(
-            collection: Dictionary<T>,
-            iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[]
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<T> {
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll(
-            iteratees: ListIterator<T, any>|string|(ListIterator<T, any>|string)[]
-        ): LoDashImplicitArrayWrapper<T>;
-    }
-
-    interface LoDashImplicitArrayWrapper<T> {
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<W extends Object>(
-            iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[]
-        ): LoDashImplicitArrayWrapper<T>;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<W extends Object, T>(
-            iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[]
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<T>(
-            iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[]
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<W extends Object, T>(
-            iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[]
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<T>(
-            iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[]
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<W extends Object, T>(
-            iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[]
-        ): LoDashImplicitArrayWrapper<T>;
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<T>(
-            iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[]
-        ): LoDashImplicitArrayWrapper<T>;
-    }
-
-    interface LoDashExplicitWrapper<T> {
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll(
-            iteratees: ListIterator<T, any>|string|(ListIterator<T, any>|string)[]
-        ): LoDashExplicitArrayWrapper<T>;
-    }
-
-    interface LoDashExplicitArrayWrapper<T> {
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<W extends Object>(
-            iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[]
-        ): LoDashExplicitArrayWrapper<T>;
-    }
-
-    interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<W extends Object, T>(
-            iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[]
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<T>(
-            iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[]
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<W extends Object, T>(
-            iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[]
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<T>(
-            iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[]
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<W extends Object, T>(
-            iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[]
-        ): LoDashExplicitArrayWrapper<T>;
-
-        /**
-         * @see _.sortByAll
-         */
-        sortByAll<T>(
-            iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[]
-        ): LoDashExplicitArrayWrapper<T>;
-    }
-
-    //_.sortByOrder
-    interface LoDashStatic {
-        /**
-         * This method is like _.sortByAll except that it allows specifying the sort orders of the iteratees to sort
-         * by. If orders is unspecified, all values are sorted in ascending order. Otherwise, a value is sorted in
-         * ascending order if its corresponding order is "asc", and descending if "desc".
-         *
-         * If a property name is provided for an iteratee the created _.property style callback returns the property
-         * value of the given element.
-         *
-         * If an object is provided for an iteratee the created _.matches style callback returns true for elements
-         * that have the properties of the given object, else false.
-         *
-         * @param collection The collection to iterate over.
-         * @param iteratees The iteratees to sort by.
-         * @param orders The sort orders of iteratees.
-         * @return Returns the new sorted array.
-         */
-        sortByOrder<W extends Object, T>(
+        orderBy<W extends Object, T>(
             collection: List<T>,
             iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
             orders?: boolean|string|(boolean|string)[]
         ): T[];
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<T>(
+        orderBy<T>(
             collection: List<T>,
             iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[],
             orders?: boolean|string|(boolean|string)[]
         ): T[];
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<W extends Object, T>(
+        orderBy<W extends Object, T>(
             collection: NumericDictionary<T>,
             iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[],
             orders?: boolean|string|(boolean|string)[]
         ): T[];
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<T>(
+        orderBy<T>(
             collection: NumericDictionary<T>,
             iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[],
             orders?: boolean|string|(boolean|string)[]
         ): T[];
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<W extends Object, T>(
+        orderBy<W extends Object, T>(
             collection: Dictionary<T>,
             iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[],
             orders?: boolean|string|(boolean|string)[]
         ): T[];
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<T>(
+        orderBy<T>(
             collection: Dictionary<T>,
             iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[],
             orders?: boolean|string|(boolean|string)[]
@@ -8771,9 +8086,9 @@ declare module _ {
 
     interface LoDashImplicitWrapper<T> {
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder(
+        orderBy(
             iteratees: ListIterator<T, any>|string|(ListIterator<T, any>|string)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashImplicitArrayWrapper<T>;
@@ -8781,9 +8096,9 @@ declare module _ {
 
     interface LoDashImplicitArrayWrapper<T> {
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<W extends Object>(
+        orderBy<W extends Object>(
             iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashImplicitArrayWrapper<T>;
@@ -8791,49 +8106,49 @@ declare module _ {
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<W extends Object, T>(
+        orderBy<W extends Object, T>(
             iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<T>(
+        orderBy<T>(
             iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<W extends Object, T>(
+        orderBy<W extends Object, T>(
             iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<T>(
+        orderBy<T>(
             iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<W extends Object, T>(
+        orderBy<W extends Object, T>(
             iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashImplicitArrayWrapper<T>;
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<T>(
+        orderBy<T>(
             iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashImplicitArrayWrapper<T>;
@@ -8841,9 +8156,9 @@ declare module _ {
 
     interface LoDashExplicitWrapper<T> {
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder(
+        orderBy(
             iteratees: ListIterator<T, any>|string|(ListIterator<T, any>|string)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashExplicitArrayWrapper<T>;
@@ -8851,9 +8166,9 @@ declare module _ {
 
     interface LoDashExplicitArrayWrapper<T> {
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<W extends Object>(
+        orderBy<W extends Object>(
             iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashExplicitArrayWrapper<T>;
@@ -8861,89 +8176,54 @@ declare module _ {
 
     interface LoDashExplicitObjectWrapper<T> {
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<W extends Object, T>(
+        orderBy<W extends Object, T>(
             iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<T>(
+        orderBy<T>(
             iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<W extends Object, T>(
+        orderBy<W extends Object, T>(
             iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<T>(
+        orderBy<T>(
             iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<W extends Object, T>(
+        orderBy<W extends Object, T>(
             iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashExplicitArrayWrapper<T>;
 
         /**
-         * @see _.sortByOrder
+         * @see _.orderBy
          */
-        sortByOrder<T>(
+        orderBy<T>(
             iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[],
             orders?: boolean|string|(boolean|string)[]
         ): LoDashExplicitArrayWrapper<T>;
     }
 
-    //_.where
-    interface LoDashStatic {
-        /**
-        * Performs a deep comparison of each element in a collection to the given properties
-        * object, returning an array of all elements that have equivalent property values.
-        * @param collection The collection to iterate over.
-        * @param properties The object of property values to filter by.
-        * @return A new array of elements that have the given properties.
-        **/
-        where<T, U extends {}>(
-            list: Array<T>,
-            properties: U): T[];
-
-        /**
-        * @see _.where
-        **/
-        where<T, U extends {}>(
-            list: List<T>,
-            properties: U): T[];
-
-        /**
-        * @see _.where
-        **/
-        where<T, U extends {}>(
-            list: Dictionary<T>,
-            properties: U): T[];
-    }
-
-    interface LoDashImplicitArrayWrapper<T> {
-        /**
-        * @see _.where
-        **/
-        where<U extends {}>(properties: U): LoDashImplicitArrayWrapper<T>;
-    }
-
     /********
      * Date *
      ********/
@@ -9039,28 +8319,6 @@ declare module _ {
         ary<TResult extends Function>(n?: number): LoDashExplicitObjectWrapper<TResult>;
     }
 
-    //_.backflow
-    interface LoDashStatic {
-        /**
-         * @see _.flowRight
-         */
-        backflow<TResult extends Function>(...funcs: Function[]): TResult;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.flowRight
-         */
-        backflow<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>;
-    }
-
-    interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.flowRight
-         */
-        backflow<TResult extends Function>(...funcs: Function[]): LoDashExplicitObjectWrapper<TResult>;
-    }
-
     //_.before
     interface LoDashStatic {
         /**
@@ -9237,28 +8495,6 @@ declare module _ {
         ): LoDashExplicitObjectWrapper<TResult>;
     }
 
-    //_.compose
-    interface LoDashStatic {
-        /**
-         * @see _.flowRight
-         */
-        compose<TResult extends Function>(...funcs: Function[]): TResult;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.flowRight
-         */
-        compose<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>;
-    }
-
-    interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.flowRight
-         */
-        compose<TResult extends Function>(...funcs: Function[]): LoDashExplicitObjectWrapper<TResult>;
-    }
-
     //_.createCallback
     interface LoDashStatic {
         /**
@@ -9599,6 +8835,41 @@ declare module _ {
         ): LoDashExplicitWrapper<number>;
     }
 
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes `func` with arguments reversed.
+         *
+         * @static
+         * @memberOf _
+         * @category Function
+         * @param {Function} func The function to flip arguments for.
+         * @returns {Function} Returns the new function.
+         * @example
+         *
+         * var flipped = _.flip(function() {
+         *   return _.toArray(arguments);
+         * });
+         *
+         * flipped('a', 'b', 'c', 'd');
+         * // => ['d', 'c', 'b', 'a']
+         */
+        flip<T extends Function>(func: T): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.flip
+         */
+        flip(): LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.flip
+         */
+        flip(): LoDashExplicitObjectWrapper<T>;
+    }
+
     //_.flow
     interface LoDashStatic {
         /**
@@ -9631,8 +8902,6 @@ declare module _ {
          * This method is like _.flow except that it creates a function that invokes the provided functions from right
          * to left.
          *
-         * @alias _.backflow, _.compose
-         *
          * @param funcs Functions to invoke.
          * @return Returns the new function.
          */
@@ -9681,7 +8950,7 @@ declare module _ {
         memoize<TResult extends MemoizedFunction>(resolver?: Function): LoDashImplicitObjectWrapper<TResult>;
     }
 
-    //_.modArgs
+    //_.overArgs (was _.modArgs)
     interface LoDashStatic {
         /**
          * Creates a function that runs each argument through a corresponding transform function.
@@ -9691,15 +8960,15 @@ declare module _ {
          * of functions.
          * @return Returns the new function.
          */
-        modArgs<T extends Function, TResult extends Function>(
+        overArgs<T extends Function, TResult extends Function>(
             func: T,
             ...transforms: Function[]
         ): TResult;
 
         /**
-         * @see _.modArgs
+         * @see _.overArgs
          */
-        modArgs<T extends Function, TResult extends Function>(
+        overArgs<T extends Function, TResult extends Function>(
             func: T,
             transforms: Function[]
         ): TResult;
@@ -9707,26 +8976,26 @@ declare module _ {
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
-         * @see _.modArgs
+         * @see _.overArgs
          */
-        modArgs<TResult extends Function>(...transforms: Function[]): LoDashImplicitObjectWrapper<TResult>;
+        overArgs<TResult extends Function>(...transforms: Function[]): LoDashImplicitObjectWrapper<TResult>;
 
         /**
-         * @see _.modArgs
+         * @see _.overArgs
          */
-        modArgs<TResult extends Function>(transforms: Function[]): LoDashImplicitObjectWrapper<TResult>;
+        overArgs<TResult extends Function>(transforms: Function[]): LoDashImplicitObjectWrapper<TResult>;
     }
 
     interface LoDashExplicitObjectWrapper<T> {
         /**
-         * @see _.modArgs
+         * @see _.overArgs
          */
-        modArgs<TResult extends Function>(...transforms: Function[]): LoDashExplicitObjectWrapper<TResult>;
+        overArgs<TResult extends Function>(...transforms: Function[]): LoDashExplicitObjectWrapper<TResult>;
 
         /**
-         * @see _.modArgs
+         * @see _.overArgs
          */
-        modArgs<TResult extends Function>(transforms: Function[]): LoDashExplicitObjectWrapper<TResult>;
+        overArgs<TResult extends Function>(transforms: Function[]): LoDashExplicitObjectWrapper<TResult>;
     }
 
     //_.negate
@@ -9951,7 +9220,7 @@ declare module _ {
         rearg<TResult extends Function>(...indexes: number[]): LoDashImplicitObjectWrapper<TResult>;
     }
 
-    //_.restParam
+    //_.rest
     interface LoDashStatic {
         /**
          * Creates a function that invokes func with the this binding of the created function and arguments from start
@@ -9963,15 +9232,15 @@ declare module _ {
          * @param start The start position of the rest parameter.
          * @return Returns the new function.
          */
-        restParam<TResult extends Function>(
+        rest<TResult extends Function>(
             func: Function,
             start?: number
         ): TResult;
 
         /**
-         * @see _.restParam
+         * @see _.rest
          */
-        restParam<TResult extends Function, TFunc extends Function>(
+        rest<TResult extends Function, TFunc extends Function>(
             func: TFunc,
             start?: number
         ): TResult;
@@ -9979,16 +9248,16 @@ declare module _ {
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
-         * @see _.restParam
+         * @see _.rest
          */
-        restParam<TResult extends Function>(start?: number): LoDashImplicitObjectWrapper<TResult>;
+        rest<TResult extends Function>(start?: number): LoDashImplicitObjectWrapper<TResult>;
     }
 
     interface LoDashExplicitObjectWrapper<T> {
         /**
-         * @see _.restParam
+         * @see _.rest
          */
-        restParam<TResult extends Function>(start?: number): LoDashExplicitObjectWrapper<TResult>;
+        rest<TResult extends Function>(start?: number): LoDashExplicitObjectWrapper<TResult>;
     }
 
     //_.spread
@@ -10081,6 +9350,39 @@ declare module _ {
         ): LoDashExplicitObjectWrapper<T & Cancelable>;
     }
 
+    //_.unary
+    interface LoDashStatic {
+        /**
+         * Creates a function that accepts up to one argument, ignoring any
+         * additional arguments.
+         *
+         * @static
+         * @memberOf _
+         * @category Function
+         * @param {Function} func The function to cap arguments for.
+         * @returns {Function} Returns the new function.
+         * @example
+         *
+         * _.map(['6', '8', '10'], _.unary(parseInt));
+         * // => [6, 8, 10]
+         */
+        unary<T extends Function>(func: T): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.unary
+         */
+        unary(): LoDashImplicitObjectWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.unary
+         */
+        unary(): LoDashExplicitObjectWrapper<T>;
+    }
+
     //_.wrap
     interface LoDashStatic {
         /**
@@ -10193,86 +9495,150 @@ declare module _ {
     //_.clone
     interface LoDashStatic {
         /**
-         * Creates a clone of value. If isDeep is true nested objects are cloned, otherwise they are assigned by
-         * reference. If customizer is provided it’s invoked to produce the cloned values. If customizer returns
-         * undefined cloning is handled by the method instead. The customizer is bound to thisArg and invoked with up
-         * to three argument; (value [, index|key, object]).
-         * Note: This method is loosely based on the structured clone algorithm. The enumerable properties of arguments
-         * objects and objects created by constructors other than Object are cloned to plain Object objects. An empty
-         * object is returned for uncloneable values such as functions, DOM nodes, Maps, Sets, and WeakMaps.
-         * @param value The value to clone.
-         * @param isDeep Specify a deep clone.
-         * @param customizer The function to customize cloning values.
-         * @param thisArg The this binding of customizer.
-         * @return Returns the cloned value.
+         * Creates a shallow clone of `value`.
+         *
+         * **Note:** This method is loosely based on the
+         * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
+         * and supports cloning arrays, array buffers, booleans, date objects, maps,
+         * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
+         * arrays. The own enumerable properties of `arguments` objects are cloned
+         * as plain objects. An empty object is returned for uncloneable values such
+         * as error objects, functions, DOM nodes, and WeakMaps.
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to clone.
+         * @returns {*} Returns the cloned value.
+         * @example
+         *
+         * var objects = [{ 'a': 1 }, { 'b': 2 }];
+         *
+         * var shallow = _.clone(objects);
+         * console.log(shallow[0] === objects[0]);
+         * // => true
          */
-        clone<T>(
-            value: T,
-            isDeep?: boolean,
-            customizer?: (value: any) => any,
-            thisArg?: any): T;
-
-        /**
-         * @see _.clone
-         */
-        clone<T>(
-            value: T,
-            customizer?: (value: any) => any,
-            thisArg?: any): T;
+        clone<T>(value: T): T;
     }
 
     interface LoDashImplicitWrapper<T> {
         /**
          * @see _.clone
          */
-        clone(
-            isDeep?: boolean,
-            customizer?: (value: any) => any,
-            thisArg?: any): T;
-
-        /**
-         * @see _.clone
-         */
-        clone(
-            customizer?: (value: any) => any,
-            thisArg?: any): T;
+        clone(): T;
     }
 
     interface LoDashImplicitArrayWrapper<T> {
-        /**
-         * @see _.clone
-         */
-        clone(
-            isDeep?: boolean,
-            customizer?: (value: any) => any,
-            thisArg?: any): T[];
 
         /**
          * @see _.clone
          */
-        clone(
-            customizer?: (value: any) => any,
-            thisArg?: any): T[];
+        clone(): T[];
     }
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.clone
          */
-        clone(
-            isDeep?: boolean,
-            customizer?: (value: any) => any,
-            thisArg?: any): T;
+        clone(): T;
+    }
+
+    //_.cloneDeep
+    interface LoDashStatic {
+        /**
+         * This method is like `_.clone` except that it recursively clones `value`.
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to recursively clone.
+         * @returns {*} Returns the deep cloned value.
+         * @example
+         *
+         * var objects = [{ 'a': 1 }, { 'b': 2 }];
+         *
+         * var deep = _.cloneDeep(objects);
+         * console.log(deep[0] === objects[0]);
+         * // => false
+         */
+        cloneDeep<T>(value: T): T;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.cloneDeep
+         */
+        cloneDeep(): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.cloneDeep
+         */
+        cloneDeep(): T[];
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.cloneDeep
+         */
+        cloneDeep(): T;
+    }
+
+    //_.cloneWith
+    interface LoDashStatic {
+        /**
+         * Creates a shallow clone of `value`.
+         *
+         * **Note:** This method is loosely based on the
+         * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
+         * and supports cloning arrays, array buffers, booleans, date objects, maps,
+         * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
+         * arrays. The own enumerable properties of `arguments` objects are cloned
+         * as plain objects. An empty object is returned for uncloneable values such
+         * as error objects, functions, DOM nodes, and WeakMaps.
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to clone.
+         * @returns {*} Returns the cloned value.
+         * @example
+         *
+         * var objects = [{ 'a': 1 }, { 'b': 2 }];
+         *
+         * var shallow = _.clone(objects);
+         * console.log(shallow[0] === objects[0]);
+         * // => true
+         */
+        clone<T>(
+            value: T,
+            customizer: (value: any) => any): T;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.clone
+         */
+        clone(customizer: (value: any) => any): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
 
         /**
          * @see _.clone
          */
-        clone(
-            customizer?: (value: any) => any,
-            thisArg?: any): T;
+        clone(customizer: (value: any) => any): T[];
     }
 
-    //_.cloneDeep
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.clone
+         */
+        clone(customizer: (value: any) => any): T;
+    }
+
+    //_.cloneDeepWith
     interface LoDashStatic {
         /**
          * Creates a deep clone of value. If customizer is provided it’s invoked to produce the cloned values. If
@@ -10288,47 +9654,65 @@ declare module _ {
          */
         cloneDeep<T>(
             value: T,
-            customizer?: (value: any) => any,
-            thisArg?: any): T;
+            customizer: (value: any) => any): T;
     }
 
     interface LoDashImplicitWrapper<T> {
         /**
          * @see _.cloneDeep
          */
-        cloneDeep(
-            customizer?: (value: any) => any,
-            thisArg?: any): T;
+        cloneDeep(customizer: (value: any) => any): T;
     }
 
     interface LoDashImplicitArrayWrapper<T> {
         /**
          * @see _.cloneDeep
          */
-        cloneDeep(
-            customizer?: (value: any) => any,
-            thisArg?: any): T[];
+        cloneDeep(customizer: (value: any) => any): T[];
     }
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.cloneDeep
          */
-        cloneDeep(
-            customizer?: (value: any) => any,
-            thisArg?: any): T;
+        cloneDeep(customizer: (value: any) => any): T;
     }
 
     //_.eq
     interface LoDashStatic {
         /**
-         * @see _.isEqual
+         * Performs a [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+         * comparison between two values to determine if they are equivalent.
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to compare.
+         * @param {*} other The other value to compare.
+         * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+         * @example
+         *
+         * var object = { 'user': 'fred' };
+         * var other = { 'user': 'fred' };
+         *
+         * _.eq(object, object);
+         * // => true
+         *
+         * _.eq(object, other);
+         * // => false
+         *
+         * _.eq('a', 'a');
+         * // => true
+         *
+         * _.eq('a', Object('a'));
+         * // => false
+         *
+         * _.eq(NaN, NaN);
+         * // => true
          */
         eq(
             value: any,
-            other: any,
-            customizer?: IsEqualCustomizer,
-            thisArg?: any
+            other: any
         ): boolean;
     }
 
@@ -10337,9 +9721,7 @@ declare module _ {
          * @see _.isEqual
          */
         eq(
-            other: any,
-            customizer?: IsEqualCustomizer,
-            thisArg?: any
+            other: any
         ): boolean;
     }
 
@@ -10348,9 +9730,7 @@ declare module _ {
          * @see _.isEqual
          */
         eq(
-            other: any,
-            customizer?: IsEqualCustomizer,
-            thisArg?: any
+            other: any
         ): LoDashExplicitWrapper<boolean>;
     }
 
@@ -10462,6 +9842,93 @@ declare module _ {
         isArray(): LoDashExplicitWrapper<boolean>;
     }
 
+    //_.isArrayLike
+    interface LoDashStatic {
+        /**
+         * Checks if `value` is array-like. A value is considered array-like if it's
+         * not a function and has a `value.length` that's an integer greater than or
+         * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+         *
+         * @static
+         * @memberOf _
+         * @type Function
+         * @category Lang
+         * @param {*} value The value to check.
+         * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+         * @example
+         *
+         * _.isArrayLike([1, 2, 3]);
+         * // => true
+         *
+         * _.isArrayLike(document.body.children);
+         * // => true
+         *
+         * _.isArrayLike('abc');
+         * // => true
+         *
+         * _.isArrayLike(_.noop);
+         * // => false
+         */
+        isArrayLike<T>(value?: any): value is T[];
+    }
+
+    interface LoDashImplicitWrapperBase<T,TWrapper> {
+        /**
+         * @see _.isArrayLike
+         */
+        isArrayLike(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T,TWrapper> {
+        /**
+         * @see _.isArrayLike
+         */
+        isArrayLike(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isArrayLikeObject
+    interface LoDashStatic {
+        /**
+         * This method is like `_.isArrayLike` except that it also checks if `value`
+         * is an object.
+         *
+         * @static
+         * @memberOf _
+         * @type Function
+         * @category Lang
+         * @param {*} value The value to check.
+         * @returns {boolean} Returns `true` if `value` is an array-like object, else `false`.
+         * @example
+         *
+         * _.isArrayLikeObject([1, 2, 3]);
+         * // => true
+         *
+         * _.isArrayLikeObject(document.body.children);
+         * // => true
+         *
+         * _.isArrayLikeObject('abc');
+         * // => false
+         *
+         * _.isArrayLikeObject(_.noop);
+         * // => false
+         */
+        isArrayLikeObject<T>(value?: any): value is T[];
+    }
+
+    interface LoDashImplicitWrapperBase<T,TWrapper> {
+        /**
+         * @see _.isArrayLikeObject
+         */
+        isArrayLikeObject(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T,TWrapper> {
+        /**
+         * @see _.isArrayLikeObject
+         */
+        isArrayLikeObject(): LoDashExplicitWrapper<boolean>;
+    }
+
     //_.isBoolean
     interface LoDashStatic {
         /**
@@ -10556,34 +10023,37 @@ declare module _ {
     }
 
     //_.isEqual
-    interface IsEqualCustomizer {
-        (value: any, other: any, indexOrKey?: number|string): boolean;
-    }
-
     interface LoDashStatic {
         /**
-         * Performs a deep comparison between two values to determine if they are equivalent. If customizer is
-         * provided it’s invoked to compare values. If customizer returns undefined comparisons are handled by the
-         * method instead. The customizer is bound to thisArg and invoked with up to three arguments: (value, other
-         * [, index|key]).
+         * Performs a deep comparison between two values to determine if they are
+         * equivalent.
          *
-         * Note: This method supports comparing arrays, booleans, Date objects, numbers, Object objects, regexes,
-         * and strings. Objects are compared by their own, not inherited, enumerable properties. Functions and DOM
-         * nodes are not supported. Provide a customizer function to extend support for comparing other values.
+         * **Note:** This method supports comparing arrays, array buffers, booleans,
+         * date objects, error objects, maps, numbers, `Object` objects, regexes,
+         * sets, strings, symbols, and typed arrays. `Object` objects are compared
+         * by their own, not inherited, enumerable properties. Functions and DOM
+         * nodes are **not** supported.
          *
-         * @alias _.eq
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to compare.
+         * @param {*} other The other value to compare.
+         * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+         * @example
          *
-         * @param value The value to compare.
-         * @param other The other value to compare.
-         * @param customizer The function to customize value comparisons.
-         * @param thisArg The this binding of customizer.
-         * @return Returns true if the values are equivalent, else false.
+         * var object = { 'user': 'fred' };
+         * var other = { 'user': 'fred' };
+         *
+         * _.isEqual(object, other);
+         * // => true
+         *
+         * object === other;
+         * // => false
          */
         isEqual(
             value: any,
-            other: any,
-            customizer?: IsEqualCustomizer,
-            thisArg?: any
+            other: any
         ): boolean;
     }
 
@@ -10592,9 +10062,7 @@ declare module _ {
          * @see _.isEqual
          */
         isEqual(
-            other: any,
-            customizer?: IsEqualCustomizer,
-            thisArg?: any
+            other: any
         ): boolean;
     }
 
@@ -10603,9 +10071,71 @@ declare module _ {
          * @see _.isEqual
          */
         isEqual(
+            other: any
+        ): LoDashExplicitWrapper<boolean>;
+    }
+
+    // _.isEqualWith
+    interface IsEqualCustomizer {
+        (value: any, other: any, indexOrKey?: number|string): boolean;
+    }
+
+    interface LoDashStatic {
+        /**
+         * This method is like `_.isEqual` except that it accepts `customizer` which is
+         * invoked to compare values. If `customizer` returns `undefined` comparisons are
+         * handled by the method instead. The `customizer` is invoked with up to seven arguments:
+         * (objValue, othValue [, index|key, object, other, stack]).
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to compare.
+         * @param {*} other The other value to compare.
+         * @param {Function} [customizer] The function to customize comparisons.
+         * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+         * @example
+         *
+         * function isGreeting(value) {
+         *   return /^h(?:i|ello)$/.test(value);
+         * }
+         *
+         * function customizer(objValue, othValue) {
+         *   if (isGreeting(objValue) && isGreeting(othValue)) {
+         *     return true;
+         *   }
+         * }
+         *
+         * var array = ['hello', 'goodbye'];
+         * var other = ['hi', 'goodbye'];
+         *
+         * _.isEqualWith(array, other, customizer);
+         * // => true
+         */
+        isEqualWith(
+            value: any,
             other: any,
-            customizer?: IsEqualCustomizer,
-            thisArg?: any
+            customizer: IsEqualCustomizer
+        ): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isEqualWith
+         */
+        isEqualWith(
+            other: any,
+            customizer: IsEqualCustomizer
+        ): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isEqualWith
+         */
+        isEqualWith(
+            other: any,
+            customizer: IsEqualCustomizer
         ): LoDashExplicitWrapper<boolean>;
     }
 
@@ -10687,6 +10217,92 @@ declare module _ {
         isFunction(): LoDashExplicitWrapper<boolean>;
     }
 
+    //_.isInteger
+    interface LoDashStatic {
+        /**
+         * Checks if `value` is an integer.
+         *
+         * **Note:** This method is based on [`Number.isInteger`](https://mdn.io/Number/isInteger).
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to check.
+         * @returns {boolean} Returns `true` if `value` is an integer, else `false`.
+         * @example
+         *
+         * _.isInteger(3);
+         * // => true
+         *
+         * _.isInteger(Number.MIN_VALUE);
+         * // => false
+         *
+         * _.isInteger(Infinity);
+         * // => false
+         *
+         * _.isInteger('3');
+         * // => false
+         */
+        isInteger(value?: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isInteger
+         */
+        isInteger(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isInteger
+         */
+        isInteger(): LoDashExplicitWrapper<boolean>;
+    }
+
+    //_.isLength
+    interface LoDashStatic {
+        /**
+         * Checks if `value` is a valid array-like length.
+         *
+         * **Note:** This function is loosely based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to check.
+         * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+         * @example
+         *
+         * _.isLength(3);
+         * // => true
+         *
+         * _.isLength(Number.MIN_VALUE);
+         * // => false
+         *
+         * _.isLength(Infinity);
+         * // => false
+         *
+         * _.isLength('3');
+         * // => false
+         */
+        isLength(value?: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isLength
+         */
+        isLength(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isLength
+         */
+        isLength(): LoDashExplicitWrapper<boolean>;
+    }
+
     //_.isMatch
     interface isMatchCustomizer {
         (value: any, other: any, indexOrKey?: number|string): boolean;
@@ -10694,24 +10310,82 @@ declare module _ {
 
     interface LoDashStatic {
         /**
-         * Performs a deep comparison between object and source to determine if object contains equivalent property
-         * values. If customizer is provided it’s invoked to compare values. If customizer returns undefined
-         * comparisons are handled by the method instead. The customizer is bound to thisArg and invoked with three
-         * arguments: (value, other, index|key).
-         * @param object The object to inspect.
-         * @param source The object of property values to match.
-         * @param customizer The function to customize value comparisons.
-         * @param thisArg The this binding of customizer.
-         * @return Returns true if object is a match, else false.
+         * Performs a deep comparison between `object` and `source` to determine if
+         * `object` contains equivalent property values.
+         *
+         * **Note:** This method supports comparing the same values as `_.isEqual`.
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {Object} object The object to inspect.
+         * @param {Object} source The object of property values to match.
+         * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+         * @example
+         *
+         * var object = { 'user': 'fred', 'age': 40 };
+         *
+         * _.isMatch(object, { 'age': 40 });
+         * // => true
+         *
+         * _.isMatch(object, { 'age': 36 });
+         * // => false
          */
-        isMatch(object: Object, source: Object, customizer?: isMatchCustomizer, thisArg?: any): boolean;
+        isMatch(object: Object, source: Object): boolean;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.isMatch
          */
-        isMatch(source: Object, customizer?: isMatchCustomizer, thisArg?: any): boolean;
+        isMatch(source: Object): boolean;
+    }
+
+    //_.isMatchWith
+    interface isMatchWithCustomizer {
+        (value: any, other: any, indexOrKey?: number|string): boolean;
+    }
+
+    interface LoDashStatic {
+        /**
+         * This method is like `_.isMatch` except that it accepts `customizer` which
+         * is invoked to compare values. If `customizer` returns `undefined` comparisons
+         * are handled by the method instead. The `customizer` is invoked with three
+         * arguments: (objValue, srcValue, index|key, object, source).
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {Object} object The object to inspect.
+         * @param {Object} source The object of property values to match.
+         * @param {Function} [customizer] The function to customize comparisons.
+         * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+         * @example
+         *
+         * function isGreeting(value) {
+         *   return /^h(?:i|ello)$/.test(value);
+         * }
+         *
+         * function customizer(objValue, srcValue) {
+         *   if (isGreeting(objValue) && isGreeting(srcValue)) {
+         *     return true;
+         *   }
+         * }
+         *
+         * var object = { 'greeting': 'hello' };
+         * var source = { 'greeting': 'hi' };
+         *
+         * _.isMatchWith(object, source, customizer);
+         * // => true
+         */
+        isMatchWith(object: Object, source: Object, customizer: isMatchWithCustomizer): boolean;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.isMatchWith
+         */
+        isMatchWith(source: Object, customizer: isMatchWithCustomizer): boolean;
     }
 
     //_.isNaN
@@ -10766,6 +10440,44 @@ declare module _ {
         isNative(): LoDashExplicitWrapper<boolean>;
     }
 
+    //_.isNil
+    interface LoDashStatic {
+        /**
+         * Checks if `value` is `null` or `undefined`.
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to check.
+         * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
+         * @example
+         *
+         * _.isNil(null);
+         * // => true
+         *
+         * _.isNil(void 0);
+         * // => true
+         *
+         * _.isNil(NaN);
+         * // => false
+         */
+        isNil(value?: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isNil
+         */
+        isNil(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isNil
+         */
+        isNil(): LoDashExplicitWrapper<boolean>;
+    }
+
     //_.isNull
     interface LoDashStatic {
         /**
@@ -10844,6 +10556,48 @@ declare module _ {
         isObject(): LoDashExplicitWrapper<boolean>;
     }
 
+    //_.isObjectLike
+    interface LoDashStatic {
+        /**
+         * Checks if `value` is object-like. A value is object-like if it's not `null`
+         * and has a `typeof` result of "object".
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to check.
+         * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+         * @example
+         *
+         * _.isObjectLike({});
+         * // => true
+         *
+         * _.isObjectLike([1, 2, 3]);
+         * // => true
+         *
+         * _.isObjectLike(_.noop);
+         * // => false
+         *
+         * _.isObjectLike(null);
+         * // => false
+         */
+        isObjectLike(value?: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isObjectLike
+         */
+        isObjectLike(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isObjectLike
+         */
+        isObjectLike(): LoDashExplicitWrapper<boolean>;
+    }
+
     //_.isPlainObject
     interface LoDashStatic {
         /**
@@ -10897,6 +10651,50 @@ declare module _ {
         isRegExp(): LoDashExplicitWrapper<boolean>;
     }
 
+    //_.isSafeInteger
+    interface LoDashStatic {
+        /**
+         * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
+         * double precision number which isn't the result of a rounded unsafe integer.
+         *
+         * **Note:** This method is based on [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to check.
+         * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
+         * @example
+         *
+         * _.isSafeInteger(3);
+         * // => true
+         *
+         * _.isSafeInteger(Number.MIN_VALUE);
+         * // => false
+         *
+         * _.isSafeInteger(Infinity);
+         * // => false
+         *
+         * _.isSafeInteger('3');
+         * // => false
+         */
+        isSafeInteger(value: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isSafeInteger
+         */
+        isSafeInteger(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isSafeInteger
+         */
+        isSafeInteger(): LoDashExplicitWrapper<boolean>;
+    }
+
     //_.isString
     interface LoDashStatic {
         /**
@@ -10922,6 +10720,41 @@ declare module _ {
         isString(): LoDashExplicitWrapper<boolean>;
     }
 
+    //_.isSymbol
+    interface LoDashStatic {
+        /**
+         * Checks if `value` is classified as a `Symbol` primitive or object.
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to check.
+         * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
+         * @example
+         *
+         * _.isSymbol(Symbol.iterator);
+         * // => true
+         *
+         * _.isSymbol('abc');
+         * // => false
+         */
+        isSymbol(value: any): boolean;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isSymbol
+         */
+        isSymbol(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * see _.isSymbol
+         */
+        isSymbol(): LoDashExplicitWrapper<boolean>;
+    }
+
     //_.isTypedArray
     interface LoDashStatic {
         /**
@@ -11112,6 +10945,201 @@ declare module _ {
         toPlainObject<TResult extends {}>(): LoDashImplicitObjectWrapper<TResult>;
     }
 
+    //_.toInteger
+    interface LoDashStatic {
+        /**
+         * Converts `value` to an integer.
+         *
+         * **Note:** This function is loosely based on [`ToInteger`](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger).
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to convert.
+         * @returns {number} Returns the converted integer.
+         * @example
+         *
+         * _.toInteger(3);
+         * // => 3
+         *
+         * _.toInteger(Number.MIN_VALUE);
+         * // => 0
+         *
+         * _.toInteger(Infinity);
+         * // => 1.7976931348623157e+308
+         *
+         * _.toInteger('3');
+         * // => 3
+         */
+        toInteger(value: any): number;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.toInteger
+         */
+        toInteger(): LoDashImplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.toInteger
+         */
+        toInteger(): LoDashExplicitWrapper<number>;
+    }
+
+    //_.toLength
+    interface LoDashStatic {
+        /**
+         * Converts `value` to an integer suitable for use as the length of an
+         * array-like object.
+         *
+         * **Note:** This method is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to convert.
+         * @return {number} Returns the converted integer.
+         * @example
+         *
+         * _.toLength(3);
+         * // => 3
+         *
+         * _.toLength(Number.MIN_VALUE);
+         * // => 0
+         *
+         * _.toLength(Infinity);
+         * // => 4294967295
+         *
+         * _.toLength('3');
+         * // => 3
+         */
+        toLength(value: any): number;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.toLength
+         */
+        toLength(): LoDashImplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.toLength
+         */
+        toLength(): LoDashExplicitWrapper<number>;
+    }
+
+    //_.toNumber
+    interface LoDashStatic {
+        /**
+         * Converts `value` to a number.
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to process.
+         * @returns {number} Returns the number.
+         * @example
+         *
+         * _.toNumber(3);
+         * // => 3
+         *
+         * _.toNumber(Number.MIN_VALUE);
+         * // => 5e-324
+         *
+         * _.toNumber(Infinity);
+         * // => Infinity
+         *
+         * _.toNumber('3');
+         * // => 3
+         */
+        toNumber(value: any): number;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.toNumber
+         */
+        toNumber(): LoDashImplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.toNumber
+         */
+        toNumber(): LoDashExplicitWrapper<number>;
+    }
+
+    //_.toSafeInteger
+    interface LoDashStatic {
+        /**
+         * Converts `value` to a safe integer. A safe integer can be compared and
+         * represented correctly.
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to convert.
+         * @returns {number} Returns the converted integer.
+         * @example
+         *
+         * _.toSafeInteger(3);
+         * // => 3
+         *
+         * _.toSafeInteger(Number.MIN_VALUE);
+         * // => 0
+         *
+         * _.toSafeInteger(Infinity);
+         * // => 9007199254740991
+         *
+         * _.toSafeInteger('3');
+         * // => 3
+         */
+        toSafeInteger(value: any): number;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.toSafeInteger
+         */
+        toSafeInteger(): LoDashImplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.toSafeInteger
+         */
+        toSafeInteger(): LoDashExplicitWrapper<number>;
+    }
+
+    //_.toString DUMMY
+    interface LoDashStatic {
+        /**
+         * Converts `value` to a string if it's not one. An empty string is returned
+         * for `null` and `undefined` values. The sign of `-0` is preserved.
+         *
+         * @static
+         * @memberOf _
+         * @category Lang
+         * @param {*} value The value to process.
+         * @returns {string} Returns the string.
+         * @example
+         *
+         * _.toString(null);
+         * // => ''
+         *
+         * _.toString(-0);
+         * // => '-0'
+         *
+         * _.toString([1, 2, 3]);
+         * // => '1,2,3'
+         */
+        toString(value: any): string;
+    }
+
     /********
      * Math *
      ********/
@@ -11205,55 +11233,18 @@ declare module _ {
 
     //_.max
     interface LoDashStatic {
-        /**
-         * Gets the maximum value of collection. If collection is empty or falsey -Infinity is returned. If an iteratee
-         * function is provided it’s invoked for each value in collection to generate the criterion by which the value
-         * is ranked. The iteratee is bound to thisArg and invoked with three arguments: (value, index, collection).
-         *
-         * If a property name is provided for iteratee the created _.property style callback returns the property value
-         * of the given element.
-         *
-         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
-         * elements that have a matching property value, else false.
-         *
-         * If an object is provided for iteratee the created _.matches style callback returns true for elements that
-         * have the properties of the given object, else false.
-         *
-         * @param collection The collection to iterate over.
-         * @param iteratee The function invoked per iteration.
-         * @param thisArg The this binding of iteratee.
-         * @return Returns the maximum value.
-         */
+         /**
+          * Computes the maximum value of `array`. If `array` is empty or falsey
+          * `undefined` is returned.
+          *
+          * @static
+          * @memberOf _
+          * @category Math
+          * @param {Array} array The array to iterate over.
+          * @returns {*} Returns the maximum value.
+          */
         max<T>(
-            collection: List<T>,
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.max
-         */
-        max<T>(
-            collection: Dictionary<T>,
-            iteratee?: DictionaryIterator<T, any>,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.max
-         */
-        max<T>(
-            collection: List<T>|Dictionary<T>,
-            iteratee?: string,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.max
-         */
-        max<TObject extends {}, T>(
-            collection: List<T>|Dictionary<T>,
-            whereValue?: TObject
+            collection: List<T>
         ): T;
     }
 
@@ -11261,103 +11252,164 @@ declare module _ {
         /**
          * @see _.max
          */
-        max(
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.max
-         */
-        max(
-            iteratee?: string,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.max
-         */
-        max<TObject extends {}>(
-            whereValue?: TObject
-        ): T;
+        max(): T;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.max
          */
-        max<T>(
+        max<T>(): T;
+    }
+
+    //_.maxBy
+    interface LoDashStatic {
+        /**
+         * This method is like `_.max` except that it accepts `iteratee` which is
+         * invoked for each element in `array` to generate the criterion by which
+         * the value is ranked. The iteratee is invoked with one argument: (value).
+         *
+         * @static
+         * @memberOf _
+         * @category Math
+         * @param {Array} array The array to iterate over.
+         * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+         * @returns {*} Returns the maximum value.
+         * @example
+         *
+         * var objects = [{ 'n': 1 }, { 'n': 2 }];
+         *
+         * _.maxBy(objects, function(o) { return o.a; });
+         * // => { 'n': 2 }
+         *
+         * // using the `_.property` iteratee shorthand
+         * _.maxBy(objects, 'n');
+         * // => { 'n': 2 }
+         */
+        maxBy<T>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, any>
+        ): T;
+
+        /**
+         * @see _.maxBy
+         */
+        maxBy<T>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>
+        ): T;
+
+        /**
+         * @see _.maxBy
+         */
+        maxBy<T>(
+            collection: List<T>|Dictionary<T>,
+            iteratee?: string
+        ): T;
+
+        /**
+         * @see _.maxBy
+         */
+        maxBy<TObject extends {}, T>(
+            collection: List<T>|Dictionary<T>,
+            whereValue?: TObject
+        ): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.maxBy
+         */
+        maxBy(
+            iteratee?: ListIterator<T, any>
+        ): T;
+
+        /**
+         * @see _.maxBy
+         */
+        maxBy(
+            iteratee?: string
+        ): T;
+
+        /**
+         * @see _.maxBy
+         */
+        maxBy<TObject extends {}>(
+            whereValue?: TObject
+        ): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.maxBy
+         */
+        maxBy<T>(
             iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>,
             thisArg?: any
         ): T;
 
         /**
-         * @see _.max
+         * @see _.maxBy
          */
-        max<T>(
+        maxBy<T>(
             iteratee?: string,
             thisArg?: any
         ): T;
 
         /**
-         * @see _.max
+         * @see _.maxBy
          */
-        max<TObject extends {}, T>(
+        maxBy<TObject extends {}, T>(
             whereValue?: TObject
         ): T;
     }
 
+    //_.mean
+    interface LoDashStatic {
+        /**
+         * Computes the mean of the values in `array`.
+         *
+         * @static
+         * @memberOf _
+         * @category Math
+         * @param {Array} array The array to iterate over.
+         * @returns {number} Returns the mean.
+         * @example
+         *
+         * _.mean([4, 2, 8, 6]);
+         * // => 5
+         */
+        mean<T>(
+            collection: List<T>
+        ): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.mean
+         */
+        mean<T>(): number;
+
+        /**
+         * @see _.mean
+         */
+        mean(): number;
+    }
+
     //_.min
     interface LoDashStatic {
         /**
-         * Gets the minimum value of collection. If collection is empty or falsey Infinity is returned. If an iteratee
-         * function is provided it’s invoked for each value in collection to generate the criterion by which the value
-         * is ranked. The iteratee is bound to thisArg and invoked with three arguments: (value, index, collection).
+         * Computes the minimum value of `array`. If `array` is empty or falsey
+         * `undefined` is returned.
          *
-         * If a property name is provided for iteratee the created _.property style callback returns the property value
-         * of the given element.
-         *
-         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
-         * elements that have a matching property value, else false.
-         *
-         * If an object is provided for iteratee the created _.matches style callback returns true for elements that
-         * have the properties of the given object, else false.
-         *
-         * @param collection The collection to iterate over.
-         * @param iteratee The function invoked per iteration.
-         * @param thisArg The this binding of iteratee.
-         * @return Returns the minimum value.
+         * @static
+         * @memberOf _
+         * @category Math
+         * @param {Array} array The array to iterate over.
+         * @returns {*} Returns the minimum value.
          */
         min<T>(
-            collection: List<T>,
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.min
-         */
-        min<T>(
-            collection: Dictionary<T>,
-            iteratee?: DictionaryIterator<T, any>,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.min
-         */
-        min<T>(
-            collection: List<T>|Dictionary<T>,
-            iteratee?: string,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.min
-         */
-        min<TObject extends {}, T>(
-            collection: List<T>|Dictionary<T>,
-            whereValue?: TObject
+            collection: List<T>
         ): T;
     }
 
@@ -11365,48 +11417,114 @@ declare module _ {
         /**
          * @see _.min
          */
-        min(
-            iteratee?: ListIterator<T, any>,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.min
-         */
-        min(
-            iteratee?: string,
-            thisArg?: any
-        ): T;
-
-        /**
-         * @see _.min
-         */
-        min<TObject extends {}>(
-            whereValue?: TObject
-        ): T;
+        min(): T;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
          * @see _.min
          */
-        min<T>(
+        min<T>(): T;
+    }
+
+    //_.minBy
+    interface LoDashStatic {
+        /**
+         * This method is like `_.min` except that it accepts `iteratee` which is
+         * invoked for each element in `array` to generate the criterion by which
+         * the value is ranked. The iteratee is invoked with one argument: (value).
+         *
+         * @static
+         * @memberOf _
+         * @category Math
+         * @param {Array} array The array to iterate over.
+         * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+         * @returns {*} Returns the minimum value.
+         * @example
+         *
+         * var objects = [{ 'n': 1 }, { 'n': 2 }];
+         *
+         * _.minBy(objects, function(o) { return o.a; });
+         * // => { 'n': 1 }
+         *
+         * // using the `_.property` iteratee shorthand
+         * _.minBy(objects, 'n');
+         * // => { 'n': 1 }
+         */
+        minBy<T>(
+            collection: List<T>,
+            iteratee?: ListIterator<T, any>
+        ): T;
+
+        /**
+         * @see _.minBy
+         */
+        minBy<T>(
+            collection: Dictionary<T>,
+            iteratee?: DictionaryIterator<T, any>
+        ): T;
+
+        /**
+         * @see _.minBy
+         */
+        minBy<T>(
+            collection: List<T>|Dictionary<T>,
+            iteratee?: string
+        ): T;
+
+        /**
+         * @see _.minBy
+         */
+        minBy<TObject extends {}, T>(
+            collection: List<T>|Dictionary<T>,
+            whereValue?: TObject
+        ): T;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.minBy
+         */
+        minBy(
+            iteratee?: ListIterator<T, any>
+        ): T;
+
+        /**
+         * @see _.minBy
+         */
+        minBy(
+            iteratee?: string
+        ): T;
+
+        /**
+         * @see _.minBy
+         */
+        minBy<TObject extends {}>(
+            whereValue?: TObject
+        ): T;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.minBy
+         */
+        minBy<T>(
             iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>,
             thisArg?: any
         ): T;
 
         /**
-         * @see _.min
+         * @see _.minBy
          */
-        min<T>(
+        minBy<T>(
             iteratee?: string,
             thisArg?: any
         ): T;
 
         /**
-         * @see _.min
+         * @see _.minBy
          */
-        min<TObject extends {}, T>(
+        minBy<TObject extends {}, T>(
             whereValue?: TObject
         ): T;
     }
@@ -11443,40 +11561,19 @@ declare module _ {
     //_.sum
     interface LoDashStatic {
         /**
-         * Gets the sum of the values in collection.
+         * Computes the sum of the values in `array`.
          *
-         * @param collection The collection to iterate over.
-         * @param iteratee The function invoked per iteration.
-         * @param thisArg The this binding of iteratee.
-         * @return Returns the sum.
+         * @static
+         * @memberOf _
+         * @category Math
+         * @param {Array} array The array to iterate over.
+         * @returns {number} Returns the sum.
+         * @example
+         *
+         * _.sum([4, 2, 8, 6]);
+         * // => 20
          */
-        sum<T>(
-            collection: List<T>,
-            iteratee: ListIterator<T, number>,
-            thisArg?: any
-        ): number;
-
-        /**
-         * @see _.sum
-         **/
-        sum<T>(
-            collection: Dictionary<T>,
-            iteratee: DictionaryIterator<T, number>,
-            thisArg?: any
-        ): number;
-
-        /**
-         * @see _.sum
-         */
-        sum<T>(
-            collection: List<number>|Dictionary<number>,
-            iteratee: string
-        ): number;
-
-        /**
-         * @see _.sum
-         */
-        sum<T>(collection: List<T>|Dictionary<T>): number;
+        sum<T>(collection: List<T>): number;
 
         /**
          * @see _.sum
@@ -11485,19 +11582,6 @@ declare module _ {
     }
 
     interface LoDashImplicitArrayWrapper<T> {
-        /**
-         * @see _.sum
-         */
-        sum(
-            iteratee: ListIterator<T, number>,
-            thisArg?: any
-        ): number;
-
-        /**
-         * @see _.sum
-         */
-        sum(iteratee: string): number;
-
         /**
          * @see _.sum
          */
@@ -11508,15 +11592,7 @@ declare module _ {
         /**
          * @see _.sum
          **/
-        sum<TValue>(
-            iteratee: ListIterator<TValue, number>|DictionaryIterator<TValue, number>,
-            thisArg?: any
-        ): number;
-
-        /**
-         * @see _.sum
-         */
-        sum(iteratee: string): number;
+        sum<TValue>(): number;
 
         /**
          * @see _.sum
@@ -11525,19 +11601,6 @@ declare module _ {
     }
 
     interface LoDashExplicitArrayWrapper<T> {
-        /**
-         * @see _.sum
-         */
-        sum(
-            iteratee: ListIterator<T, number>,
-            thisArg?: any
-        ): LoDashExplicitWrapper<number>;
-
-        /**
-         * @see _.sum
-         */
-        sum(iteratee: string): LoDashExplicitWrapper<number>;
-
         /**
          * @see _.sum
          */
@@ -11548,15 +11611,7 @@ declare module _ {
         /**
          * @see _.sum
          */
-        sum<TValue>(
-            iteratee: ListIterator<TValue, number>|DictionaryIterator<TValue, number>,
-            thisArg?: any
-        ): LoDashExplicitWrapper<number>;
-
-        /**
-         * @see _.sum
-         */
-        sum(iteratee: string): LoDashExplicitWrapper<number>;
+        sum<TValue>(): LoDashExplicitWrapper<number>;
 
         /**
          * @see _.sum
@@ -11564,10 +11619,229 @@ declare module _ {
         sum(): LoDashExplicitWrapper<number>;
     }
 
+    //_.sumBy
+    interface LoDashStatic {
+        /**
+         * This method is like `_.sum` except that it accepts `iteratee` which is
+         * invoked for each element in `array` to generate the value to be summed.
+         * The iteratee is invoked with one argument: (value).
+         *
+         * @static
+         * @memberOf _
+         * @category Math
+         * @param {Array} array The array to iterate over.
+         * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+         * @returns {number} Returns the sum.
+         * @example
+         *
+         * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
+         *
+         * _.sumBy(objects, function(o) { return o.n; });
+         * // => 20
+         *
+         * // using the `_.property` iteratee shorthand
+         * _.sumBy(objects, 'n');
+         * // => 20
+         */
+        sumBy<T>(
+            collection: List<T>,
+            iteratee: ListIterator<T, number>
+        ): number;
+
+        /**
+         * @see _.sumBy
+         **/
+        sumBy<T>(
+            collection: Dictionary<T>,
+            iteratee: DictionaryIterator<T, number>
+        ): number;
+
+        /**
+         * @see _.sumBy
+         */
+        sumBy<T>(
+            collection: List<number>|Dictionary<number>,
+            iteratee: string
+        ): number;
+
+        /**
+         * @see _.sumBy
+         */
+        sumBy<T>(collection: List<T>|Dictionary<T>): number;
+
+        /**
+         * @see _.sumBy
+         */
+        sumBy(collection: List<number>|Dictionary<number>): number;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.sumBy
+         */
+        sumBy(
+            iteratee: ListIterator<T, number>
+        ): number;
+
+        /**
+         * @see _.sumBy
+         */
+        sumBy(iteratee: string): number;
+
+        /**
+         * @see _.sumBy
+         */
+        sumBy(): number;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.sumBy
+         **/
+        sumBy<TValue>(
+            iteratee: ListIterator<TValue, number>|DictionaryIterator<TValue, number>
+        ): number;
+
+        /**
+         * @see _.sumBy
+         */
+        sumBy(iteratee: string): number;
+
+        /**
+         * @see _.sumBy
+         */
+        sumBy(): number;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.sumBy
+         */
+        sumBy(
+            iteratee: ListIterator<T, number>
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sumBy
+         */
+        sumBy(iteratee: string): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sumBy
+         */
+        sumBy(): LoDashExplicitWrapper<number>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.sumBy
+         */
+        sumBy<TValue>(
+            iteratee: ListIterator<TValue, number>|DictionaryIterator<TValue, number>
+        ): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sumBy
+         */
+        sumBy(iteratee: string): LoDashExplicitWrapper<number>;
+
+        /**
+         * @see _.sumBy
+         */
+        sumBy(): LoDashExplicitWrapper<number>;
+    }
+
     /**********
      * Number *
      **********/
 
+    //_.subtract
+    interface LoDashStatic {
+        /**
+         * Subtract two numbers.
+         *
+         * @static
+         * @memberOf _
+         * @category Math
+         * @param {number} minuend The first number in a subtraction.
+         * @param {number} subtrahend The second number in a subtraction.
+         * @returns {number} Returns the difference.
+         * @example
+         *
+         * _.subtract(6, 4);
+         * // => 2
+         */
+        subtract(
+            minuend: number,
+            subtrahend: number
+        ): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.subtract
+         */
+        subtract(
+            subtrahend: number
+        ): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.subtract
+         */
+        subtract(
+            subtrahend: number
+        ): LoDashExplicitWrapper<number>;
+    }
+
+    //_.clamp
+    interface LoDashStatic {
+        /**
+         * Clamps `number` within the inclusive `lower` and `upper` bounds.
+         *
+         * @static
+         * @memberOf _
+         * @category Number
+         * @param {number} number The number to clamp.
+         * @param {number} [lower] The lower bound.
+         * @param {number} upper The upper bound.
+         * @returns {number} Returns the clamped number.
+         * @example
+         *
+         * _.clamp(-10, -5, 5);
+         * // => -5
+         *
+         * _.clamp(10, -5, 5);
+         * // => 5
+         */
+        clamp(
+            number: number,
+            lower: number,
+            upper: number
+        ): number;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.clamp
+         */
+        clamp(
+            lower: number,
+            upper: number
+        ): number;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.clamp
+         */
+        clamp(
+            lower: number,
+            upper: number
+        ): LoDashExplicitWrapper<number>;
+    }
+
     //_.inRange
     interface LoDashStatic {
         /**
@@ -11692,32 +11966,40 @@ declare module _ {
      **********/
 
     //_.assign
-    interface AssignCustomizer {
-        (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}): any;
-    }
-
     interface LoDashStatic {
         /**
-         * Assigns own enumerable properties of source object(s) to the destination object. Subsequent sources
-         * overwrite property assignments of previous sources. If customizer is provided it’s invoked to produce the
-         * assigned values. The customizer is bound to thisArg and invoked with five arguments:
-         * (objectValue, sourceValue, key, object, source).
+         * Assigns own enumerable properties of source objects to the destination
+         * object. Source objects are applied from left to right. Subsequent sources
+         * overwrite property assignments of previous sources.
          *
-         * Note: This method mutates object and is based on Object.assign.
+         * **Note:** This method mutates `object` and is loosely based on
+         * [`Object.assign`](https://mdn.io/Object/assign).
          *
-         * @alias _.extend
+         * @static
+         * @memberOf _
+         * @category Object
+         * @param {Object} object The destination object.
+         * @param {...Object} [sources] The source objects.
+         * @returns {Object} Returns `object`.
+         * @example
          *
-         * @param object The destination object.
-         * @param source The source objects.
-         * @param customizer The function to customize assigned values.
-         * @param thisArg The this binding of callback.
-         * @return The destination object.
+         * function Foo() {
+         *   this.c = 3;
+         * }
+         *
+         * function Bar() {
+         *   this.e = 5;
+         * }
+         *
+         * Foo.prototype.d = 4;
+         * Bar.prototype.f = 6;
+         *
+         * _.assign({ 'a': 1 }, new Foo, new Bar);
+         * // => { 'a': 1, 'c': 3, 'e': 5 }
          */
         assign<TObject extends {}, TSource extends {}, TResult extends {}>(
             object: TObject,
-            source: TSource,
-            customizer?: AssignCustomizer,
-            thisArg?: any
+            source: TSource
         ): TResult;
 
         /**
@@ -11726,9 +12008,7 @@ declare module _ {
         assign<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
             object: TObject,
             source1: TSource1,
-            source2: TSource2,
-            customizer?: AssignCustomizer,
-            thisArg?: any
+            source2: TSource2
         ): TResult;
 
         /**
@@ -11738,9 +12018,7 @@ declare module _ {
             object: TObject,
             source1: TSource1,
             source2: TSource2,
-            source3: TSource3,
-            customizer?: AssignCustomizer,
-            thisArg?: any
+            source3: TSource3
         ): TResult;
 
         /**
@@ -11753,9 +12031,7 @@ declare module _ {
             source1: TSource1,
             source2: TSource2,
             source3: TSource3,
-            source4: TSource4,
-            customizer?: AssignCustomizer,
-            thisArg?: any
+            source4: TSource4
         ): TResult;
 
         /**
@@ -11776,9 +12052,7 @@ declare module _ {
          * @see _.assign
          */
         assign<TSource extends {}, TResult extends {}>(
-            source: TSource,
-            customizer?: AssignCustomizer,
-            thisArg?: any
+            source: TSource
         ): LoDashImplicitObjectWrapper<TResult>;
 
         /**
@@ -11786,9 +12060,7 @@ declare module _ {
          */
         assign<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
             source1: TSource1,
-            source2: TSource2,
-            customizer?: AssignCustomizer,
-            thisArg?: any
+            source2: TSource2
         ): LoDashImplicitObjectWrapper<TResult>;
 
         /**
@@ -11797,9 +12069,7 @@ declare module _ {
         assign<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
             source1: TSource1,
             source2: TSource2,
-            source3: TSource3,
-            customizer?: AssignCustomizer,
-            thisArg?: any
+            source3: TSource3
         ): LoDashImplicitObjectWrapper<TResult>;
 
         /**
@@ -11809,9 +12079,7 @@ declare module _ {
             source1: TSource1,
             source2: TSource2,
             source3: TSource3,
-            source4: TSource4,
-            customizer?: AssignCustomizer,
-            thisArg?: any
+            source4: TSource4
         ): LoDashImplicitObjectWrapper<TResult>;
 
         /**
@@ -11830,9 +12098,7 @@ declare module _ {
          * @see _.assign
          */
         assign<TSource extends {}, TResult extends {}>(
-            source: TSource,
-            customizer?: AssignCustomizer,
-            thisArg?: any
+            source: TSource
         ): LoDashExplicitObjectWrapper<TResult>;
 
         /**
@@ -11840,9 +12106,7 @@ declare module _ {
          */
         assign<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
             source1: TSource1,
-            source2: TSource2,
-            customizer?: AssignCustomizer,
-            thisArg?: any
+            source2: TSource2
         ): LoDashExplicitObjectWrapper<TResult>;
 
         /**
@@ -11851,9 +12115,7 @@ declare module _ {
         assign<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
             source1: TSource1,
             source2: TSource2,
-            source3: TSource3,
-            customizer?: AssignCustomizer,
-            thisArg?: any
+            source3: TSource3
         ): LoDashExplicitObjectWrapper<TResult>;
 
         /**
@@ -11863,9 +12125,7 @@ declare module _ {
             source1: TSource1,
             source2: TSource2,
             source3: TSource3,
-            source4: TSource4,
-            customizer?: AssignCustomizer,
-            thisArg?: any
+            source4: TSource4
         ): LoDashExplicitObjectWrapper<TResult>;
 
         /**
@@ -11879,6 +12139,552 @@ declare module _ {
         assign<TResult extends {}>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
     }
 
+    //_.assignWith
+    interface AssignCustomizer {
+        (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}): any;
+    }
+
+    interface LoDashStatic {
+        /**
+         * This method is like `_.assign` except that it accepts `customizer` which
+         * is invoked to produce the assigned values. If `customizer` returns `undefined`
+         * assignment is handled by the method instead. The `customizer` is invoked
+         * with five arguments: (objValue, srcValue, key, object, source).
+         *
+         * **Note:** This method mutates `object`.
+         *
+         * @static
+         * @memberOf _
+         * @category Object
+         * @param {Object} object The destination object.
+         * @param {...Object} sources The source objects.
+         * @param {Function} [customizer] The function to customize assigned values.
+         * @returns {Object} Returns `object`.
+         * @example
+         *
+         * function customizer(objValue, srcValue) {
+         *   return _.isUndefined(objValue) ? srcValue : objValue;
+         * }
+         *
+         * var defaults = _.partialRight(_.assignWith, customizer);
+         *
+         * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
+         * // => { 'a': 1, 'b': 2 }
+         */
+        assignWith<TObject extends {}, TSource extends {}, TResult extends {}>(
+            object: TObject,
+            source: TSource,
+            customizer: AssignCustomizer
+        ): TResult;
+
+        /**
+         * @see assignWith
+         */
+        assignWith<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            customizer: AssignCustomizer
+        ): TResult;
+
+        /**
+         * @see assignWith
+         */
+        assignWith<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer: AssignCustomizer
+        ): TResult;
+
+        /**
+         * @see assignWith
+         */
+        assignWith<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {},
+            TResult extends {}>
+        (
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer: AssignCustomizer
+        ): TResult;
+
+        /**
+         * @see _.assignWith
+         */
+        assignWith<TObject extends {}>(object: TObject): TObject;
+
+        /**
+         * @see _.assignWith
+         */
+        assignWith<TObject extends {}, TResult extends {}>(
+            object: TObject, ...otherArgs: any[]
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.assignWith
+         */
+        assignWith<TSource extends {}, TResult extends {}>(
+            source: TSource,
+            customizer: AssignCustomizer
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignWith
+         */
+        assignWith<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            customizer: AssignCustomizer
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignWith
+         */
+        assignWith<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer: AssignCustomizer
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignWith
+         */
+        assignWith<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer: AssignCustomizer
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.assignWith
+         */
+        assignWith(): LoDashImplicitObjectWrapper<T>;
+
+        /**
+         * @see _.assignWith
+         */
+        assignWith<TResult extends {}>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.assignWith
+         */
+        assignWith<TSource extends {}, TResult extends {}>(
+            source: TSource,
+            customizer: AssignCustomizer
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignWith
+         */
+        assignWith<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            customizer: AssignCustomizer
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignWith
+         */
+        assignWith<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer: AssignCustomizer
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignWith
+         */
+        assignWith<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer: AssignCustomizer
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.assignWith
+         */
+        assignWith(): LoDashExplicitObjectWrapper<T>;
+
+        /**
+         * @see _.assignWith
+         */
+        assignWith<TResult extends {}>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.assignIn
+    interface LoDashStatic {
+        /**
+         * This method is like `_.assign` except that it iterates over own and
+         * inherited source properties.
+         *
+         * **Note:** This method mutates `object`.
+         *
+         * @static
+         * @memberOf _
+         * @alias extend
+         * @category Object
+         * @param {Object} object The destination object.
+         * @param {...Object} [sources] The source objects.
+         * @returns {Object} Returns `object`.
+         * @example
+         *
+         * function Foo() {
+         *   this.b = 2;
+         * }
+         *
+         * function Bar() {
+         *   this.d = 4;
+         * }
+         *
+         * Foo.prototype.c = 3;
+         * Bar.prototype.e = 5;
+         *
+         * _.assignIn({ 'a': 1 }, new Foo, new Bar);
+         * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5 }
+         */
+        assignIn<TObject extends {}, TSource extends {}, TResult extends {}>(
+            object: TObject,
+            source: TSource
+        ): TResult;
+
+        /**
+         * @see assignIn
+         */
+        assignIn<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2
+        ): TResult;
+
+        /**
+         * @see assignIn
+         */
+        assignIn<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3
+        ): TResult;
+
+        /**
+         * @see assignIn
+         */
+        assignIn<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {},
+            TResult extends {}>
+        (
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4
+        ): TResult;
+
+        /**
+         * @see _.assignIn
+         */
+        assignIn<TObject extends {}>(object: TObject): TObject;
+
+        /**
+         * @see _.assignIn
+         */
+        assignIn<TObject extends {}, TResult extends {}>(
+            object: TObject, ...otherArgs: any[]
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.assignIn
+         */
+        assignIn<TSource extends {}, TResult extends {}>(
+            source: TSource
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignIn
+         */
+        assignIn<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignIn
+         */
+        assignIn<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignIn
+         */
+        assignIn<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.assignIn
+         */
+        assignIn(): LoDashImplicitObjectWrapper<T>;
+
+        /**
+         * @see _.assignIn
+         */
+        assignIn<TResult extends {}>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.assignIn
+         */
+        assignIn<TSource extends {}, TResult extends {}>(
+            source: TSource
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignIn
+         */
+        assignIn<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignIn
+         */
+        assignIn<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignIn
+         */
+        assignIn<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.assignIn
+         */
+        assignIn(): LoDashExplicitObjectWrapper<T>;
+
+        /**
+         * @see _.assignIn
+         */
+        assignIn<TResult extends {}>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.assignInWith
+    interface AssignCustomizer {
+        (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}): any;
+    }
+
+    interface LoDashStatic {
+        /**
+         * This method is like `_.assignIn` except that it accepts `customizer` which
+         * is invoked to produce the assigned values. If `customizer` returns `undefined`
+         * assignment is handled by the method instead. The `customizer` is invoked
+         * with five arguments: (objValue, srcValue, key, object, source).
+         *
+         * **Note:** This method mutates `object`.
+         *
+         * @static
+         * @memberOf _
+         * @alias extendWith
+         * @category Object
+         * @param {Object} object The destination object.
+         * @param {...Object} sources The source objects.
+         * @param {Function} [customizer] The function to customize assigned values.
+         * @returns {Object} Returns `object`.
+         * @example
+         *
+         * function customizer(objValue, srcValue) {
+         *   return _.isUndefined(objValue) ? srcValue : objValue;
+         * }
+         *
+         * var defaults = _.partialRight(_.assignInWith, customizer);
+         *
+         * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
+         * // => { 'a': 1, 'b': 2 }
+         */
+        assignInWith<TObject extends {}, TSource extends {}, TResult extends {}>(
+            object: TObject,
+            source: TSource,
+            customizer: AssignCustomizer
+        ): TResult;
+
+        /**
+         * @see assignInWith
+         */
+        assignInWith<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            customizer: AssignCustomizer
+        ): TResult;
+
+        /**
+         * @see assignInWith
+         */
+        assignInWith<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer: AssignCustomizer
+        ): TResult;
+
+        /**
+         * @see assignInWith
+         */
+        assignInWith<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {},
+            TResult extends {}>
+        (
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer: AssignCustomizer
+        ): TResult;
+
+        /**
+         * @see _.assignInWith
+         */
+        assignInWith<TObject extends {}>(object: TObject): TObject;
+
+        /**
+         * @see _.assignInWith
+         */
+        assignInWith<TObject extends {}, TResult extends {}>(
+            object: TObject, ...otherArgs: any[]
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.assignInWith
+         */
+        assignInWith<TSource extends {}, TResult extends {}>(
+            source: TSource,
+            customizer: AssignCustomizer
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignInWith
+         */
+        assignInWith<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            customizer: AssignCustomizer
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignInWith
+         */
+        assignInWith<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer: AssignCustomizer
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignInWith
+         */
+        assignInWith<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer: AssignCustomizer
+        ): LoDashImplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.assignInWith
+         */
+        assignInWith(): LoDashImplicitObjectWrapper<T>;
+
+        /**
+         * @see _.assignInWith
+         */
+        assignInWith<TResult extends {}>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.assignInWith
+         */
+        assignInWith<TSource extends {}, TResult extends {}>(
+            source: TSource,
+            customizer: AssignCustomizer
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignInWith
+         */
+        assignInWith<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            customizer: AssignCustomizer
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignInWith
+         */
+        assignInWith<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer: AssignCustomizer
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see assignInWith
+         */
+        assignInWith<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer: AssignCustomizer
+        ): LoDashExplicitObjectWrapper<TResult>;
+
+        /**
+         * @see _.assignInWith
+         */
+        assignInWith(): LoDashExplicitObjectWrapper<T>;
+
+        /**
+         * @see _.assignInWith
+         */
+        assignInWith<TResult extends {}>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
+    }
+
     //_.create
     interface LoDashStatic {
         /**
@@ -12697,12 +13503,25 @@ declare module _ {
     //_.functions
     interface LoDashStatic {
         /**
-         * Creates an array of function property names from all enumerable properties, own and inherited, of object.
+         * Creates an array of function property names from own enumerable properties
+         * of `object`.
          *
-         * @alias _.methods
+         * @static
+         * @memberOf _
+         * @category Object
+         * @param {Object} object The object to inspect.
+         * @returns {Array} Returns the new array of property names.
+         * @example
          *
-         * @param object The object to inspect.
-         * @return Returns the new array of property names.
+         * function Foo() {
+         *   this.a = _.constant('a');
+         *   this.b = _.constant('b');
+         * }
+         *
+         * Foo.prototype.c = _.constant('c');
+         *
+         * _.functions(new Foo);
+         * // => ['a', 'b']
          */
         functions<T extends {}>(object: any): string[];
     }
@@ -12721,6 +13540,46 @@ declare module _ {
         functions(): _.LoDashExplicitArrayWrapper<string>;
     }
 
+    //_.functionsIn
+    interface LoDashStatic {
+        /**
+         * Creates an array of function property names from own and inherited
+         * enumerable properties of `object`.
+         *
+         * @static
+         * @memberOf _
+         * @category Object
+         * @param {Object} object The object to inspect.
+         * @returns {Array} Returns the new array of property names.
+         * @example
+         *
+         * function Foo() {
+         *   this.a = _.constant('a');
+         *   this.b = _.constant('b');
+         * }
+         *
+         * Foo.prototype.c = _.constant('c');
+         *
+         * _.functionsIn(new Foo);
+         * // => ['a', 'b', 'c']
+         */
+        functionsIn<T extends {}>(object: any): string[];
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.functionsIn
+         */
+        functionsIn(): _.LoDashImplicitArrayWrapper<string>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.functionsIn
+         */
+        functionsIn(): _.LoDashExplicitArrayWrapper<string>;
+    }
+
     //_.get
     interface LoDashStatic {
         /**
@@ -12749,11 +13608,30 @@ declare module _ {
     //_.has
     interface LoDashStatic {
         /**
-         * Checks if path is a direct property.
+         * Checks if `path` is a direct property of `object`.
          *
-         * @param object The object to query.
-         * @param path The path to check.
-         * @return Returns true if path is a direct property, else false.
+         * @static
+         * @memberOf _
+         * @category Object
+         * @param {Object} object The object to query.
+         * @param {Array|string} path The path to check.
+         * @returns {boolean} Returns `true` if `path` exists, else `false`.
+         * @example
+         *
+         * var object = { 'a': { 'b': { 'c': 3 } } };
+         * var other = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) });
+         *
+         * _.has(object, 'a');
+         * // => true
+         *
+         * _.has(object, 'a.b.c');
+         * // => true
+         *
+         * _.has(object, ['a', 'b', 'c']);
+         * // => true
+         *
+         * _.has(other, 'a');
+         * // => false
          */
         has<T extends {}>(
             object: T,
@@ -12775,6 +13653,53 @@ declare module _ {
         has(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper<boolean>;
     }
 
+    //_.hasIn
+    interface LoDashStatic {
+        /**
+         * Checks if `path` is a direct or inherited property of `object`.
+         *
+         * @static
+         * @memberOf _
+         * @category Object
+         * @param {Object} object The object to query.
+         * @param {Array|string} path The path to check.
+         * @returns {boolean} Returns `true` if `path` exists, else `false`.
+         * @example
+         *
+         * var object = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) });
+         *
+         * _.hasIn(object, 'a');
+         * // => true
+         *
+         * _.hasIn(object, 'a.b.c');
+         * // => true
+         *
+         * _.hasIn(object, ['a', 'b', 'c']);
+         * // => true
+         *
+         * _.hasIn(object, 'b');
+         * // => false
+         */
+        hasIn<T extends {}>(
+            object: T,
+            path: StringRepresentable|StringRepresentable[]
+        ): boolean;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.hasIn
+         */
+        hasIn(path: StringRepresentable|StringRepresentable[]): boolean;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.hasIn
+         */
+        hasIn(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper<boolean>;
+    }
+
     //_.invert
     interface LoDashStatic {
         /**
@@ -13069,29 +13994,39 @@ declare module _ {
     }
 
     //_.merge
-    interface MergeCustomizer {
-        (value: any, srcValue: any, key?: string, object?: Object, source?: Object): any;
-    }
-
     interface LoDashStatic {
         /**
-         * Recursively merges own enumerable properties of the source object(s), that don’t resolve to undefined into
-         * the destination object. Subsequent sources overwrite property assignments of previous sources. If customizer
-         * is provided it’s invoked to produce the merged values of the destination and source properties. If
-         * customizer returns undefined merging is handled by the method instead. The customizer is bound to thisArg
-         * and invoked with five arguments: (objectValue, sourceValue, key, object, source).
+         * Recursively merges own and inherited enumerable properties of source
+         * objects into the destination object, skipping source properties that resolve
+         * to `undefined`. Array and plain object properties are merged recursively.
+         * Other objects and value types are overridden by assignment. Source objects
+         * are applied from left to right. Subsequent sources overwrite property
+         * assignments of previous sources.
          *
-         * @param object The destination object.
-         * @param source The source objects.
-         * @param customizer The function to customize assigned values.
-         * @param thisArg The this binding of customizer.
-         * @return Returns object.
+         * **Note:** This method mutates `object`.
+         *
+         * @static
+         * @memberOf _
+         * @category Object
+         * @param {Object} object The destination object.
+         * @param {...Object} [sources] The source objects.
+         * @returns {Object} Returns `object`.
+         * @example
+         *
+         * var users = {
+         *   'data': [{ 'user': 'barney' }, { 'user': 'fred' }]
+         * };
+         *
+         * var ages = {
+         *   'data': [{ 'age': 36 }, { 'age': 40 }]
+         * };
+         *
+         * _.merge(users, ages);
+         * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }
          */
         merge<TObject, TSource>(
             object: TObject,
-            source: TSource,
-            customizer?: MergeCustomizer,
-            thisArg?: any
+            source: TSource
         ): TObject & TSource;
 
         /**
@@ -13100,9 +14035,7 @@ declare module _ {
         merge<TObject, TSource1, TSource2>(
             object: TObject,
             source1: TSource1,
-            source2: TSource2,
-            customizer?: MergeCustomizer,
-            thisArg?: any
+            source2: TSource2
         ): TObject & TSource1 & TSource2;
 
         /**
@@ -13112,9 +14045,7 @@ declare module _ {
             object: TObject,
             source1: TSource1,
             source2: TSource2,
-            source3: TSource3,
-            customizer?: MergeCustomizer,
-            thisArg?: any
+            source3: TSource3
         ): TObject & TSource1 & TSource2 & TSource3;
 
         /**
@@ -13125,9 +14056,7 @@ declare module _ {
             source1: TSource1,
             source2: TSource2,
             source3: TSource3,
-            source4: TSource4,
-            customizer?: MergeCustomizer,
-            thisArg?: any
+            source4: TSource4
         ): TObject & TSource1 & TSource2 & TSource3 & TSource4;
 
         /**
@@ -13144,9 +14073,7 @@ declare module _ {
          * @see _.merge
          */
         merge<TSource>(
-            source: TSource,
-            customizer?: MergeCustomizer,
-            thisArg?: any
+            source: TSource
         ): LoDashImplicitObjectWrapper<T & TSource>;
 
         /**
@@ -13154,9 +14081,7 @@ declare module _ {
          */
         merge<TSource1, TSource2>(
             source1: TSource1,
-            source2: TSource2,
-            customizer?: MergeCustomizer,
-            thisArg?: any
+            source2: TSource2
         ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;
 
         /**
@@ -13165,9 +14090,7 @@ declare module _ {
         merge<TSource1, TSource2, TSource3>(
             source1: TSource1,
             source2: TSource2,
-            source3: TSource3,
-            customizer?: MergeCustomizer,
-            thisArg?: any
+            source3: TSource3
         ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
 
         /**
@@ -13177,9 +14100,7 @@ declare module _ {
             source1: TSource1,
             source2: TSource2,
             source3: TSource3,
-            source4: TSource4,
-            customizer?: MergeCustomizer,
-            thisArg?: any
+            source4: TSource4
         ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
 
         /**
@@ -13195,9 +14116,7 @@ declare module _ {
          * @see _.merge
          */
         merge<TSource>(
-            source: TSource,
-            customizer?: MergeCustomizer,
-            thisArg?: any
+            source: TSource
         ): LoDashExplicitObjectWrapper<T & TSource>;
 
         /**
@@ -13205,9 +14124,7 @@ declare module _ {
          */
         merge<TSource1, TSource2>(
             source1: TSource1,
-            source2: TSource2,
-            customizer?: MergeCustomizer,
-            thisArg?: any
+            source2: TSource2
         ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>;
 
         /**
@@ -13216,21 +14133,13 @@ declare module _ {
         merge<TSource1, TSource2, TSource3>(
             source1: TSource1,
             source2: TSource2,
-            source3: TSource3,
-            customizer?: MergeCustomizer,
-            thisArg?: any
+            source3: TSource3
         ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
 
         /**
          * @see _.merge
          */
         merge<TSource1, TSource2, TSource3, TSource4>(
-            source1: TSource1,
-            source2: TSource2,
-            source3: TSource3,
-            source4: TSource4,
-            customizer?: MergeCustomizer,
-            thisArg?: any
         ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
 
         /**
@@ -13241,49 +14150,163 @@ declare module _ {
         ): LoDashExplicitObjectWrapper<TResult>;
     }
 
-    //_.methods
+    //_.mergeWith
+    interface MergeWithCustomizer {
+        (value: any, srcValue: any, key?: string, object?: Object, source?: Object): any;
+    }
+
     interface LoDashStatic {
         /**
-         * @see _.functions
+         * This method is like `_.merge` except that it accepts `customizer` which
+         * is invoked to produce the merged values of the destination and source
+         * properties. If `customizer` returns `undefined` merging is handled by the
+         * method instead. The `customizer` is invoked with seven arguments:
+         * (objValue, srcValue, key, object, source, stack).
+         *
+         * @static
+         * @memberOf _
+         * @category Object
+         * @param {Object} object The destination object.
+         * @param {...Object} sources The source objects.
+         * @param {Function} customizer The function to customize assigned values.
+         * @returns {Object} Returns `object`.
+         * @example
+         *
+         * function customizer(objValue, srcValue) {
+         *   if (_.isArray(objValue)) {
+         *     return objValue.concat(srcValue);
+         *   }
+         * }
+         *
+         * var object = {
+         *   'fruits': ['apple'],
+         *   'vegetables': ['beet']
+         * };
+         *
+         * var other = {
+         *   'fruits': ['banana'],
+         *   'vegetables': ['carrot']
+         * };
+         *
+         * _.merge(object, other, customizer);
+         * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] }
          */
-        methods<T extends {}>(object: any): string[];
+        mergeWith<TObject, TSource>(
+            object: TObject,
+            source: TSource,
+            customizer: MergeWithCustomizer
+        ): TObject & TSource;
+
+        /**
+         * @see _.mergeWith
+         */
+        mergeWith<TObject, TSource1, TSource2>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            customizer: MergeWithCustomizer
+        ): TObject & TSource1 & TSource2;
+
+        /**
+         * @see _.mergeWith
+         */
+        mergeWith<TObject, TSource1, TSource2, TSource3>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer: MergeWithCustomizer
+        ): TObject & TSource1 & TSource2 & TSource3;
+
+        /**
+         * @see _.mergeWith
+         */
+        mergeWith<TObject, TSource1, TSource2, TSource3, TSource4>(
+            object: TObject,
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer: MergeWithCustomizer
+        ): TObject & TSource1 & TSource2 & TSource3 & TSource4;
+
+        /**
+         * @see _.mergeWith
+         */
+        mergeWith<TResult>(
+            object: any,
+            ...otherArgs: any[]
+        ): TResult;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
-         * @see _.functions
+         * @see _.mergeWith
          */
-        methods(): _.LoDashImplicitArrayWrapper<string>;
-    }
+        mergeWith<TSource>(
+            source: TSource,
+            customizer: MergeWithCustomizer
+        ): LoDashImplicitObjectWrapper<T & TSource>;
 
-    interface LoDashExplicitObjectWrapper<T> {
         /**
-         * @see _.functions
+         * @see _.mergeWith
          */
-        methods(): _.LoDashExplicitArrayWrapper<string>;
+        mergeWith<TSource1, TSource2>(
+            source1: TSource1,
+            source2: TSource2,
+            customizer: MergeWithCustomizer
+        ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;
+
+        /**
+         * @see _.mergeWith
+         */
+        mergeWith<TSource1, TSource2, TSource3>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            customizer: MergeWithCustomizer
+        ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+        /**
+         * @see _.mergeWith
+         */
+        mergeWith<TSource1, TSource2, TSource3, TSource4>(
+            source1: TSource1,
+            source2: TSource2,
+            source3: TSource3,
+            source4: TSource4,
+            customizer: MergeWithCustomizer
+        ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+        /**
+         * @see _.mergeWith
+         */
+        mergeWith<TResult>(
+            ...otherArgs: any[]
+        ): LoDashImplicitObjectWrapper<TResult>;
     }
 
     //_.omit
     interface LoDashStatic {
         /**
-         * The opposite of _.pick; this method creates an object composed of the own and inherited enumerable
-         * properties of object that are not omitted.
+         * The opposite of `_.pick`; this method creates an object composed of the
+         * own and inherited enumerable properties of `object` that are not omitted.
          *
-         * @param object The source object.
-         * @param predicate The function invoked per iteration or property names to omit, specified as individual
-         * property names or arrays of property names.
-         * @param thisArg The this binding of predicate.
-         * @return Returns the new object.
+         * @static
+         * @memberOf _
+         * @category Object
+         * @param {Object} object The source object.
+         * @param {...(string|string[])} [props] The property names to omit, specified
+         *  individually or in arrays..
+         * @returns {Object} Returns the new object.
+         * @example
+         *
+         * var object = { 'a': 1, 'b': '2', 'c': 3 };
+         *
+         * _.omit(object, ['a', 'c']);
+         * // => { 'b': '2' }
          */
-        omit<TResult extends {}, T extends {}>(
-            object: T,
-            predicate: ObjectIterator<any, boolean>,
-            thisArg?: any
-        ): TResult;
 
-        /**
-         * @see _.omit
-         */
         omit<TResult extends {}, T extends {}>(
             object: T,
             ...predicate: (StringRepresentable|StringRepresentable[])[]
@@ -13291,13 +14314,6 @@ declare module _ {
     }
 
     interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.omit
-         */
-        omit<TResult extends {}>(
-            predicate: ObjectIterator<any, boolean>,
-            thisArg?: any
-        ): LoDashImplicitObjectWrapper<TResult>;
 
         /**
          * @see _.omit
@@ -13308,13 +14324,6 @@ declare module _ {
     }
 
     interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.omit
-         */
-        omit<TResult extends {}>(
-            predicate: ObjectIterator<any, boolean>,
-            thisArg?: any
-        ): LoDashExplicitObjectWrapper<TResult>;
 
         /**
          * @see _.omit
@@ -13324,7 +14333,51 @@ declare module _ {
         ): LoDashExplicitObjectWrapper<TResult>;
     }
 
-    //_.pairs
+    //_.omitBy
+    interface LoDashStatic {
+        /**
+         * The opposite of `_.pickBy`; this method creates an object composed of the
+         * own and inherited enumerable properties of `object` that `predicate`
+         * doesn't return truthy for.
+         *
+         * @static
+         * @memberOf _
+         * @category Object
+         * @param {Object} object The source object.
+         * @param {Function|Object|string} [predicate=_.identity] The function invoked per property.
+         * @returns {Object} Returns the new object.
+         * @example
+         *
+         * var object = { 'a': 1, 'b': '2', 'c': 3 };
+         *
+         * _.omitBy(object, _.isNumber);
+         * // => { 'b': '2' }
+         */
+        omitBy<TResult extends {}, T extends {}>(
+            object: T,
+            predicate: ObjectIterator<any, boolean>
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.omitBy
+         */
+        omitBy<TResult extends {}>(
+            predicate: ObjectIterator<any, boolean>
+        ): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.omitBy
+         */
+        omitBy<TResult extends {}>(
+            predicate: ObjectIterator<any, boolean>
+        ): LoDashExplicitObjectWrapper<TResult>;
+    }
+
+    //_.toPairs
     interface LoDashStatic {
         /**
          * Creates a two dimensional array of the key-value pairs for object, e.g. [[key1, value1], [key2, value2]].
@@ -13332,47 +14385,43 @@ declare module _ {
          * @param object The object to query.
          * @return Returns the new array of key-value pairs.
          */
-        pairs<T extends {}>(object?: T): any[][];
+        toPairs<T extends {}>(object?: T): any[][];
 
-        pairs<T extends {}, TResult>(object?: T): TResult[][];
+        toPairs<T extends {}, TResult>(object?: T): TResult[][];
     }
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
-         * @see _.pairs
+         * @see _.toPairs
          */
-        pairs<TResult>(): LoDashImplicitArrayWrapper<TResult[]>;
+        toPairs<TResult>(): LoDashImplicitArrayWrapper<TResult[]>;
     }
 
     interface LoDashExplicitObjectWrapper<T> {
         /**
-         * @see _.pairs
+         * @see _.toPairs
          */
-        pairs<TResult>(): LoDashExplicitArrayWrapper<TResult[]>;
+        toPairs<TResult>(): LoDashExplicitArrayWrapper<TResult[]>;
     }
 
     //_.pick
     interface LoDashStatic {
         /**
-         * Creates an object composed of the picked object properties. Property names may be specified as individual
-         * arguments or as arrays of property names. If predicate is provided it’s invoked for each property of object
-         * picking the properties predicate returns truthy for. The predicate is bound to thisArg and invoked with
-         * three arguments: (value, key, object).
+         * Creates an object composed of the picked `object` properties.
          *
-         * @param object The source object.
-         * @param predicate The function invoked per iteration or property names to pick, specified as individual
-         * property names or arrays of property names.
-         * @param thisArg The this binding of predicate.
-         * @return Returns the new object.
-         */
-        pick<TResult extends {}, T extends {}>(
-            object: T,
-            predicate: ObjectIterator<any, boolean>,
-            thisArg?: any
-        ): TResult;
-
-        /**
-         * @see _.pick
+         * @static
+         * @memberOf _
+         * @category Object
+         * @param {Object} object The source object.
+         * @param {...(string|string[])} [props] The property names to pick, specified
+         *  individually or in arrays.
+         * @returns {Object} Returns the new object.
+         * @example
+         *
+         * var object = { 'a': 1, 'b': '2', 'c': 3 };
+         *
+         * _.pick(object, ['a', 'c']);
+         * // => { 'a': 1, 'c': 3 }
          */
         pick<TResult extends {}, T extends {}>(
             object: T,
@@ -13381,14 +14430,6 @@ declare module _ {
     }
 
     interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.pick
-         */
-        pick<TResult extends {}>(
-            predicate: ObjectIterator<any, boolean>,
-            thisArg?: any
-        ): LoDashImplicitObjectWrapper<TResult>;
-
         /**
          * @see _.pick
          */
@@ -13398,14 +14439,6 @@ declare module _ {
     }
 
     interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.pick
-         */
-        pick<TResult extends {}>(
-            predicate: ObjectIterator<any, boolean>,
-            thisArg?: any
-        ): LoDashExplicitObjectWrapper<TResult>;
-
         /**
          * @see _.pick
          */
@@ -13414,6 +14447,49 @@ declare module _ {
         ): LoDashExplicitObjectWrapper<TResult>;
     }
 
+    //_.pickBy
+    interface LoDashStatic {
+        /**
+         * Creates an object composed of the `object` properties `predicate` returns
+         * truthy for. The predicate is invoked with one argument: (value).
+         *
+         * @static
+         * @memberOf _
+         * @category Object
+         * @param {Object} object The source object.
+         * @param {Function|Object|string} [predicate=_.identity] The function invoked per property.
+         * @returns {Object} Returns the new object.
+         * @example
+         *
+         * var object = { 'a': 1, 'b': '2', 'c': 3 };
+         *
+         * _.pickBy(object, _.isNumber);
+         * // => { 'a': 1, 'c': 3 }
+         */
+        pickBy<TResult extends {}, T extends {}>(
+            object: T,
+            predicate: ObjectIterator<any, boolean>
+        ): TResult;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        /**
+         * @see _.pickBy
+         */
+        pickBy<TResult extends {}>(
+            predicate: ObjectIterator<any, boolean>
+        ): LoDashImplicitObjectWrapper<TResult>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        /**
+         * @see _.pickBy
+         */
+        pickBy<TResult extends {}>(
+            predicate: ObjectIterator<any, boolean>
+        ): LoDashExplicitObjectWrapper<TResult>;
+    }
+
     //_.result
     interface LoDashStatic {
         /**
@@ -13828,6 +14904,79 @@ declare module _ {
         kebabCase(): LoDashExplicitWrapper<string>;
     }
 
+    //_.lowerCase
+    interface LoDashStatic {
+        /**
+         * Converts `string`, as space separated words, to lower case.
+         *
+         * @static
+         * @memberOf _
+         * @category String
+         * @param {string} [string=''] The string to convert.
+         * @returns {string} Returns the lower cased string.
+         * @example
+         *
+         * _.lowerCase('--Foo-Bar');
+         * // => 'foo bar'
+         *
+         * _.lowerCase('fooBar');
+         * // => 'foo bar'
+         *
+         * _.lowerCase('__FOO_BAR__');
+         * // => 'foo bar'
+         */
+        lowerCase(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.lowerCase
+         */
+        lowerCase(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.lowerCase
+         */
+        lowerCase(): LoDashExplicitWrapper<string>;
+    }
+
+    //_.lowerFirst
+    interface LoDashStatic {
+        /**
+         * Converts the first character of `string` to lower case.
+         *
+         * @static
+         * @memberOf _
+         * @category String
+         * @param {string} [string=''] The string to convert.
+         * @returns {string} Returns the converted string.
+         * @example
+         *
+         * _.lowerFirst('Fred');
+         * // => 'fred'
+         *
+         * _.lowerFirst('FRED');
+         * // => 'fRED'
+         */
+        lowerFirst(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.lowerFirst
+         */
+        lowerFirst(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.lowerFirst
+         */
+        lowerFirst(): LoDashExplicitWrapper<string>;
+    }
+
     //_.pad
     interface LoDashStatic {
         /**
@@ -13866,7 +15015,7 @@ declare module _ {
         ): LoDashExplicitWrapper<string>;
     }
 
-    //_.padLeft
+    //_.padStart
     interface LoDashStatic {
         /**
          * Pads string on the left side if it’s shorter than length. Padding characters are truncated if they exceed
@@ -13877,7 +15026,7 @@ declare module _ {
          * @param chars The string used as padding.
          * @return Returns the padded string.
          */
-        padLeft(
+        padStart(
             string?: string,
             length?: number,
             chars?: string
@@ -13886,9 +15035,9 @@ declare module _ {
 
     interface LoDashImplicitWrapper<T> {
         /**
-         * @see _.padLeft
+         * @see _.padStart
          */
-        padLeft(
+        padStart(
             length?: number,
             chars?: string
         ): string;
@@ -13896,15 +15045,15 @@ declare module _ {
 
     interface LoDashExplicitWrapper<T> {
         /**
-         * @see _.padLeft
+         * @see _.padStart
          */
-        padLeft(
+        padStart(
             length?: number,
             chars?: string
         ): LoDashExplicitWrapper<string>;
     }
 
-    //_.padRight
+    //_.padEnd
     interface LoDashStatic {
         /**
          * Pads string on the right side if it’s shorter than length. Padding characters are truncated if they exceed
@@ -13915,7 +15064,7 @@ declare module _ {
          * @param chars The string used as padding.
          * @return Returns the padded string.
          */
-        padRight(
+        padEnd(
             string?: string,
             length?: number,
             chars?: string
@@ -13924,9 +15073,9 @@ declare module _ {
 
     interface LoDashImplicitWrapper<T> {
         /**
-         * @see _.padRight
+         * @see _.padEnd
          */
-        padRight(
+        padEnd(
             length?: number,
             chars?: string
         ): string;
@@ -13934,9 +15083,9 @@ declare module _ {
 
     interface LoDashExplicitWrapper<T> {
         /**
-         * @see _.padRight
+         * @see _.padEnd
          */
-        padRight(
+        padEnd(
             length?: number,
             chars?: string
         ): LoDashExplicitWrapper<string>;
@@ -14150,6 +15299,82 @@ declare module _ {
         template(options?: TemplateOptions): LoDashExplicitObjectWrapper<TemplateExecutor>;
     }
 
+    //_.toLower
+    interface LoDashStatic {
+        /**
+         * Converts `string`, as a whole, to lower case.
+         *
+         * @static
+         * @memberOf _
+         * @category String
+         * @param {string} [string=''] The string to convert.
+         * @returns {string} Returns the lower cased string.
+         * @example
+         *
+         * _.toLower('--Foo-Bar');
+         * // => '--foo-bar'
+         *
+         * _.toLower('fooBar');
+         * // => 'foobar'
+         *
+         * _.toLower('__FOO_BAR__');
+         * // => '__foo_bar__'
+         */
+        toLower(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.toLower
+         */
+        toLower(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.toLower
+         */
+        toLower(): LoDashExplicitWrapper<string>;
+    }
+
+    //_.toUpper
+    interface LoDashStatic {
+        /**
+         * Converts `string`, as a whole, to upper case.
+         *
+         * @static
+         * @memberOf _
+         * @category String
+         * @param {string} [string=''] The string to convert.
+         * @returns {string} Returns the upper cased string.
+         * @example
+         *
+         * _.toUpper('--foo-bar');
+         * // => '--FOO-BAR'
+         *
+         * _.toUpper('fooBar');
+         * // => 'FOOBAR'
+         *
+         * _.toUpper('__foo_bar__');
+         * // => '__FOO_BAR__'
+         */
+        toUpper(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.toUpper
+         */
+        toUpper(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.toUpper
+         */
+        toUpper(): LoDashExplicitWrapper<string>;
+    }
+
     //_.trim
     interface LoDashStatic {
         /**
@@ -14179,7 +15404,7 @@ declare module _ {
         trim(chars?: string): LoDashExplicitWrapper<string>;
     }
 
-    //_.trimLeft
+    //_.trimStart
     interface LoDashStatic {
         /**
          * Removes leading whitespace or specified characters from string.
@@ -14188,7 +15413,7 @@ declare module _ {
          * @param chars The characters to trim.
          * @return Returns the trimmed string.
          */
-        trimLeft(
+        trimStart(
             string?: string,
             chars?: string
         ): string;
@@ -14196,19 +15421,19 @@ declare module _ {
 
     interface LoDashImplicitWrapper<T> {
         /**
-         * @see _.trimLeft
+         * @see _.trimStart
          */
-        trimLeft(chars?: string): string;
+        trimStart(chars?: string): string;
     }
 
     interface LoDashExplicitWrapper<T> {
         /**
-         * @see _.trimLeft
+         * @see _.trimStart
          */
-        trimLeft(chars?: string): LoDashExplicitWrapper<string>;
+        trimStart(chars?: string): LoDashExplicitWrapper<string>;
     }
 
-    //_.trimRight
+    //_.trimEnd
     interface LoDashStatic {
         /**
          * Removes trailing whitespace or specified characters from string.
@@ -14217,7 +15442,7 @@ declare module _ {
          * @param chars The characters to trim.
          * @return Returns the trimmed string.
          */
-        trimRight(
+        trimEnd(
             string?: string,
             chars?: string
         ): string;
@@ -14225,20 +15450,20 @@ declare module _ {
 
     interface LoDashImplicitWrapper<T> {
         /**
-         * @see _.trimRight
+         * @see _.trimEnd
          */
-        trimRight(chars?: string): string;
+        trimEnd(chars?: string): string;
     }
 
     interface LoDashExplicitWrapper<T> {
         /**
-         * @see _.trimRight
+         * @see _.trimEnd
          */
-        trimRight(chars?: string): LoDashExplicitWrapper<string>;
+        trimEnd(chars?: string): LoDashExplicitWrapper<string>;
     }
 
-    //_.trunc
-    interface TruncOptions {
+    //_.truncate
+    interface TruncateOptions {
         /** The maximum string length. */
         length?: number;
         /** The string to indicate text is omitted. */
@@ -14256,24 +15481,97 @@ declare module _ {
          * @param options The options object or maximum string length.
          * @return Returns the truncated string.
          */
-        trunc(
+        truncate(
             string?: string,
-            options?: TruncOptions|number
+            options?: TruncateOptions|number
         ): string;
     }
 
     interface LoDashImplicitWrapper<T> {
         /**
-         * @see _.trunc
+         * @see _.truncate
          */
-        trunc(options?: TruncOptions|number): string;
+        truncate(options?: TruncateOptions|number): string;
     }
 
     interface LoDashExplicitWrapper<T> {
         /**
-         * @see _.trunc
+         * @see _.truncate
          */
-        trunc(options?: TruncOptions|number): LoDashExplicitWrapper<string>;
+        truncate(options?: TruncateOptions|number): LoDashExplicitWrapper<string>;
+    }
+
+    //_.upperCase
+    interface LoDashStatic {
+        /**
+         * Converts `string`, as space separated words, to upper case.
+         *
+         * @static
+         * @memberOf _
+         * @category String
+         * @param {string} [string=''] The string to convert.
+         * @returns {string} Returns the upper cased string.
+         * @example
+         *
+         * _.upperCase('--foo-bar');
+         * // => 'FOO BAR'
+         *
+         * _.upperCase('fooBar');
+         * // => 'FOO BAR'
+         *
+         * _.upperCase('__foo_bar__');
+         * // => 'FOO BAR'
+         */
+        upperCase(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.upperCase
+         */
+        upperCase(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.upperCase
+         */
+        upperCase(): LoDashExplicitWrapper<string>;
+    }
+
+    //_.upperFirst
+    interface LoDashStatic {
+        /**
+         * Converts the first character of `string` to upper case.
+         *
+         * @static
+         * @memberOf _
+         * @category String
+         * @param {string} [string=''] The string to convert.
+         * @returns {string} Returns the converted string.
+         * @example
+         *
+         * _.upperFirst('fred');
+         * // => 'Fred'
+         *
+         * _.upperFirst('FRED');
+         * // => 'FRED'
+         */
+        upperFirst(string?: string): string;
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.upperFirst
+         */
+        upperFirst(): string;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.upperFirst
+         */
+        upperFirst(): LoDashExplicitWrapper<string>;
     }
 
     //_.unescape
@@ -14305,11 +15603,22 @@ declare module _ {
     //_.words
     interface LoDashStatic {
         /**
-         * Splits string into an array of its words.
+         * Splits `string` into an array of its words.
          *
-         * @param string The string to inspect.
-         * @param pattern The pattern to match words.
-         * @return Returns the words of string.
+         * @static
+         * @memberOf _
+         * @category String
+         * @param {string} [string=''] The string to inspect.
+         * @param {RegExp|string} [pattern] The pattern to match words.
+         * @param- {Object} [guard] Enables use as an iteratee for functions like `_.map`.
+         * @returns {Array} Returns the words of `string`.
+         * @example
+         *
+         * _.words('fred, barney, & pebbles');
+         * // => ['fred', 'barney', 'pebbles']
+         *
+         * _.words('fred, barney, & pebbles', /[^, ]+/g);
+         * // => ['fred', 'barney', '&', 'pebbles']
          */
         words(
             string?: string,
@@ -14361,83 +15670,6 @@ declare module _ {
         attempt<TResult>(): LoDashExplicitObjectWrapper<TResult|Error>;
     }
 
-    //_.callback
-    interface LoDashStatic {
-        /**
-         * Creates a function that invokes func with the this binding of thisArg and arguments of the created function.
-         * If func is a property name the created callback returns the property value for a given element. If func is
-         * an object the created callback returns true for elements that contain the equivalent object properties,
-         * otherwise it returns false.
-         *
-         * @param func The value to convert to a callback.
-         * @param thisArg The this binding of func.
-         * @result Returns the callback.
-         */
-        callback<TResult>(
-            func: Function,
-            thisArg?: any
-        ): (...args: any[]) => TResult;
-
-        /**
-         * @see _.callback
-         */
-        callback<TResult>(
-            func: string,
-            thisArg?: any
-        ): (object: any) => TResult;
-
-        /**
-         * @see _.callback
-         */
-        callback(
-            func: Object,
-            thisArg?: any
-        ): (object: any) => boolean;
-
-        /**
-         * @see _.callback
-         */
-        callback<TResult>(): (value: TResult) => TResult;
-    }
-
-    interface LoDashImplicitWrapper<T> {
-        /**
-         * @see _.callback
-         */
-        callback<TResult>(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => TResult>;
-    }
-
-    interface LoDashImplicitObjectWrapper<T> {
-        /**
-         * @see _.callback
-         */
-        callback(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => boolean>;
-
-        /**
-         * @see _.callback
-         */
-        callback<TResult>(thisArg?: any): LoDashImplicitObjectWrapper<(...args: any[]) => TResult>;
-    }
-
-    interface LoDashExplicitWrapper<T> {
-        /**
-         * @see _.callback
-         */
-        callback<TResult>(thisArg?: any): LoDashExplicitObjectWrapper<(object: any) => TResult>;
-    }
-
-    interface LoDashExplicitObjectWrapper<T> {
-        /**
-         * @see _.callback
-         */
-        callback(thisArg?: any): LoDashExplicitObjectWrapper<(object: any) => boolean>;
-
-        /**
-         * @see _.callback
-         */
-        callback<TResult>(thisArg?: any): LoDashExplicitObjectWrapper<(...args: any[]) => TResult>;
-    }
-
     //_.constant
     interface LoDashStatic {
         /**
@@ -14497,7 +15729,33 @@ declare module _ {
     //_.iteratee
     interface LoDashStatic {
         /**
-         * @see _.callback
+         * Creates a function that invokes `func` with the arguments of the created
+         * function. If `func` is a property name the created callback returns the
+         * property value for a given element. If `func` is an object the created
+         * callback returns `true` for elements that contain the equivalent object properties, otherwise it returns `false`.
+         *
+         * @static
+         * @memberOf _
+         * @category Util
+         * @param {*} [func=_.identity] The value to convert to a callback.
+         * @returns {Function} Returns the callback.
+         * @example
+         *
+         * var users = [
+         *   { 'user': 'barney', 'age': 36 },
+         *   { 'user': 'fred',   'age': 40 }
+         * ];
+         *
+         * // create custom iteratee shorthands
+         * _.iteratee = _.wrap(_.iteratee, function(callback, func) {
+         *   var p = /^(\S+)\s*([<>])\s*(\S+)$/.exec(func);
+         *   return !p ? callback(func) : function(object) {
+         *     return (p[2] == '>' ? object[p[1]] > p[3] : object[p[1]] < p[3]);
+         *   };
+         * });
+         *
+         * _.filter(users, 'age > 36');
+         * // => [{ 'user': 'fred', 'age': 40 }]
          */
         iteratee<TResult>(
             func: Function,
@@ -14505,7 +15763,7 @@ declare module _ {
         ): (...args: any[]) => TResult;
 
         /**
-         * @see _.callback
+         * @see _.iteratee
          */
         iteratee<TResult>(
             func: string,
@@ -14513,7 +15771,7 @@ declare module _ {
         ): (object: any) => TResult;
 
         /**
-         * @see _.callback
+         * @see _.iteratee
          */
         iteratee(
             func: Object,
@@ -14521,45 +15779,45 @@ declare module _ {
         ): (object: any) => boolean;
 
         /**
-         * @see _.callback
+         * @see _.iteratee
          */
         iteratee<TResult>(): (value: TResult) => TResult;
     }
 
     interface LoDashImplicitWrapper<T> {
         /**
-         * @see _.callback
+         * @see _.iteratee
          */
         iteratee<TResult>(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => TResult>;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
         /**
-         * @see _.callback
+         * @see _.iteratee
          */
         iteratee(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => boolean>;
 
         /**
-         * @see _.callback
+         * @see _.iteratee
          */
         iteratee<TResult>(thisArg?: any): LoDashImplicitObjectWrapper<(...args: any[]) => TResult>;
     }
 
     interface LoDashExplicitWrapper<T> {
         /**
-         * @see _.callback
+         * @see _.iteratee
          */
         iteratee<TResult>(thisArg?: any): LoDashExplicitObjectWrapper<(object: any) => TResult>;
     }
 
     interface LoDashExplicitObjectWrapper<T> {
         /**
-         * @see _.callback
+         * @see _.iteratee
          */
         iteratee(thisArg?: any): LoDashExplicitObjectWrapper<(object: any) => boolean>;
 
         /**
-         * @see _.callback
+         * @see _.iteratee
          */
         iteratee<TResult>(thisArg?: any): LoDashExplicitObjectWrapper<(...args: any[]) => TResult>;
     }
@@ -14992,6 +16250,77 @@ declare module _ {
         ): LoDashExplicitArrayWrapper<number>;
     }
 
+    //_.rangeRight
+    interface LoDashStatic {
+        /**
+         * This method is like `_.range` except that it populates values in
+         * descending order.
+         *
+         * @static
+         * @memberOf _
+         * @category Util
+         * @param {number} [start=0] The start of the range.
+         * @param {number} end The end of the range.
+         * @param {number} [step=1] The value to increment or decrement by.
+         * @returns {Array} Returns the new array of numbers.
+         * @example
+         *
+         * _.rangeRight(4);
+         * // => [3, 2, 1, 0]
+         *
+         * _.rangeRight(-4);
+         * // => [-3, -2, -1, 0]
+         *
+         * _.rangeRight(1, 5);
+         * // => [4, 3, 2, 1]
+         *
+         * _.rangeRight(0, 20, 5);
+         * // => [15, 10, 5, 0]
+         *
+         * _.rangeRight(0, -4, -1);
+         * // => [-3, -2, -1, 0]
+         *
+         * _.rangeRight(1, 4, 0);
+         * // => [1, 1, 1]
+         *
+         * _.rangeRight(0);
+         * // => []
+         */
+        rangeRight(
+            start: number,
+            end: number,
+            step?: number
+        ): number[];
+
+        /**
+         * @see _.rangeRight
+         */
+        rangeRight(
+            end: number,
+            step?: number
+        ): number[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.rangeRight
+         */
+        rangeRight(
+            end?: number,
+            step?: number
+        ): LoDashImplicitArrayWrapper<number>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.rangeRight
+         */
+        rangeRight(
+            end?: number,
+            step?: number
+        ): LoDashExplicitArrayWrapper<number>;
+    }
+
     //_.runInContext
     interface LoDashStatic {
         /**
@@ -15063,6 +16392,50 @@ declare module _ {
         times(): LoDashExplicitArrayWrapper<number>;
     }
 
+    //_.toPath
+    interface LoDashStatic {
+        /**
+         * Converts `value` to a property path array.
+         *
+         * @static
+         * @memberOf _
+         * @category Util
+         * @param {*} value The value to convert.
+         * @returns {Array} Returns the new property path array.
+         * @example
+         *
+         * _.toPath('a.b.c');
+         * // => ['a', 'b', 'c']
+         *
+         * _.toPath('a[0].b.c');
+         * // => ['a', '0', 'b', 'c']
+         *
+         * var path = ['a', 'b', 'c'],
+         *     newPath = _.toPath(path);
+         *
+         * console.log(newPath);
+         * // => ['a', 'b', 'c']
+         *
+         * console.log(path === newPath);
+         * // => false
+         */
+        toPath(value: any): string[];
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.toPath
+         */
+        toPath(): LoDashImplicitWrapper<string[]>;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.toPath
+         */
+        toPath(): LoDashExplicitWrapper<string[]>;
+    }
+
     //_.uniqueId
     interface LoDashStatic {
         /**
diff --git a/sequelize/sequelize-2.0.0.d.ts b/sequelize/sequelize-2.0.0.d.ts
index 1bb6be593..04af612a5 100644
--- a/sequelize/sequelize-2.0.0.d.ts
+++ b/sequelize/sequelize-2.0.0.d.ts
@@ -6,7 +6,7 @@
 // Based on original work by: samuelneff <https://github.com/samuelneff/sequelize-auto-ts/blob/master/lib/sequelize.d.ts>
 
 /// <reference path="../node/node.d.ts" />
-/// <reference path="../lodash/lodash.d.ts" />
+/// <reference path='../lodash/lodash-3.10.d.ts' />
 
 declare module "sequelize"
 {
diff --git a/sequelize/sequelize.d.ts b/sequelize/sequelize.d.ts
index 0dcd61e86..fda6503a5 100644
--- a/sequelize/sequelize.d.ts
+++ b/sequelize/sequelize.d.ts
@@ -5,7 +5,7 @@
 
 // Based on original work by: samuelneff <https://github.com/samuelneff/sequelize-auto-ts/blob/master/lib/sequelize.d.ts>
 
-/// <reference path="../lodash/lodash.d.ts" />
+/// <reference path='../lodash/lodash-3.10.d.ts' />
 /// <reference path="../bluebird/bluebird.d.ts" />
 /// <reference path="../validator/validator.d.ts" />