<NME> test.ts
<BEF> /// <reference path="../defs/tsd.d.ts" />

var grunt: IGrunt = require('grunt');
import fs = require('fs');
import path = require('path');
import utils = require('../tasks/modules/utils');
import _ = require('underscore');

function testFile(test, path) {
    var actual = grunt.file.read('test/' + path);
} from './testHelpers';

export var tests : nodeunit.ITestGroup = {
    setUp: (callback) => {
       callback();
    },
	  tearDown: (callback) => {
       callback();
    },
    simple: function (test) {
        testFile(test, 'simple/js/zoo.js', true);
        testFile(test, 'simple/js/zoo.d.ts');
        test.done();
    },
    simple_with_rootDir: function (test) {
        testDirectory(test, 'simple_with_rootDir');
        test.done();
    },
    abtest: function (test) {
        testFile(test, 'abtest/reference.ts');
        testFile(test, 'abtest/out.js', true);
        test.done();
    },
    allowJs: function (test) {
        testDirectory(test, 'allowJs');
        test.done();
    },
    amdloader: function (test) {
        testDirectory(test, 'amdloader');
        test.done();
    },
    templateCache: function (test) {
        testDirectory(test, 'templateCache');
        test.done();
    },
    html2ts: function (test) {
        testDirectory(test, 'html');
        testDirectory(test, 'htmlTemplate');
        testDirectory(test, 'htmlSnakeModuleName');
        test.done();
    },
    index: function (test) {
        testDirectory(test, 'index');
        test.done();
    },
    transform: function (test) {
        testDirectory(test, 'transform', true);
        test.done();
    },
    referencesTransform: function (test) {
        testDirectory(test, 'references-transform');
        test.done();
    },
    customcompiler: function (test) {
        testDirectory(test, 'customcompiler');
        test.done();
    },
    fail: function (test) {
        testDirectory(test, 'fail'); // tested to make sure transformers still run for failing task
        test.done();
    },
    es6: function (test) {
        testDirectory(test, 'es6');
        test.done();
    },
    noEmitOnError: function (test) {
        testDirectory(test, 'noEmitOnError');
        assertFileDoesNotExist(test, 'test/noEmitOnError/testNoEmitOnError_true.js');
        test.done();
    },
    preserveConstEnums: function (test) {
        testDirectory(test, 'preserveConstEnums');
        test.done();
    },
    suppressImplicitAnyIndexErrors: function (test) {
        testDirectory(test, 'suppressImplicitAnyIndexErrors');
        assertFileDoesNotExist(test, 'test/suppressImplicitAnyIndexErrors/test_suppressImplicitAnyIndexError_false.js');
        test.done();
    },
    varReplacedTest: function (test) {
        testDirectory(test, 'varreplacedtest');
        test.done();
    },
    vsproj_test_ignoreSettings: function (test) {
        testDirectory(test, 'vsproj/ignoreSettings');
        test.done();
    },
    files_ObjectFormat: function (test) {
        testDirectory(test, 'files_ObjectFormat', true);
        test.done();
    },
    out_and_outdir_with_spaces: function (test) {
        testDirectory(test, 'out with spaces');
        test.done();
    },
    htmlExternal: function (test) {
        testDirectory(test, 'htmlExternal');
        test.done();
    },
    nestedSources: function (test) {
        testDirectory(test, 'nestedSources');
        test.done();
    }
}

<MSG> Switch to Lo-Dash from Underscore

<DFF> @@ -4,7 +4,7 @@ var grunt: IGrunt = require('grunt');
 import fs = require('fs');
 import path = require('path');
 import utils = require('../tasks/modules/utils');
-import _ = require('underscore');
+import _ = require('lodash');
 
 function testFile(test, path) {
     var actual = grunt.file.read('test/' + path);

{'commit': 'diff --git a/defs/lodash/lodash.d.ts b/defs/lodash/lodash.d.ts\nnew file mode 100644\nindex 0000000..3e3fd43\n--- /dev/null\n+++ b/defs/lodash/lodash.d.ts\n@@ -0,0 +1,6261 @@\n+// Type definitions for Lo-Dash\n+// Project: http://lodash.com/\n+// Definitions by: Brian Zengel <https://github.com/bczengel>\n+// Definitions: https://github.com/borisyankov/DefinitelyTyped\n+\n+declare var _: _.LoDashStatic;\n+\n+declare module _ {\n+    interface LoDashStatic {\n+        /**\n+        * Creates a lodash object which wraps the given value to enable intuitive method chaining.\n+        *\n+        * In addition to Lo-Dash methods, wrappers also have the following Array methods:\n+        * concat, join, pop, push, reverse, shift, slice, sort, splice, and unshift\n+        *\n+        * Chaining is supported in custom builds as long as the value method is implicitly or \n+        * explicitly included in the build.\n+        *\n+        * The chainable wrapper functions are:\n+        * after, assign, bind, bindAll, bindKey, chain, compact, compose, concat, countBy, \n+        * createCallback, curry, debounce, defaults, defer, delay, difference, filter, flatten, \n+        * forEach, forEachRight, forIn, forInRight, forOwn, forOwnRight, functions, groupBy, \n+        * indexBy, initial, intersection, invert, invoke, keys, map, max, memoize, merge, min, \n+        * object, omit, once, pairs, partial, partialRight, pick, pluck, pull, push, range, reject, \n+        * remove, rest, reverse, shuffle, slice, sort, sortBy, splice, tap, throttle, times, \n+        * toArray, transform, union, uniq, unshift, unzip, values, where, without, wrap, and zip\n+        *\n+        * The non-chainable wrapper functions are:\n+        * clone, cloneDeep, contains, escape, every, find, findIndex, findKey, findLast, \n+        * findLastIndex, findLastKey, has, identity, indexOf, isArguments, isArray, isBoolean, \n+        * isDate, isElement, isEmpty, isEqual, isFinite, isFunction, isNaN, isNull, isNumber, \n+        * isObject, isPlainObject, isRegExp, isString, isUndefined, join, lastIndexOf, mixin, \n+        * noConflict, parseInt, pop, random, reduce, reduceRight, result, shift, size, some, \n+        * sortedIndex, runInContext, template, unescape, uniqueId, and value\n+        *\n+        * The wrapper functions first and last return wrapped values when n is provided, otherwise \n+        * they return unwrapped values.\n+        *\n+        * Explicit chaining can be enabled by using the _.chain method.\n+        **/\n+        (value: number): LoDashWrapper<number>;\n+        (value: string): LoDashWrapper<string>;\n+        (value: boolean): LoDashWrapper<boolean>;\n+        <T>(value: Array<T>): LoDashArrayWrapper<T>;\n+        <T extends {}>(value: T): LoDashObjectWrapper<T>;\n+        (value: any): LoDashWrapper<any>;\n+\n+        /**\n+        * The semantic version number.\n+        **/\n+        VERSION: string;\n+\n+        /**\n+        * An object used to flag environments features.\n+        **/\n+        support: Support;\n+\n+        /**\n+        * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby \n+        * (ERB). Change the following template settings to use alternative delimiters.\n+        **/\n+        templateSettings: TemplateSettings;\n+    }\n+\n+    /**\n+    * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby \n+    * (ERB). Change the following template settings to use alternative delimiters.\n+    **/\n+    interface TemplateSettings {\n+        /**\n+        * The "escape" delimiter.\n+        **/\n+        escape?: RegExp;\n+\n+        /**\n+        * The "evaluate" delimiter.\n+        **/\n+        evaluate?: RegExp;\n+\n+        /**\n+        * An object to import into the template as local variables.\n+        **/\n+        imports?: Dictionary<any>;\n+\n+        /**\n+        * The "interpolate" delimiter.\n+        **/\n+        interpolate?: RegExp;\n+\n+        /**\n+        * Used to reference the data object in the template text.\n+        **/\n+        variable?: string;\n+    }\n+\n+    /**\n+    * An object used to flag environments features.\n+    **/\n+    interface Support {\n+        /**\n+        * Detect if an arguments object’s [[Class]] is resolvable (all but Firefox < 4, IE < 9).\n+        **/\n+        argsClass: boolean;\n+\n+        /**\n+        * Detect if arguments objects are Object objects (all but Narwhal and Opera < 10.5).\n+        **/\n+        argsObject: boolean;\n+\n+        /**\n+        * Detect if name or message properties of Error.prototype are enumerable by default. \n+        * (IE < 9, Safari < 5.1)\n+        **/\n+        enumErrorProps: boolean;\n+\n+        /**\n+        * Detect if Function#bind exists and is inferred to be fast (all but V8).\n+        **/\n+        fastBind: boolean;\n+\n+        /**\n+        * Detect if functions can be decompiled by Function#toString (all but PS3 and older Opera \n+        * mobile browsers & avoided in Windows 8 apps).\n+        **/\n+        funcDecomp: boolean;\n+\n+        /**\n+        * Detect if Function#name is supported (all but IE).\n+        **/\n+        funcNames: boolean;\n+\n+        /**\n+        * Detect if arguments object indexes are non-enumerable (Firefox < 4, IE < 9, PhantomJS, \n+        * Safari < 5.1).\n+        **/\n+        nonEnumArgs: boolean;\n+\n+        /**\n+        * Detect if properties shadowing those on Object.prototype are non-enumerable.\n+        *\n+        * In IE < 9 an objects own properties, shadowing non-enumerable ones, are made \n+        * non-enumerable as well (a.k.a the JScript [[DontEnum]] bug).\n+        **/\n+        nonEnumShadows: boolean;\n+\n+        /**\n+        * Detect if own properties are iterated after inherited properties (all but IE < 9).\n+        **/\n+        ownLast: boolean;\n+\n+        /**\n+        * Detect if Array#shift and Array#splice augment array-like objects correctly.\n+        *\n+        * Firefox < 10, IE compatibility mode, and IE < 9 have buggy Array shift() and splice() \n+        * functions that fail to remove the last element, value[0], of array-like objects even \n+        * though the length property is set to 0. The shift() method is buggy in IE 8 compatibility \n+        * mode, while splice() is buggy regardless of mode in IE < 9 and buggy in compatibility mode\n+        * in IE 9.\n+        **/\n+        spliceObjects: boolean;\n+\n+        /**\n+        * Detect lack of support for accessing string characters by index.\n+        *\n+        * IE < 8 can\'t access characters by index and IE 8 can only access characters by index on \n+        * string literals.\n+        **/\n+        unindexedChars: boolean;\n+    }\n+\n+    interface LoDashWrapperBase<T, TWrapper> {\n+        /**\n+        * Produces the toString result of the wrapped value.\n+        * @return Returns the string result.\n+        **/\n+        toString(): string;\n+\n+        /**\n+        * Extracts the wrapped value.\n+        * @return The wrapped value.\n+        **/\n+        valueOf(): T;\n+\n+        /**\n+        * @see valueOf\n+        **/\n+        value(): T;\n+    }\n+\n+    interface LoDashWrapper<T> extends LoDashWrapperBase<T, LoDashWrapper<T>> { }\n+\n+    interface LoDashObjectWrapper<T> extends LoDashWrapperBase<T, LoDashObjectWrapper<T>> { }\n+\n+    interface LoDashArrayWrapper<T> extends LoDashWrapperBase<T[], LoDashArrayWrapper<T>> {\n+        concat(...items: T[]): LoDashArrayWrapper<T>;\n+        join(seperator?: string): LoDashWrapper<string>;\n+        pop(): LoDashWrapper<T>;\n+        push(...items: T[]): void;\n+        reverse(): LoDashArrayWrapper<T>;\n+        shift(): LoDashWrapper<T>;\n+        slice(start: number, end?: number): LoDashArrayWrapper<T>;\n+        sort(compareFn?: (a: T, b: T) => number): LoDashArrayWrapper<T>;\n+        splice(start: number): LoDashArrayWrapper<T>;\n+        splice(start: number, deleteCount: number, ...items: any[]): LoDashArrayWrapper<T>;\n+        unshift(...items: any[]): LoDashWrapper<number>;\n+    }\n+\n+    //_.chain\n+    interface LoDashStatic {\n+        /**\n+        * Creates a lodash object that wraps the given value with explicit method chaining enabled.\n+        * @param value The value to wrap.\n+        * @return The wrapper object.\n+        **/\n+        chain(value: number): LoDashWrapper<number>;\n+        chain(value: string): LoDashWrapper<string>;\n+        chain(value: boolean): LoDashWrapper<boolean>;\n+        chain<T>(value: Array<T>): LoDashArrayWrapper<T>;\n+        chain<T extends {}>(value: T): LoDashObjectWrapper<T>;\n+        chain(value: any): LoDashWrapper<any>;\n+    }\n+\n+    interface LoDashWrapperBase<T, TWrapper> {\n+        /**\n+        * Enables explicit method chaining on the wrapper object.\n+        * @see _.chain\n+        * @return The wrapper object.\n+        **/\n+        chain(): TWrapper;\n+    }\n+\n+    //_.tap\n+    interface LoDashStatic {\n+        /**\n+        * Invokes interceptor with the value as the first argument and then returns value. The \n+        * purpose of this method is to "tap into" a method chain in order to perform operations on \n+        * intermediate results within the chain.\n+        * @param value The value to provide to interceptor\n+        * @param interceptor The function to invoke.\n+        * @return value\n+        **/\n+        tap<T>(\n+            value: T,\n+            interceptor: (value: T) => void): T;\n+    }\n+\n+    interface LoDashWrapperBase<T, TWrapper> {\n+        /**\n+        * @see _.tap\n+        **/\n+        tap(interceptor: (value: T) => void): TWrapper;\n+    }\n+\n+    /*********\n+    * Arrays *\n+    **********/\n+\n+    //_.compact\n+    interface LoDashStatic {\n+        /**\n+        * Returns a copy of the array with all falsy values removed. In JavaScript, false, null, 0, "",\n+        * undefined and NaN are all falsy.\n+        * @param array Array to compact.\n+        * @return (Array) Returns a new array of filtered values.\n+        **/\n+        compact<T>(array: Array<T>): T[];\n+\n+        /**\n+        * @see _.compact\n+        **/\n+        compact<T>(array: List<T>): T[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.compact\n+        **/\n+        compact(): LoDashArrayWrapper<T>;\n+    }\n+\n+    //_.difference\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array excluding all values of the provided arrays using strict equality for comparisons\n+        * , i.e. ===.\n+        * @param array The array to process\n+        * @param others The arrays of values to exclude.\n+        * @return Returns a new array of filtered values.\n+        **/\n+        difference<T>(\n+            array: Array<T>,\n+            ...others: Array<T>[]): T[];\n+        /**\n+        * @see _.difference\n+        **/\n+        difference<T>(\n+            array: List<T>,\n+            ...others: List<T>[]): T[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.difference\n+        **/\n+        difference(\n+            ...others: Array<T>[]): LoDashArrayWrapper<T>;\n+        /**\n+        * @see _.difference\n+        **/\n+        difference(\n+            ...others: List<T>[]): LoDashArrayWrapper<T>;\n+    }\n+\n+    //_.findIndex\n+    interface LoDashStatic {\n+        /**\n+        * This method is like _.find except that it returns the index of the first element that passes \n+        * the callback check, instead of the element itself.\n+        * @param array The array to search.\n+        * @param {(Function|Object|string)} callback The function called per iteration. If a property name or object is provided it will be \n+        * used to create a ".pluck" or ".where" style callback, respectively.\n+        * @param thisArg The this binding of callback.\n+        * @return Returns the index of the found element, else -1.\n+        **/\n+        findIndex<T>(\n+            array: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): number;\n+\n+        /**\n+        * @see _.findIndex\n+        **/\n+        findIndex<T>(\n+            array: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): number;\n+\n+        /**\n+        * @see _.findIndex\n+        **/\n+        findIndex<T>(\n+            array: Array<T>,\n+            pluckValue: string): number;\n+\n+        /**\n+        * @see _.findIndex\n+        **/\n+        findIndex<T>(\n+            array: List<T>,\n+            pluckValue: string): number;\n+\n+        /**\n+        * @see _.findIndex\n+        **/\n+        findIndex<W, T>(\n+            array: Array<T>,\n+            whereDictionary: W): number;\n+\n+        /**\n+        * @see _.findIndex\n+        **/\n+        findIndex<W, T>(\n+            array: List<T>,\n+            whereDictionary: W): number;\n+    }\n+\n+    //_.findLastIndex\n+    interface LoDashStatic {\n+        /**\n+        * This method is like _.findIndex except that it iterates over elements of a collection from right to left.\n+        * @param array The array to search.\n+        * @param {(Function|Object|string)} callback The function called per iteration. If a property name or object is provided it will be \n+        * used to create a ".pluck" or ".where" style callback, respectively.\n+        * @param thisArg The this binding of callback.\n+        * @return Returns the index of the found element, else -1.\n+        **/\n+        findLastIndex<T>(\n+            array: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): number;\n+\n+        /**\n+        * @see _.findLastIndex\n+        **/\n+        findLastIndex<T>(\n+            array: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): number;\n+\n+        /**\n+        * @see _.findLastIndex\n+        **/\n+        findLastIndex<T>(\n+            array: Array<T>,\n+            pluckValue: string): number;\n+\n+        /**\n+        * @see _.findLastIndex\n+        **/\n+        findLastIndex<T>(\n+            array: List<T>,\n+            pluckValue: string): number;\n+\n+        /**\n+        * @see _.findLastIndex\n+        **/\n+        findLastIndex<T>(\n+            array: Array<T>,\n+            whereDictionary: Dictionary<any>): number;\n+\n+        /**\n+        * @see _.findLastIndex\n+        **/\n+        findLastIndex<T>(\n+            array: List<T>,\n+            whereDictionary: Dictionary<any>): number;\n+    }\n+\n+    //_.first\n+    interface LoDashStatic {\n+        /**\n+        * Gets the first element or first n elements of an array. If a callback is provided \n+        * elements at the beginning of the array are returned as long as the callback returns \n+        * truey. The callback is bound to thisArg and invoked with three arguments; (value, \n+        * index, array).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback \n+        * will return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return ]\n+        * true for elements that have the properties of the given object, else false.\n+        * @param array Retrieves the first element of this array.\n+        * @return Returns the first element of `array`.\n+        **/\n+        first<T>(array: Array<T>): T;\n+\n+        /**\n+        * @see _.first\n+        **/\n+        first<T>(array: List<T>): T;\n+\n+        /**\n+        * @see _.first\n+        * @param n The number of elements to return.\n+        **/\n+        first<T>(\n+            array: Array<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.first\n+        * @param n The number of elements to return.\n+        **/\n+        first<T>(\n+            array: List<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.first\n+        * @param callback The function called per element.\n+        * @param [thisArg] The this binding of callback.\n+        **/\n+        first<T>(\n+            array: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.first\n+        * @param callback The function called per element.\n+        * @param [thisArg] The this binding of callback.\n+        **/\n+        first<T>(\n+            array: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.first\n+        * @param pluckValue "_.pluck" style callback value\n+        **/\n+        first<T>(\n+            array: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.first\n+        * @param pluckValue "_.pluck" style callback value\n+        **/\n+        first<T>(\n+            array: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.first\n+        * @param whereValue "_.where" style callback value\n+        **/\n+        first<W, T>(\n+            array: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.first\n+        * @param whereValue "_.where" style callback value\n+        **/\n+        first<W, T>(\n+            array: List<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        head<T>(array: Array<T>): T;\n+\n+        /**\n+        * @see _.first\n+        **/\n+        head<T>(array: List<T>): T;\n+\n+        /**\n+        * @see _.first\n+        **/\n+        head<T>(\n+            array: Array<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        head<T>(\n+            array: List<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        head<T>(\n+            array: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        head<T>(\n+            array: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        head<T>(\n+            array: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        head<T>(\n+            array: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        head<W, T>(\n+            array: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        head<W, T>(\n+            array: List<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        take<T>(array: Array<T>): T;\n+\n+        /**\n+        * @see _.first\n+        **/\n+        take<T>(array: List<T>): T;\n+\n+        /**\n+        * @see _.first\n+        **/\n+        take<T>(\n+            array: Array<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        take<T>(\n+            array: List<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        take<T>(\n+            array: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        take<T>(\n+            array: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        take<T>(\n+            array: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        take<T>(\n+            array: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        take<W, T>(\n+            array: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.first\n+        **/\n+        take<W, T>(\n+            array: List<T>,\n+            whereValue: W): T[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.first\n+        **/\n+        first(): T;\n+\n+        /**\n+        * @see _.first\n+        * @param n The number of elements to return.\n+        **/\n+        first(n: number): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.first\n+        * @param callback The function called per element.\n+        * @param [thisArg] The this binding of callback.\n+        **/\n+        first(\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.first\n+        * @param pluckValue "_.pluck" style callback value\n+        **/\n+        first(pluckValue: string): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.first\n+        * @param whereValue "_.where" style callback value\n+        **/\n+        first<W>(whereValue: W): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.first\n+        **/\n+        head(): T;\n+\n+        /**\n+        * @see _.first\n+        * @param n The number of elements to return.\n+        **/\n+        head(n: number): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.first\n+        * @param callback The function called per element.\n+        * @param [thisArg] The this binding of callback.\n+        **/\n+        head(\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.first\n+        * @param pluckValue "_.pluck" style callback value\n+        **/\n+        head(pluckValue: string): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.first\n+        * @param whereValue "_.where" style callback value\n+        **/\n+        head<W>(whereValue: W): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.first\n+        **/\n+        take(): T;\n+\n+        /**\n+        * @see _.first\n+        * @param n The number of elements to return.\n+        **/\n+        take(n: number): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.first\n+        * @param callback The function called per element.\n+        * @param [thisArg] The this binding of callback.\n+        **/\n+        take(\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.first\n+        * @param pluckValue "_.pluck" style callback value\n+        **/\n+        take(pluckValue: string): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.first\n+        * @param whereValue "_.where" style callback value\n+        **/\n+        take<W>(whereValue: W): LoDashArrayWrapper<T>;\n+    }\n+\n+    //_.flatten\n+    interface LoDashStatic {\n+        /**\n+        * Flattens a nested array (the nesting can be to any depth). If isShallow is truey, the \n+        * array will only be flattened a single level. If a callback is provided each element of \n+        * the array is passed through the callback before flattening. The callback is bound to \n+        * thisArg and invoked with three arguments; (value, index, array).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false.\n+        * @param array The array to flatten.\n+        * @param shallow If true then only flatten one level, optional, default = false.\n+        * @return `array` flattened.\n+        **/\n+        flatten<T>(array: Array<any>, isShallow?: boolean): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<T>(array: List<any>, isShallow?: boolean): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<T>(\n+            array: Array<any>,\n+            isShallow: boolean,\n+            callback: ListIterator<any, T>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<T>(\n+            array: List<any>,\n+            isShallow: boolean,\n+            callback: ListIterator<any, T>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<T>(\n+            array: Array<any>,\n+            callback: ListIterator<any, T>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<T>(\n+            array: List<any>,\n+            callback: ListIterator<any, T>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<W, T>(\n+            array: Array<any>,\n+            isShallow: boolean,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<W, T>(\n+            array: List<any>,\n+            isShallow: boolean,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<W, T>(\n+            array: Array<any>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<W, T>(\n+            array: List<any>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<T>(\n+            array: Array<any>,\n+            isShallow: boolean,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<T>(\n+            array: List<any>,\n+            isShallow: boolean,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<T>(\n+            array: Array<any>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<T>(\n+            array: List<any>,\n+            pluckValue: string): T[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<Flat>(isShallow?: boolean): LoDashArrayWrapper<Flat>;\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<Flat>(\n+            isShallow: boolean,\n+            callback: ListIterator<T, Flat>,\n+            thisArg?: any): LoDashArrayWrapper<Flat>;\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<Flat>(\n+            callback: ListIterator<T, Flat>,\n+            thisArg?: any): LoDashArrayWrapper<Flat>;\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<Flat>(\n+            isShallow: boolean,\n+            pluckValue: string): LoDashArrayWrapper<Flat>;\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<Flat>(\n+            pluckValue: string): LoDashArrayWrapper<Flat>;\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<Flat, W>(\n+            isShallow: boolean,\n+            whereValue: W): LoDashArrayWrapper<Flat>;\n+\n+        /**\n+        * @see _.flatten\n+        **/\n+        flatten<Flat, W>(\n+            whereValue: W): LoDashArrayWrapper<Flat>;\n+    }\n+\n+    //_.indexOf\n+    interface LoDashStatic {\n+        /**\n+        * Gets the index at which the first occurrence of value is found using strict equality \n+        * for comparisons, i.e. ===. If the array is already sorted providing true for fromIndex \n+        * will run a faster binary search.\n+        * @param array The array to search.\n+        * @param value The value to search for.\n+        * @param fromIndex The index to search from.\n+        * @return The index of `value` within `array`.\n+        **/\n+        indexOf<T>(\n+            array: Array<T>,\n+            value: T): number;\n+\n+        /**\n+        * @see _.indexOf\n+        **/\n+        indexOf<T>(\n+            array: List<T>,\n+            value: T): number;\n+\n+        /**\n+        * @see _.indexOf\n+        * @param fromIndex The index to search from\n+        **/\n+        indexOf<T>(\n+            array: Array<T>,\n+            value: T,\n+            fromIndex: number): number;\n+\n+        /**\n+        * @see _.indexOf\n+        * @param fromIndex The index to search from\n+        **/\n+        indexOf<T>(\n+            array: List<T>,\n+            value: T,\n+            fromIndex: number): number;\n+\n+        /**\n+        * @see _.indexOf\n+        * @param isSorted True to perform a binary search on a sorted array.\n+        **/\n+        indexOf<T>(\n+            array: Array<T>,\n+            value: T,\n+            isSorted: boolean): number;\n+\n+        /**\n+        * @see _.indexOf\n+        * @param isSorted True to perform a binary search on a sorted array.\n+        **/\n+        indexOf<T>(\n+            array: List<T>,\n+            value: T,\n+            isSorted: boolean): number;\n+    }\n+\n+    //_.initial\n+    interface LoDashStatic {\n+        /**\n+        * Gets all but the last element or last n elements of an array. If a callback is provided \n+        * elements at the end of the array are excluded from the result as long as the callback \n+        * returns truey. The callback is bound to thisArg and invoked with three arguments; \n+        * (value, index, array).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false.\n+        * @param array The array to query.\n+        * @param n Leaves this many elements behind, optional.\n+        * @return Returns everything but the last `n` elements of `array`.\n+        **/\n+        initial<T>(\n+            array: Array<T>): T[];\n+\n+        /**\n+        * @see _.initial\n+        **/\n+        initial<T>(\n+            array: List<T>): T[];\n+\n+        /**\n+        * @see _.initial\n+        * @param n The number of elements to exclude.\n+        **/\n+        initial<T>(\n+            array: Array<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.initial\n+        * @param n The number of elements to exclude.\n+        **/\n+        initial<T>(\n+            array: List<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.initial\n+        * @param callback The function called per element\n+        **/\n+        initial<T>(\n+            array: Array<T>,\n+            callback: ListIterator<T, boolean>): T[];\n+\n+        /**\n+        * @see _.initial\n+        * @param callback The function called per element\n+        **/\n+        initial<T>(\n+            array: List<T>,\n+            callback: ListIterator<T, boolean>): T[];\n+\n+        /**\n+        * @see _.initial\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        initial<T>(\n+            array: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.initial\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        initial<T>(\n+            array: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.initial\n+        * @param whereValue _.where style callback\n+        **/\n+        initial<W, T>(\n+            array: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.initial\n+        * @param whereValue _.where style callback\n+        **/\n+        initial<W, T>(\n+            array: List<T>,\n+            whereValue: W): T[];\n+    }\n+\n+    //_.intersection\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array of unique values present in all provided arrays using strict \n+        * equality for comparisons, i.e. ===.\n+        * @param arrays The arrays to inspect.\n+        * @return Returns an array of composite values.\n+        **/\n+        intersection<T>(...arrays: Array<T>[]): T[];\n+\n+        /**\n+        * @see _.intersection\n+        **/\n+        intersection<T>(...arrays: List<T>[]): T[];\n+    }\n+\n+    //_.last\n+    interface LoDashStatic {\n+        /**\n+        * Gets the last element or last n elements of an array. If a callback is provided \n+        * elements at the end of the array are returned as long as the callback returns truey. \n+        * The callback is bound to thisArg and invoked with three arguments; (value, index, array).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false.\n+        * @param array The array to query.\n+        * @return Returns the last element(s) of array.\n+        **/\n+        last<T>(array: Array<T>): T;\n+\n+        /**\n+        * @see _.last\n+        **/\n+        last<T>(array: List<T>): T;\n+\n+        /**\n+        * @see _.last\n+        * @param n The number of elements to return\n+        **/\n+        last<T>(\n+            array: Array<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.last\n+        * @param n The number of elements to return\n+        **/\n+        last<T>(\n+            array: List<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.last\n+        * @param callback The function called per element\n+        **/\n+        last<T>(\n+            array: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.last\n+        * @param callback The function called per element\n+        **/\n+        last<T>(\n+            array: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.last\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        last<T>(\n+            array: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.last\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        last<T>(\n+            array: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.last\n+        * @param whereValue _.where style callback\n+        **/\n+        last<W, T>(\n+            array: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.last\n+        * @param whereValue _.where style callback\n+        **/\n+        last<W, T>(\n+            array: List<T>,\n+            whereValue: W): T[];\n+    }\n+\n+    //_.lastIndexOf\n+    interface LoDashStatic {\n+        /**\n+        * Gets the index at which the last occurrence of value is found using strict equality \n+        * for comparisons, i.e. ===. If fromIndex is negative, it is used as the offset from the \n+        * end of the collection.\n+        * @param array The array to search.\n+        * @param value The value to search for.\n+        * @param fromIndex The index to search from.\n+        * @return The index of the matched value or -1.\n+        **/\n+        lastIndexOf<T>(\n+            array: Array<T>,\n+            value: T,\n+            fromIndex?: number): number;\n+\n+        /**\n+        * @see _.lastIndexOf\n+        **/\n+        lastIndexOf<T>(\n+            array: List<T>,\n+            value: T,\n+            fromIndex?: number): number;\n+    }\n+\n+    //_.pull\n+    interface LoDashStatic {\n+        /**\n+        * Removes all provided values from the given array using strict equality for comparisons, \n+        * i.e. ===.\n+        * @param array The array to modify.\n+        * @param values The values to remove.\n+        * @return array.\n+        **/\n+        pull(\n+            array: Array<any>,\n+            ...values: any[]): any[];\n+\n+        /**\n+        * @see _.pull\n+        **/\n+        pull(\n+            array: List<any>,\n+            ...values: any[]): any[];\n+    }\n+\n+    //_.range\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array of numbers (positive and/or negative) progressing from start up \n+        * to but not including end. If start is less than stop a zero-length range is created \n+        * unless a negative step is specified.\n+        * @param start The start of the range.\n+        * @param end The end of the range.\n+        * @param step The value to increment or decrement by.\n+        * @return Returns a new range array.\n+        **/\n+        range(\n+            start: number,\n+            stop: number,\n+            step?: number): number[];\n+\n+        /**\n+        * @see _.range\n+        * @param end The end of the range.\n+        * @return Returns a new range array.\n+        * @note If start is not specified the implementation will never pull the step (step = arguments[2] || 0)\n+        **/\n+        range(stop: number): number[];\n+    }\n+\n+    //_.remove\n+    interface LoDashStatic {\n+        /**\n+        * Removes all elements from an array that the callback returns truey for and returns \n+        * an array of removed elements. The callback is bound to thisArg and invoked with three \n+        * arguments; (value, index, array).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false.\n+        * @param array The array to modify.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return A new array of removed elements.\n+        **/\n+        remove(\n+            array: Array<any>,\n+            callback?: ListIterator<any, boolean>,\n+            thisArg?: any): any[];\n+\n+        /**\n+        * @see _.remove\n+        **/\n+        remove(\n+            array: List<any>,\n+            callback?: ListIterator<any, boolean>,\n+            thisArg?: any): any[];\n+\n+        /**\n+        * @see _.remove\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        remove(\n+            array: Array<any>,\n+            pluckValue?: string): any[];\n+\n+        /**\n+        * @see _.remove\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        remove(\n+            array: List<any>,\n+            pluckValue?: string): any[];\n+\n+        /**\n+        * @see _.remove\n+        * @param whereValue _.where style callback\n+        **/\n+        remove(\n+            array: Array<any>,\n+            wherealue?: Dictionary<any>): any[];\n+\n+        /**\n+        * @see _.remove\n+        * @param whereValue _.where style callback\n+        **/\n+        remove(\n+            array: List<any>,\n+            wherealue?: Dictionary<any>): any[];\n+    }\n+\n+    //_.rest\n+    interface LoDashStatic {\n+        /**\n+        * The opposite of _.initial this method gets all but the first element or first n elements of \n+        * an array. If a callback function is provided elements at the beginning of the array are excluded \n+        * from the result as long as the callback returns truey. The callback is bound to thisArg and \n+        * invoked with three arguments; (value, index, array).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will return \n+        * the property value of the given element.\n+        * \n+        * If an object is provided for callback the created "_.where" style callback will return true \n+        * for elements that have the properties of the given object, else false.\n+        * @param array The array to query.\n+        * @param {(Function|Object|number|string)} [callback=1] The function called per element or the number \n+        * of elements to exclude. If a property name or object is provided it will be used to create a \n+        * ".pluck" or ".where" style callback, respectively.\n+        * @param {*} [thisArg] The this binding of callback.\n+        * @return Returns a slice of array.\n+        **/\n+        rest<T>(array: Array<T>): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        rest<T>(array: List<T>): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        rest<T>(\n+            array: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        rest<T>(\n+            array: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        rest<T>(\n+            array: Array<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        rest<T>(\n+            array: List<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        rest<T>(\n+            array: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        rest<T>(\n+            array: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        rest<W, T>(\n+            array: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        rest<W, T>(\n+            array: List<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        drop<T>(array: Array<T>): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        drop<T>(array: List<T>): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        drop<T>(\n+            array: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        drop<T>(\n+            array: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        drop<T>(\n+            array: Array<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        drop<T>(\n+            array: List<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        drop<T>(\n+            array: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        drop<T>(\n+            array: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        drop<W, T>(\n+            array: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        drop<W, T>(\n+            array: List<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        tail<T>(array: Array<T>): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        tail<T>(array: List<T>): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        tail<T>(\n+            array: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        tail<T>(\n+            array: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        tail<T>(\n+            array: Array<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        tail<T>(\n+            array: List<T>,\n+            n: number): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        tail<T>(\n+            array: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        tail<T>(\n+            array: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        tail<W, T>(\n+            array: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.rest\n+        **/\n+        tail<W, T>(\n+            array: List<T>,\n+            whereValue: W): T[];\n+    }\n+\n+    //_.sortedIndex\n+    interface LoDashStatic {\n+        /**\n+        * Uses a binary search to determine the smallest index at which a value should be inserted \n+        * into a given sorted array in order to maintain the sort order of the array. If a callback \n+        * is provided it will be executed for value and each element of array to compute their sort \n+        * ranking. The callback is bound to thisArg and invoked with one argument; (value).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false.\n+        * @param array The sorted list.\n+        * @param value The value to determine its index within `list`.\n+        * @param callback Iterator to compute the sort ranking of each value, optional.\n+        * @return The index at which value should be inserted into array.\n+        **/\n+        sortedIndex<T, TSort>(\n+            array: Array<T>,\n+            value: T,\n+            callback?: (x: T) => TSort,\n+            thisArg?: any): number;\n+\n+        /**\n+        * @see _.sortedIndex\n+        **/\n+        sortedIndex<T, TSort>(\n+            array: List<T>,\n+            value: T,\n+            callback?: (x: T) => TSort,\n+            thisArg?: any): number;\n+\n+        /**\n+        * @see _.sortedIndex\n+        * @param pluckValue the _.pluck style callback\n+        **/\n+        sortedIndex<T>(\n+            array: Array<T>,\n+            value: T,\n+            pluckValue: string): number;\n+\n+        /**\n+        * @see _.sortedIndex\n+        * @param pluckValue the _.pluck style callback\n+        **/\n+        sortedIndex<T>(\n+            array: List<T>,\n+            value: T,\n+            pluckValue: string): number;\n+\n+        /**\n+        * @see _.sortedIndex\n+        * @param pluckValue the _.where style callback\n+        **/\n+        sortedIndex<W, T>(\n+            array: Array<T>,\n+            value: T,\n+            whereValue: W): number;\n+\n+        /**\n+        * @see _.sortedIndex\n+        * @param pluckValue the _.where style callback\n+        **/\n+        sortedIndex<W, T>(\n+            array: List<T>,\n+            value: T,\n+            whereValue: W): number;\n+    }\n+\n+    //_.union\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array of unique values, in order, of the provided arrays using strict \n+        * equality for comparisons, i.e. ===.\n+        * @param arrays The arrays to inspect.\n+        * @return Returns an array of composite values.\n+        **/\n+        union<T>(...arrays: Array<T>[]): T[];\n+\n+        /**\n+        * @see _.union\n+        **/\n+        union<T>(...arrays: List<T>[]): T[];\n+    }\n+\n+    //_.uniq\n+    interface LoDashStatic {\n+        /**\n+        * Creates a duplicate-value-free version of an array using strict equality for comparisons, \n+        * i.e. ===. If the array is sorted, providing true for isSorted will use a faster algorithm. \n+        * If a callback is provided each element of array is passed through the callback before \n+        * uniqueness is computed. The callback is bound to thisArg and invoked with three arguments; \n+        * (value, index, array).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false.\n+        * @param array Array to remove duplicates from.\n+        * @param isSorted True if `array` is already sorted, optiona, default = false.\n+        * @param iterator Transform the elements of `array` before comparisons for uniqueness.\n+        * @param context \'this\' object in `iterator`, optional.\n+        * @return Copy of `array` where all elements are unique.\n+        **/\n+        uniq<T, TSort>(array: Array<T>, isSorted?: boolean): T[];\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        uniq<T, TSort>(array: List<T>, isSorted?: boolean): T[];\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        uniq<T, TSort>(\n+            array: Array<T>,\n+            isSorted: boolean,\n+            callback: ListIterator<T, TSort>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        uniq<T, TSort>(\n+            array: List<T>,\n+            isSorted: boolean,\n+            callback: ListIterator<T, TSort>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        uniq<T, TSort>(\n+            array: Array<T>,\n+            callback: ListIterator<T, TSort>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        uniq<T, TSort>(\n+            array: List<T>,\n+            callback: ListIterator<T, TSort>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        uniq<T>(\n+            array: Array<T>,\n+            isSorted: boolean,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        uniq<T>(\n+            array: List<T>,\n+            isSorted: boolean,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        uniq<T>(\n+            array: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        uniq<T>(\n+            array: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param whereValue _.where style callback\n+        **/\n+        uniq<W, T>(\n+            array: Array<T>,\n+            isSorted: boolean,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param whereValue _.where style callback\n+        **/\n+        uniq<W, T>(\n+            array: List<T>,\n+            isSorted: boolean,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param whereValue _.where style callback\n+        **/\n+        uniq<W, T>(\n+            array: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param whereValue _.where style callback\n+        **/\n+        uniq<W, T>(\n+            array: List<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        unique<T>(array: Array<T>, isSorted?: boolean): T[];\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        unique<T>(array: List<T>, isSorted?: boolean): T[];\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        unique<T, TSort>(\n+            array: Array<T>,\n+            callback: ListIterator<T, TSort>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        unique<T, TSort>(\n+            array: List<T>,\n+            callback: ListIterator<T, TSort>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        unique<T, TSort>(\n+            array: Array<T>,\n+            isSorted: boolean,\n+            callback: ListIterator<T, TSort>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        unique<T, TSort>(\n+            array: List<T>,\n+            isSorted: boolean,\n+            callback: ListIterator<T, TSort>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        unique<T>(\n+            array: Array<T>,\n+            isSorted: boolean,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        unique<T>(\n+            array: List<T>,\n+            isSorted: boolean,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        unique<T>(\n+            array: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        unique<T>(\n+            array: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param whereValue _.where style callback\n+        **/\n+        unique<W, T>(\n+            array: Array<T>,\n+            whereValue?: W): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param whereValue _.where style callback\n+        **/\n+        unique<W, T>(\n+            array: List<T>,\n+            whereValue?: W): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param whereValue _.where style callback\n+        **/\n+        unique<W, T>(\n+            array: Array<T>,\n+            isSorted: boolean,\n+            whereValue?: W): T[];\n+\n+        /**\n+        * @see _.uniq\n+        * @param whereValue _.where style callback\n+        **/\n+        unique<W, T>(\n+            array: List<T>,\n+            isSorted: boolean,\n+            whereValue?: W): T[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.uniq\n+        **/\n+        uniq<TSort>(isSorted?: boolean): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        uniq<TSort>(\n+            isSorted: boolean,\n+            callback: ListIterator<T, TSort>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        uniq<TSort>(\n+            callback: ListIterator<T, TSort>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        uniq(\n+            isSorted: boolean,\n+            pluckValue: string): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        uniq(pluckValue: string): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        * @param whereValue _.where style callback\n+        **/\n+        uniq<W>(\n+            isSorted: boolean,\n+            whereValue: W): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        * @param whereValue _.where style callback\n+        **/\n+        uniq<W>(\n+            whereValue: W): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        unique<TSort>(isSorted?: boolean): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        unique<TSort>(\n+            isSorted: boolean,\n+            callback: ListIterator<T, TSort>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        **/\n+        unique<TSort>(\n+            callback: ListIterator<T, TSort>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        unique(\n+            isSorted: boolean,\n+            pluckValue: string): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        unique(pluckValue: string): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        * @param whereValue _.where style callback\n+        **/\n+        unique<W>(\n+            isSorted: boolean,\n+            whereValue: W): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.uniq\n+        * @param whereValue _.where style callback\n+        **/\n+        unique<W>(\n+            whereValue: W): LoDashArrayWrapper<T>;        \n+    }\n+\n+    //_.without\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array excluding all provided values using strict equality for comparisons, i.e. ===.\n+        * @param array The array to filter.\n+        * @param values The value(s) to exclude.\n+        * @return A new array of filtered values.\n+        **/\n+        without<T>(\n+            array: Array<T>,\n+            ...values: T[]): T[];\n+\n+        /**\n+        * @see _.without\n+        **/\n+        without<T>(\n+            array: List<T>,\n+            ...values: T[]): T[];\n+    }\n+\n+    //_.xor\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array that is the symmetric difference of the provided arrays.\n+        * @param array The array to process\n+        * @param others The arrays of values to calculate the symmetric difference.\n+        * @return Returns a new array of filtered values.\n+        **/\n+        xor<T>(\n+            array: Array<T>,\n+            ...others: Array<T>[]): T[];\n+        /**\n+        * @see _.xor\n+        **/\n+        xor<T>(\n+            array: List<T>,\n+            ...others: List<T>[]): T[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.xor\n+        **/\n+        xor(\n+            ...others: Array<T>[]): LoDashArrayWrapper<T>;\n+        /**\n+        * @see _.xor\n+        **/\n+        xor(\n+            ...others: List<T>[]): LoDashArrayWrapper<T>;\n+    }\n+    \n+    //_.zip\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array of grouped elements, the first of which contains the first \n+        * elements of the given arrays, the second of which contains the second elements \n+        * of the given arrays, and so on.\n+        * @param arrays Arrays to process.\n+        * @return A new array of grouped elements.\n+        **/\n+        zip(...arrays: any[][]): any[][];\n+\n+        /**\n+        * @see _.zip\n+        **/\n+        zip(...arrays: any[]): any[];\n+\n+        /**\n+        * @see _.zip\n+        **/\n+        unzip(...arrays: any[][]): any[][];\n+\n+        /**\n+        * @see _.zip\n+        **/\n+        unzip(...arrays: any[]): any[];\n+    }\n+\n+    //_.zipObject\n+    interface LoDashStatic {\n+        /**\n+        * Creates an object composed from arrays of keys and values. Provide either a single \n+        * two dimensional array, i.e. [[key1, value1], [key2, value2]] or two arrays, one of \n+        * keys and one of corresponding values.\n+        * @param keys The array of keys.\n+        * @param values The array of values.\n+        * @return An object composed of the given keys and corresponding values.\n+        **/\n+        zipObject<TResult extends {}>(\n+            keys: List<string>,\n+            values: List<any>): TResult;\n+\n+        /**\n+        * @see _.object\n+        **/\n+        object<TResult extends {}>(\n+            keys: List<string>,\n+            values: List<any>): TResult;\n+    }\n+\n+    /* *************\n+     * Collections *\n+     ************* */\n+\n+    //_.at\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array of elements from the specified indexes, or keys, of the collection. \n+        * Indexes may be specified as individual arguments or as arrays of indexes.\n+        * @param collection The collection to iterate over.\n+        * @param indexes The indexes of collection to retrieve, specified as individual indexes or \n+        * arrays of indexes.\n+        * @return A new array of elements corresponding to the provided indexes.\n+        **/\n+        at<T>(\n+            collection: Array<T>,\n+            indexes: number[]): T[];\n+\n+        /**\n+        * @see _.at\n+        **/\n+        at<T>(\n+            collection: List<T>,\n+            indexes: number[]): T[];\n+\n+        /**\n+        * @see _.at\n+        **/\n+        at<T>(\n+            collection: Dictionary<T>,\n+            indexes: number[]): T[];\n+\n+        /**\n+        * @see _.at\n+        **/\n+        at<T>(\n+            collection: Array<T>,\n+            ...indexes: number[]): T[];\n+\n+        /**\n+        * @see _.at\n+        **/\n+        at<T>(\n+            collection: List<T>,\n+            ...indexes: number[]): T[];\n+\n+        /**\n+        * @see _.at\n+        **/\n+        at<T>(\n+            collection: Dictionary<T>,\n+            ...indexes: number[]): T[];\n+    }\n+\n+    //_.contains\n+    interface LoDashStatic {\n+        /**\n+        * Checks if a given value is present in a collection using strict equality for comparisons, \n+        * i.e. ===. If fromIndex is negative, it is used as the offset from the end of the collection.\n+        * @param collection The collection to iterate over.\n+        * @param target The value to check for.\n+        * @param fromIndex The index to search from.\n+        * @return True if the target element is found, else false.\n+        **/\n+        contains<T>(\n+            collection: Array<T>,\n+            target: T,\n+            fromIndex?: number): boolean;\n+\n+        /**\n+        * @see _.contains\n+        **/\n+        contains<T>(\n+            collection: List<T>,\n+            target: T,\n+            fromIndex?: number): boolean;\n+\n+        /**\n+        * @see _.contains\n+        * @param dictionary The dictionary to iterate over.\n+        * @param key The key in the dictionary to search for.\n+        **/\n+        contains<T>(\n+            dictionary: Dictionary<T>,\n+            key: string,\n+            fromIndex?: number): boolean;\n+\n+        /**\n+        * @see _.contains\n+        * @param searchString the string to search\n+        * @param targetString the string to search for\n+        **/\n+        contains(\n+            searchString: string,\n+            targetString: string,\n+            fromIndex?: number): boolean;\n+\n+        /**\n+        * @see _.contains\n+        **/\n+        include<T>(\n+            collection: Array<T>,\n+            target: T,\n+            fromIndex?: number): boolean;\n+\n+        /**\n+        * @see _.contains\n+        **/\n+        include<T>(\n+            collection: List<T>,\n+            target: T,\n+            fromIndex?: number): boolean;\n+\n+        /**\n+        * @see _.contains\n+        **/\n+        include<T>(\n+            dictionary: Dictionary<T>,\n+            key: string,\n+            fromIndex?: number): boolean;\n+\n+        /**\n+        * @see _.contains\n+        **/\n+        include(\n+            searchString: string,\n+            targetString: string,\n+            fromIndex?: number): boolean;\n+    }\n+\n+    //_.countBy\n+    interface LoDashStatic {\n+        /**\n+        * Creates an object composed of keys generated from the results of running each element \n+        * of collection through the callback. The corresponding value of each key is the number \n+        * of times the key was returned by the callback. The callback is bound to thisArg and \n+        * invoked with three arguments; (value, index|key, collection).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return Returns the composed aggregate object.\n+        **/\n+        countBy<T>(\n+            collection: Array<T>,\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): Dictionary<number>;\n+\n+        /**\n+        * @see _.countBy\n+        * @param callback Function name\n+        **/\n+        countBy<T>(\n+            collection: List<T>,\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): Dictionary<number>;\n+\n+        /**\n+        * @see _.countBy\n+        * @param callback Function name\n+        **/\n+        countBy<T>(\n+            collection: Dictionary<T>,\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): Dictionary<number>;\n+\n+        /**\n+        * @see _.countBy\n+        * @param callback Function name\n+        **/\n+        countBy<T>(\n+            collection: Array<T>,\n+            callback: string,\n+            thisArg?: any): Dictionary<number>;\n+\n+        /**\n+        * @see _.countBy\n+        * @param callback Function name\n+        **/\n+        countBy<T>(\n+            collection: List<T>,\n+            callback: string,\n+            thisArg?: any): Dictionary<number>;\n+\n+        /**\n+        * @see _.countBy\n+        * @param callback Function name\n+        **/\n+        countBy<T>(\n+            collection: Dictionary<T>,\n+            callback: string,\n+            thisArg?: any): Dictionary<number>;\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.countBy\n+        **/\n+        countBy(\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): LoDashObjectWrapper<Dictionary<number>>;\n+\n+        /**\n+        * @see _.countBy\n+        * @param callback Function name\n+        **/\n+        countBy(\n+            callback: string,\n+            thisArg?: any): LoDashObjectWrapper<Dictionary<number>>;\n+    }\n+\n+    //_.every\n+    interface LoDashStatic {\n+        /**\n+        * Checks if the given callback returns truey value for all elements of a collection. \n+        * The callback is bound to thisArg and invoked with three arguments; (value, index|key, \n+        * collection).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return True if all elements passed the callback check, else false.\n+        **/\n+        every<T>(\n+            collection: Array<T>,\n+            callback?: ListIterator<T, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        every<T>(\n+            collection: List<T>,\n+            callback?: ListIterator<T, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        every<T>(\n+            collection: Dictionary<T>,\n+            callback?: ListIterator<T, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        every<T>(\n+            collection: Array<T>,\n+            pluckValue: string): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        every<T>(\n+            collection: List<T>,\n+            pluckValue: string): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        every<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param whereValue _.where style callback\n+        **/\n+        every<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param whereValue _.where style callback\n+        **/\n+        every<W, T>(\n+            collection: List<T>,\n+            whereValue: W): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param whereValue _.where style callback\n+        **/\n+        every<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): boolean;\n+\n+        /**\n+        * @see _.every\n+        **/\n+        all<T>(\n+            collection: Array<T>,\n+            callback?: ListIterator<T, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+        * @see _.every\n+        **/\n+        all<T>(\n+            collection: List<T>,\n+            callback?: ListIterator<T, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+        * @see _.every\n+        **/\n+        all<T>(\n+            collection: Dictionary<T>,\n+            callback?: ListIterator<T, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        all<T>(\n+            collection: Array<T>,\n+            pluckValue: string): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        all<T>(\n+            collection: List<T>,\n+            pluckValue: string): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        all<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param whereValue _.where style callback\n+        **/\n+        all<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param whereValue _.where style callback\n+        **/\n+        all<W, T>(\n+            collection: List<T>,\n+            whereValue: W): boolean;\n+\n+        /**\n+        * @see _.every\n+        * @param whereValue _.where style callback\n+        **/\n+        all<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): boolean;\n+    }\n+\n+    //_.filter\n+    interface LoDashStatic {\n+        /**\n+        * Iterates over elements of a collection, returning an array of all elements the \n+        * callback returns truey for. The callback is bound to thisArg and invoked with three \n+        * arguments; (value, index|key, collection).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param context The this binding of callback.\n+        * @return Returns a new array of elements that passed the callback check.\n+        **/\n+        filter<T>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.filter\n+        **/\n+        filter<T>(\n+            collection: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.filter\n+        **/\n+        filter<T>(\n+            collection: Dictionary<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        filter<T>(\n+            collection: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        filter<T>(\n+            collection: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        filter<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        filter<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        filter<W, T>(\n+            collection: List<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        filter<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.filter\n+        **/\n+        select<T>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.filter\n+        **/\n+        select<T>(\n+            collection: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.filter\n+        **/\n+        select<T>(\n+            collection: Dictionary<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        select<T>(\n+            collection: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        select<T>(\n+            collection: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        select<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        select<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        select<W, T>(\n+            collection: List<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        select<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): T[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.filter\n+        **/\n+        filter(\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        filter(\n+            pluckValue: string): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        filter<W>(\n+            whereValue: W): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.filter\n+        **/\n+        select(\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        select(\n+            pluckValue: string): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.filter\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        select<W>(\n+            whereValue: W): LoDashArrayWrapper<T>;\n+    }\n+\n+    //_.find\n+    interface LoDashStatic {\n+        /**\n+        * Iterates over elements of a collection, returning the first element that the callback \n+        * returns truey for. The callback is bound to thisArg and invoked with three arguments; \n+        * (value, index|key, collection).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false.\n+        * @param collection Searches for a value in this list.\n+        * @param callback The function called per iteration. \n+        * @param thisArg The this binding of callback.\n+        * @return The found element, else undefined.\n+        **/\n+        find<T>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.find\n+        **/\n+        find<T>(\n+            collection: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.find\n+        **/\n+        find<T>(\n+            collection: Dictionary<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.pluck style callback\n+        **/\n+        find<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.pluck style callback\n+        **/\n+        find<W, T>(\n+            collection: List<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.pluck style callback\n+        **/\n+        find<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.where style callback\n+        **/\n+        find<T>(\n+            collection: Array<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.where style callback\n+        **/\n+        find<T>(\n+            collection: List<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.where style callback\n+        **/\n+        find<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.find\n+        **/\n+        detect<T>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.find\n+        **/\n+        detect<T>(\n+            collection: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.find\n+        **/\n+        detect<T>(\n+            collection: Dictionary<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.pluck style callback\n+        **/\n+        detect<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.pluck style callback\n+        **/\n+        detect<W, T>(\n+            collection: List<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.pluck style callback\n+        **/\n+        detect<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.where style callback\n+        **/\n+        detect<T>(\n+            collection: Array<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.where style callback\n+        **/\n+        detect<T>(\n+            collection: List<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.where style callback\n+        **/\n+        detect<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.find\n+        **/\n+        findWhere<T>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.find\n+        **/\n+        findWhere<T>(\n+            collection: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.find\n+        **/\n+        findWhere<T>(\n+            collection: Dictionary<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.pluck style callback\n+        **/\n+        findWhere<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.pluck style callback\n+        **/\n+        findWhere<W, T>(\n+            collection: List<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.pluck style callback\n+        **/\n+        findWhere<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.where style callback\n+        **/\n+        findWhere<T>(\n+            collection: Array<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.where style callback\n+        **/\n+        findWhere<T>(\n+            collection: List<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.where style callback\n+        **/\n+        findWhere<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): T;\n+    }\n+\n+    //_.findLast\n+    interface LoDashStatic {\n+        /**\n+        * This method is like _.find except that it iterates over elements of a collection from \n+        * right to left.\n+        * @param collection Searches for a value in this list.\n+        * @param callback The function called per iteration. \n+        * @param thisArg The this binding of callback.\n+        * @return The found element, else undefined.\n+        **/\n+        findLast<T>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.find\n+        **/\n+        findLast<T>(\n+            collection: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.find\n+        **/\n+        findLast<T>(\n+            collection: Dictionary<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.pluck style callback\n+        **/\n+        findLast<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.pluck style callback\n+        **/\n+        findLast<W, T>(\n+            collection: List<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.pluck style callback\n+        **/\n+        findLast<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.where style callback\n+        **/\n+        findLast<T>(\n+            collection: Array<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.where style callback\n+        **/\n+        findLast<T>(\n+            collection: List<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.find\n+        * @param _.where style callback\n+        **/\n+        findLast<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): T;\n+    }\n+\n+    //_.forEach\n+    interface LoDashStatic {\n+        /**\n+        * Iterates over elements of a collection, executing the callback for each element. \n+        * The callback is bound to thisArg and invoked with three arguments; (value, index|key, \n+        * collection). Callbacks may exit iteration early by explicitly returning false.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        **/\n+        forEach<T>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, void>,\n+            thisArg?: any): Array<T>;\n+\n+        /**\n+        * @see _.forEach\n+        **/\n+        forEach<T>(\n+            collection: List<T>,\n+            callback: ListIterator<T, void>,\n+            thisArg?: any): List<T>;\n+\n+        /**\n+        * @see _.forEach\n+        **/\n+        forEach<T extends {}>(\n+            object: Dictionary<T>,\n+            callback: ObjectIterator<T, void>,\n+            thisArg?: any): Dictionary<T>;\n+\n+        /**\n+        * @see _.each\n+        **/\n+        forEach<T extends {}, TValue>(\n+            object: T,\n+            callback: ObjectIterator<TValue, void>,\n+            thisArg?: any): T\n+\n+        /**\n+        * @see _.forEach\n+        **/\n+        each<T>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, void>,\n+            thisArg?: any): Array<T>;\n+\n+        /**\n+        * @see _.forEach\n+        **/\n+        each<T>(\n+            collection: List<T>,\n+            callback: ListIterator<T, void>,\n+            thisArg?: any): List<T>;\n+\n+        /**\n+        * @see _.forEach\n+        * @param object The object to iterate over\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        **/\n+        each<T extends {}>(\n+            object: Dictionary<T>,\n+            callback: ObjectIterator<T, void>,\n+            thisArg?: any): Dictionary<T>;\n+\n+        /**\n+        * @see _.each\n+        **/\n+        each<T extends {}, TValue>(\n+            object: T,\n+            callback: ObjectIterator<TValue, void>,\n+            thisArg?: any): T\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.forEach\n+        **/\n+        forEach(\n+            callback: ListIterator<T, void>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.forEach\n+        **/\n+        each(\n+            callback: ListIterator<T, void>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.forEach\n+        **/\n+        forEach<T extends {}>(\n+            callback: ObjectIterator<T, void>,\n+            thisArg?: any): LoDashObjectWrapper<T>;\n+\n+        /**\n+        * @see _.forEach\n+        **/\n+        each<T extends {}>(\n+            callback: ObjectIterator<T, void>,\n+            thisArg?: any): LoDashObjectWrapper<T>;\n+    }\n+\n+    //_.forEachRight\n+    interface LoDashStatic {\n+        /**\n+        * This method is like _.forEach except that it iterates over elements of a \n+        * collection from right to left.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        **/\n+        forEachRight<T>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, void>,\n+            thisArg?: any): Array<T>;\n+\n+        /**\n+        * @see _.forEachRight\n+        **/\n+        forEachRight<T>(\n+            collection: List<T>,\n+            callback: ListIterator<T, void>,\n+            thisArg?: any): List<T>;\n+\n+        /**\n+        * @see _.forEachRight\n+        **/\n+        forEachRight<T extends {}>(\n+            object: Dictionary<T>,\n+            callback: ObjectIterator<T, void>,\n+            thisArg?: any): Dictionary<T>;\n+\n+        /**\n+        * @see _.forEachRight\n+        **/\n+        eachRight<T>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, void>,\n+            thisArg?: any): Array<T>;\n+\n+        /**\n+        * @see _.forEachRight\n+        **/\n+        eachRight<T>(\n+            collection: List<T>,\n+            callback: ListIterator<T, void>,\n+            thisArg?: any): List<T>;\n+\n+        /**\n+        * @see _.forEachRight\n+        * @param object The object to iterate over\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        **/\n+        eachRight<T extends {}>(\n+            object: Dictionary<T>,\n+            callback: ObjectIterator<T, void>,\n+            thisArg?: any): Dictionary<T>;\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.forEachRight\n+        **/\n+        forEachRight(\n+            callback: ListIterator<T, void>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.forEachRight\n+        **/\n+        eachRight(\n+            callback: ListIterator<T, void>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.forEachRight\n+        **/\n+        forEachRight<T extends {}>(\n+            callback: ObjectIterator<T, void>,\n+            thisArg?: any): LoDashObjectWrapper<Dictionary<T>>;\n+\n+        /**\n+        * @see _.forEachRight\n+        * @param object The object to iterate over\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        **/\n+        eachRight<T extends {}>(\n+            callback: ObjectIterator<T, void>,\n+            thisArg?: any): LoDashObjectWrapper<Dictionary<T>>;\n+    }\n+\n+    //_.groupBy\n+    interface LoDashStatic {\n+        /**\n+        * Creates an object composed of keys generated from the results of running each element \n+        * of a collection through the callback. The corresponding value of each key is an array \n+        * of the elements responsible for generating the key. The callback is bound to thisArg \n+        * and invoked with three arguments; (value, index|key, collection).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return Returns the composed aggregate object.\n+        **/\n+        groupBy<T>(\n+            collection: Array<T>,\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): Dictionary<T[]>;\n+\n+        /**\n+        * @see _.groupBy\n+        **/\n+        groupBy<T>(\n+            collection: List<T>,\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): Dictionary<T[]>;\n+\n+        /**\n+        * @see _.groupBy\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        groupBy<T>(\n+            collection: Array<T>,\n+            pluckValue: string): Dictionary<T[]>;\n+\n+        /**\n+        * @see _.groupBy\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        groupBy<T>(\n+            collection: List<T>,\n+            pluckValue: string): Dictionary<T[]>;\n+\n+        /**\n+        * @see _.groupBy\n+        * @param whereValue _.where style callback\n+        **/\n+        groupBy<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): Dictionary<T[]>;\n+\n+        /**\n+        * @see _.groupBy\n+        * @param whereValue _.where style callback\n+        **/\n+        groupBy<W, T>(\n+            collection: List<T>,\n+            whereValue: W): Dictionary<T[]>;\n+\n+        /**\n+        * @see _.groupBy\n+        **/\n+        groupBy<T>(\n+            collection: Dictionary<T>,\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): Dictionary<T[]>;\n+\n+        /**\n+        * @see _.groupBy\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        groupBy<TValue>(\n+            collection: Dictionary<TValue>,\n+            pluckValue: string): Dictionary<TValue[]>;\n+\n+        /**\n+        * @see _.groupBy\n+        * @param whereValue _.where style callback\n+        **/\n+        groupBy<W, TValue>(\n+            collection: Dictionary<TValue>,\n+            whereValue: W): Dictionary<TValue[]>;\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.groupBy\n+        **/\n+        groupBy(\n+            callback: ListIterator<T, any>,\n+            thisArg?: any): _.LoDashObjectWrapper<_.Dictionary<T[]>>;\n+\n+        /**\n+        * @see _.groupBy\n+        **/\n+        groupBy(\n+            pluckValue: string): _.LoDashObjectWrapper<_.Dictionary<T[]>>;\n+\n+        /**\n+        * @see _.groupBy\n+        **/\n+        groupBy<W>(\n+            whereValue: W): _.LoDashObjectWrapper<_.Dictionary<T[]>>;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.groupBy\n+        **/\n+        groupBy<TValue>(\n+            callback: ListIterator<TValue, any>,\n+            thisArg?: any): _.LoDashObjectWrapper<_.Dictionary<TValue[]>>;\n+\n+        /**\n+        * @see _.groupBy\n+        **/\n+        groupBy<TValue>(\n+            pluckValue: string): _.LoDashObjectWrapper<_.Dictionary<TValue[]>>;\n+\n+        /**\n+        * @see _.groupBy\n+        **/\n+        groupBy<W, TValue>(\n+            whereValue: W): _.LoDashObjectWrapper<_.Dictionary<TValue[]>>;\n+    }\n+\n+    //_.indexBy\n+    interface LoDashStatic {\n+        /**\n+        * Creates an object composed of keys generated from the results of running each element \n+        * of the collection through the given callback. The corresponding value of each key is \n+        * the last element responsible for generating the key. The callback is bound to thisArg \n+        * and invoked with three arguments; (value, index|key, collection).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return Returns the composed aggregate object.\n+        **/\n+        indexBy<T>(\n+            list: Array<T>,\n+            iterator: ListIterator<T, any>,\n+            context?: any): Dictionary<T>;\n+\n+        /**\n+        * @see _.indexBy\n+        **/\n+        indexBy<T>(\n+            list: List<T>,\n+            iterator: ListIterator<T, any>,\n+            context?: any): Dictionary<T>;\n+\n+        /**\n+        * @see _.indexBy\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        indexBy<T>(\n+            collection: Array<T>,\n+            pluckValue: string): Dictionary<T>;\n+\n+        /**\n+        * @see _.indexBy\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        indexBy<T>(\n+            collection: List<T>,\n+            pluckValue: string): Dictionary<T>;\n+\n+        /**\n+        * @see _.indexBy\n+        * @param whereValue _.where style callback\n+        **/\n+        indexBy<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): Dictionary<T>;\n+\n+        /**\n+        * @see _.indexBy\n+        * @param whereValue _.where style callback\n+        **/\n+        indexBy<W, T>(\n+            collection: List<T>,\n+            whereValue: W): Dictionary<T>;\n+    }\n+\n+    //_.invoke\n+    interface LoDashStatic {\n+        /**\n+        * Invokes the method named by methodName on each element in the collection returning \n+        * an array of the results of each invoked method. Additional arguments will be provided \n+        * to each invoked method. If methodName is a function it will be invoked for, and this \n+        * bound to, each element in the collection.\n+        * @param collection The collection to iterate over.\n+        * @param methodName The name of the method to invoke.\n+        * @param args Arguments to invoke the method with.\n+        **/\n+        invoke<T extends {}>(\n+            collection: Array<T>,\n+            methodName: string,\n+            ...args: any[]): any;\n+\n+        /**\n+        * @see _.invoke\n+        **/\n+        invoke<T extends {}>(\n+            collection: List<T>,\n+            methodName: string,\n+            ...args: any[]): any;\n+\n+        /**\n+        * @see _.invoke\n+        **/\n+        invoke<T extends {}>(\n+            collection: Dictionary<T>,\n+            methodName: string,\n+            ...args: any[]): any;\n+\n+        /**\n+        * @see _.invoke\n+        **/\n+        invoke<T extends {}>(\n+            collection: Array<T>,\n+            method: Function,\n+            ...args: any[]): any;\n+\n+        /**\n+        * @see _.invoke\n+        **/\n+        invoke<T extends {}>(\n+            collection: List<T>,\n+            method: Function,\n+            ...args: any[]): any;\n+\n+        /**\n+        * @see _.invoke\n+        **/\n+        invoke<T extends {}>(\n+            collection: Dictionary<T>,\n+            method: Function,\n+            ...args: any[]): any;\n+    }\n+\n+    //_.map\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array of values by running each element in the collection through the callback. \n+        * The callback is bound to thisArg and invoked with three arguments; (value, index|key, \n+        * collection).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will return \n+        * the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return true \n+        * for elements that have the properties of the given object, else false.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param theArg The this binding of callback.\n+        * @return The mapped array result.\n+        **/\n+        map<T, TResult>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, TResult>,\n+            thisArg?: any): TResult[];\n+\n+        /**\n+        * @see _.map\n+        **/\n+        map<T, TResult>(\n+            collection: List<T>,\n+            callback: ListIterator<T, TResult>,\n+            thisArg?: any): TResult[];\n+\n+        /**\n+        * @see _.map\n+        * @param object The object to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg `this` object in `iterator`, optional.\n+        * @return The mapped object result.\n+        **/\n+        map<T extends {}, TResult>(\n+            object: Dictionary<T>,\n+            callback: ObjectIterator<T, TResult>,\n+            thisArg?: any): TResult[];\n+\n+        /**\n+        * @see _.map\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        map<T, TResult>(\n+            collection: Array<T>,\n+            pluckValue: string): TResult[];\n+\n+        /**\n+        * @see _.map\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        map<T, TResult>(\n+            collection: List<T>,\n+            pluckValue: string): TResult[];\n+\n+        /**\n+        * @see _.map\n+        **/\n+        collect<T, TResult>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, TResult>,\n+            thisArg?: any): TResult[];\n+\n+        /**\n+        * @see _.map\n+        **/\n+        collect<T, TResult>(\n+            collection: List<T>,\n+            callback: ListIterator<T, TResult>,\n+            thisArg?: any): TResult[];\n+\n+        /**\n+        * @see _.map\n+        **/\n+        collect<T extends {}, TResult>(\n+            object: Dictionary<T>,\n+            callback: ObjectIterator<T, TResult>,\n+            thisArg?: any): TResult[];\n+\n+        /**\n+        * @see _.map\n+        **/\n+        collect<T, TResult>(\n+            collection: Array<T>,\n+            pluckValue: string): TResult[];\n+\n+        /**\n+        * @see _.map\n+        **/\n+        collect<T, TResult>(\n+            collection: List<T>,\n+            pluckValue: string): TResult[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.map\n+        **/\n+        map<TResult>(\n+            callback: ListIterator<T, TResult>,\n+            thisArg?: any): LoDashArrayWrapper<TResult>;\n+\n+        /**\n+        * @see _.map\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        map<TResult>(\n+            pluckValue: string): LoDashArrayWrapper<TResult>;\n+\n+        /**\n+        * @see _.map\n+        **/\n+        collect<TResult>(\n+            callback: ListIterator<T, TResult>,\n+            thisArg?: any): LoDashArrayWrapper<TResult>;\n+\n+        /**\n+        * @see _.map\n+        **/\n+        collect<TResult>(\n+            pluckValue: string): LoDashArrayWrapper<TResult>;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.map\n+        **/\n+        map<T extends {}, TResult>(\n+            callback: ObjectIterator<T, TResult>,\n+            thisArg?: any): LoDashArrayWrapper<TResult>;\n+\n+        /**\n+        * @see _.map\n+        **/\n+        collect<T extends {}, TResult>(\n+            callback: ObjectIterator<T, TResult>,\n+            thisArg?: any): LoDashArrayWrapper<TResult>;\n+    }\n+\n+    //_.max\n+    interface LoDashStatic {\n+        /**\n+        * Retrieves the maximum value of a collection. If the collection is empty or falsey -Infinity is \n+        * returned. If a callback is provided it will be executed for each value in the collection to \n+        * generate the criterion by which the value is ranked. The callback is bound to thisArg and invoked \n+        * with three arguments; (value, index, collection).\n+        * \n+        * If a property name is provided for callback the created "_.pluck" style callback will return the \n+        * property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return true for \n+        * elements that have the properties of the given object, else false.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return Returns the maximum value.\n+        **/\n+        max<T>(\n+            collection: Array<T>,\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.max\n+        **/\n+        max<T>(\n+            collection: List<T>,\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.max\n+        **/\n+        max<T>(\n+            collection: Dictionary<T>,\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.max\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        max<T>(\n+            collection: Array<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.max\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        max<T>(\n+            collection: List<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.max\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        max<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.max\n+        * @param whereValue _.where style callback\n+        **/\n+        max<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.max\n+        * @param whereValue _.where style callback\n+        **/\n+        max<W, T>(\n+            collection: List<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.max\n+        * @param whereValue _.where style callback\n+        **/\n+        max<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): T;\n+    }\n+\n+    //_.min\n+    interface LoDashStatic {\n+        /**\n+        * Retrieves the minimum value of a collection. If the collection is empty or falsey \n+        * Infinity is returned. If a callback is provided it will be executed for each value \n+        * in the collection to generate the criterion by which the value is ranked. The callback \n+        * is bound to thisArg and invoked with three arguments; (value, index, collection).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback \n+        * will return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will \n+        * return true for elements that have the properties of the given object, else false.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return Returns the maximum value.\n+        **/\n+        min<T>(\n+            collection: Array<T>,\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.min\n+        **/\n+        min<T>(\n+            collection: List<T>,\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.min\n+        **/\n+        min<T>(\n+            collection: Dictionary<T>,\n+            callback?: ListIterator<T, any>,\n+            thisArg?: any): T;\n+\n+        /**\n+        * @see _.min\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        min<T>(\n+            collection: Array<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.min\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        min<T>(\n+            collection: List<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.min\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        min<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): T;\n+\n+        /**\n+        * @see _.min\n+        * @param whereValue _.where style callback\n+        **/\n+        min<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.min\n+        * @param whereValue _.where style callback\n+        **/\n+        min<W, T>(\n+            collection: List<T>,\n+            whereValue: W): T;\n+\n+        /**\n+        * @see _.min\n+        * @param whereValue _.where style callback\n+        **/\n+        min<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): T;\n+    }\n+\n+    //_.pluck\n+    interface LoDashStatic {\n+        /**\n+        * Retrieves the value of a specified property from all elements in the collection.\n+        * @param collection The collection to iterate over.\n+        * @param property The property to pluck.\n+        * @return A new array of property values.\n+        **/\n+        pluck<T extends {}>(\n+            collection: Array<T>,\n+            property: string): any[];\n+\n+        /**\n+        * @see _.pluck\n+        **/\n+        pluck<T extends {}>(\n+            collection: List<T>,\n+            property: string): any[];\n+\n+        /**\n+        * @see _.pluck\n+        **/\n+        pluck<T extends {}>(\n+            collection: Dictionary<T>,\n+            property: string): any[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.pluck\n+        **/\n+        pluck<TResult>(\n+            property: string): LoDashArrayWrapper<TResult>;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.pluck\n+        **/\n+        pluck<TResult>(\n+            property: string): LoDashArrayWrapper<TResult>;\n+    }\n+\n+    //_.reduce\n+    interface LoDashStatic {\n+        /**\n+        * Reduces a collection to a value which is the accumulated result of running each \n+        * element in the collection through the callback, where each successive callback execution \n+        * consumes the return value of the previous execution. If accumulator is not provided the \n+        * first element of the collection will be used as the initial accumulator value. The callback \n+        * is bound to thisArg and invoked with four arguments; (accumulator, value, index|key, collection).\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param accumulator Initial value of the accumulator.\n+        * @param thisArg The this binding of callback.\n+        * @return Returns the accumulated value.\n+        **/\n+        reduce<T, TResult>(\n+            collection: Array<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        reduce<T, TResult>(\n+            collection: List<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        reduce<T, TResult>(\n+            collection: Dictionary<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        reduce<T, TResult>(\n+            collection: Array<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        reduce<T, TResult>(\n+            collection: List<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        reduce<T, TResult>(\n+            collection: Dictionary<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        inject<T, TResult>(\n+            collection: Array<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        inject<T, TResult>(\n+            collection: List<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        inject<T, TResult>(\n+            collection: Dictionary<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        inject<T, TResult>(\n+            collection: Array<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        inject<T, TResult>(\n+            collection: List<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        inject<T, TResult>(\n+            collection: Dictionary<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        foldl<T, TResult>(\n+            collection: Array<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        foldl<T, TResult>(\n+            collection: List<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        foldl<T, TResult>(\n+            collection: Dictionary<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        foldl<T, TResult>(\n+            collection: Array<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        foldl<T, TResult>(\n+            collection: List<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        foldl<T, TResult>(\n+            collection: Dictionary<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+         /**\n+        * @see _.reduce\n+        **/\n+        reduce<TResult>(\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        reduce<TResult>(\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        inject<TResult>(\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        inject<TResult>(\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        foldl<TResult>(\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        foldl<TResult>(\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+         /**\n+        * @see _.reduce\n+        **/\n+        reduce<TValue, TResult>(\n+            callback: MemoIterator<TValue, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        reduce<TValue, TResult>(\n+            callback: MemoIterator<TValue, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        inject<TValue, TResult>(\n+            callback: MemoIterator<TValue, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        inject<TValue, TResult>(\n+            callback: MemoIterator<TValue, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        foldl<TValue, TResult>(\n+            callback: MemoIterator<TValue, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduce\n+        **/\n+        foldl<TValue, TResult>(\n+            callback: MemoIterator<TValue, TResult>,\n+            thisArg?: any): TResult;\n+    }\n+\n+    //_.reduceRight\n+    interface LoDashStatic {\n+        /**\n+        * This method is like _.reduce except that it iterates over elements of a collection from \n+        * right to left.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param accumulator Initial value of the accumulator.\n+        * @param thisArg The this binding of callback.\n+        * @return The accumulated value.\n+        **/\n+        reduceRight<T, TResult>(\n+            collection: Array<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduceRight\n+        **/\n+        reduceRight<T, TResult>(\n+            collection: List<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduceRight\n+        **/\n+        reduceRight<T, TResult>(\n+            collection: Dictionary<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduceRight\n+        **/\n+        reduceRight<T, TResult>(\n+            collection: Array<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduceRight\n+        **/\n+        reduceRight<T, TResult>(\n+            collection: List<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduceRight\n+        **/\n+        reduceRight<T, TResult>(\n+            collection: Dictionary<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduceRight\n+        **/\n+        foldr<T, TResult>(\n+            collection: Array<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduceRight\n+        **/\n+        foldr<T, TResult>(\n+            collection: List<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduceRight\n+        **/\n+        foldr<T, TResult>(\n+            collection: Dictionary<T>,\n+            callback: MemoIterator<T, TResult>,\n+            accumulator: TResult,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduceRight\n+        **/\n+        foldr<T, TResult>(\n+            collection: Array<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduceRight\n+        **/\n+        foldr<T, TResult>(\n+            collection: List<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.reduceRight\n+        **/\n+        foldr<T, TResult>(\n+            collection: Dictionary<T>,\n+            callback: MemoIterator<T, TResult>,\n+            thisArg?: any): TResult;\n+    }\n+\n+    //_.reject\n+    interface LoDashStatic {\n+        /**\n+        * The opposite of _.filter this method returns the elements of a collection that \n+        * the callback does not return truey for.\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback \n+        * will return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will \n+        * return true for elements that have the properties of the given object, else false.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return A new array of elements that failed the callback check.\n+        **/\n+        reject<T>(\n+            collection: Array<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.reject\n+        **/\n+        reject<T>(\n+            collection: List<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.reject\n+        **/\n+        reject<T>(\n+            collection: Dictionary<T>,\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.reject\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        reject<T>(\n+            collection: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.reject\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        reject<T>(\n+            collection: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.reject\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        reject<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.reject\n+        * @param whereValue _.where style callback\n+        **/\n+        reject<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.reject\n+        * @param whereValue _.where style callback\n+        **/\n+        reject<W, T>(\n+            collection: List<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.reject\n+        * @param whereValue _.where style callback\n+        **/\n+        reject<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): T[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.reject\n+        **/\n+        reject(\n+            callback: ListIterator<T, boolean>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.reject\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        reject(pluckValue: string): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.reject\n+        * @param whereValue _.where style callback\n+        **/\n+        reject<W>(whereValue: W): LoDashArrayWrapper<T>;\n+    }\n+\n+    //_.sample\n+    interface LoDashStatic {\n+        /**\n+        * Retrieves a random element or n random elements from a collection.\n+        * @param collection The collection to sample.\n+        * @return Returns the random sample(s) of collection.\n+        **/\n+        sample<T>(collection: Array<T>): T;\n+\n+        /**\n+        * @see _.sample\n+        **/\n+        sample<T>(collection: List<T>): T;\n+\n+        /**\n+        * @see _.sample\n+        **/\n+        sample<T>(collection: Dictionary<T>): T;\n+\n+        /**\n+        * @see _.sample\n+        * @param n The number of elements to sample.\n+        **/\n+        sample<T>(collection: Array<T>, n: number): T[];\n+\n+        /**\n+        * @see _.sample\n+        * @param n The number of elements to sample.\n+        **/\n+        sample<T>(collection: List<T>, n: number): T[];\n+\n+        /**\n+        * @see _.sample\n+        * @param n The number of elements to sample.\n+        **/\n+        sample<T>(collection: Dictionary<T>, n: number): T[];\n+    }\n+\n+    //_.shuffle\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array of shuffled values, using a version of the Fisher-Yates shuffle. \n+        * See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.\n+        * @param collection The collection to shuffle.\n+        * @return Returns a new shuffled collection.\n+        **/\n+        shuffle<T>(collection: Array<T>): T[];\n+\n+        /**\n+        * @see _.shuffle\n+        **/\n+        shuffle<T>(collection: List<T>): T[];\n+\n+        /**\n+        * @see _.shuffle\n+        **/\n+        shuffle<T>(collection: Dictionary<T>): T[];\n+    }\n+\n+    //_.size\n+    interface LoDashStatic {\n+        /**\n+        * Gets the size of the collection by returning collection.length for arrays and array-like \n+        * objects or the number of own enumerable properties for objects.\n+        * @param collection The collection to inspect.\n+        * @return collection.length\n+        **/\n+        size<T>(collection: Array<T>): number;\n+\n+        /**\n+        * @see _.size\n+        **/\n+        size<T>(collection: List<T>): number;\n+\n+        /**\n+        * @see _.size\n+        * @param object The object to inspect\n+        * @return The number of own enumerable properties.\n+        **/\n+        size<T extends {}>(object: T): number;\n+\n+        /**\n+        * @see _.size\n+        * @param aString The string to inspect\n+        * @return The length of aString\n+        **/\n+        size(aString: string): number;\n+    }\n+\n+    //_.some\n+    interface LoDashStatic {\n+        /**\n+        * Checks if the callback returns a truey value for any element of a collection. The function \n+        * returns as soon as it finds a passing value and does not iterate over the entire collection. \n+        * The callback is bound to thisArg and invoked with three arguments; (value, index|key, collection).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will return \n+        * the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return true for \n+        * elements that have the properties of the given object, else false.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return True if any element passed the callback check, else false.\n+        **/\n+        some<T>(\n+            collection: Array<T>,\n+            callback?: ListIterator<T, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+        * @see _.some\n+        **/\n+        some<T>(\n+            collection: List<T>,\n+            callback?: ListIterator<T, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+        * @see _.some\n+        **/\n+        some<T>(\n+            collection: Dictionary<T>,\n+            callback?: ListIterator<T, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+         * @see _.some\n+         **/\n+        some(\n+            collection: {},\n+            callback?: ListIterator<{}, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+        * @see _.some\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        some<T>(\n+            collection: Array<T>,\n+            pluckValue: string): boolean;\n+\n+        /**\n+        * @see _.some\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        some<T>(\n+            collection: List<T>,\n+            pluckValue: string): boolean;\n+\n+        /**\n+        * @see _.some\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        some<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): boolean;\n+\n+        /**\n+        * @see _.some\n+        * @param whereValue _.where style callback\n+        **/\n+        some<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): boolean;\n+\n+        /**\n+        * @see _.some\n+        * @param whereValue _.where style callback\n+        **/\n+        some<W, T>(\n+            collection: List<T>,\n+            whereValue: W): boolean;\n+\n+        /**\n+        * @see _.some\n+        * @param whereValue _.where style callback\n+        **/\n+        some<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): boolean;\n+\n+        /**\n+        * @see _.some\n+        **/\n+        any<T>(\n+            collection: Array<T>,\n+            callback?: ListIterator<T, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+        * @see _.some\n+        **/\n+        any<T>(\n+            collection: List<T>,\n+            callback?: ListIterator<T, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+        * @see _.some\n+        **/\n+        any<T>(\n+            collection: Dictionary<T>,\n+            callback?: ListIterator<T, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+         * @see _.some\n+         **/\n+        any(\n+            collection: {},\n+            callback?: ListIterator<{}, boolean>,\n+            thisArg?: any): boolean;\n+\n+        /**\n+        * @see _.some\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        any<T>(\n+            collection: Array<T>,\n+            pluckValue: string): boolean;\n+\n+        /**\n+        * @see _.some\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        any<T>(\n+            collection: List<T>,\n+            pluckValue: string): boolean;\n+\n+        /**\n+        * @see _.some\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        any<T>(\n+            collection: Dictionary<T>,\n+            pluckValue: string): boolean;\n+\n+        /**\n+        * @see _.some\n+        * @param whereValue _.where style callback\n+        **/\n+        any<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): boolean;\n+\n+        /**\n+        * @see _.some\n+        * @param whereValue _.where style callback\n+        **/\n+        any<W, T>(\n+            collection: List<T>,\n+            whereValue: W): boolean;\n+\n+        /**\n+        * @see _.some\n+        * @param whereValue _.where style callback\n+        **/\n+        any<W, T>(\n+            collection: Dictionary<T>,\n+            whereValue: W): boolean;\n+    }\n+\n+    //_.sortBy\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array of elements, sorted in ascending order by the results of running each \n+        * element in a collection through the callback. This method performs a stable sort, that \n+        * is, it will preserve the original sort order of equal elements. The callback is bound \n+        * to thisArg and invoked with three arguments; (value, index|key, collection).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will \n+        * return the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return \n+        * true for elements that have the properties of the given object, else false.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return A new array of sorted elements.\n+        **/\n+        sortBy<T, TSort>(\n+            collection: Array<T>,\n+            callback?: ListIterator<T, TSort>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.sortBy\n+        **/\n+        sortBy<T, TSort>(\n+            collection: List<T>,\n+            callback?: ListIterator<T, TSort>,\n+            thisArg?: any): T[];\n+\n+        /**\n+        * @see _.sortBy\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        sortBy<T>(\n+            collection: Array<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.sortBy\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        sortBy<T>(\n+            collection: List<T>,\n+            pluckValue: string): T[];\n+\n+        /**\n+        * @see _.sortBy\n+        * @param whereValue _.where style callback\n+        **/\n+        sortBy<W, T>(\n+            collection: Array<T>,\n+            whereValue: W): T[];\n+\n+        /**\n+        * @see _.sortBy\n+        * @param whereValue _.where style callback\n+        **/\n+        sortBy<W, T>(\n+            collection: List<T>,\n+            whereValue: W): T[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.sortBy\n+        **/\n+        sortBy<TSort>(\n+            callback?: ListIterator<T, TSort>,\n+            thisArg?: any): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.sortBy\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        sortBy(pluckValue: string): LoDashArrayWrapper<T>;\n+\n+        /**\n+        * @see _.sortBy\n+        * @param whereValue _.where style callback\n+        **/\n+        sortBy<W>(whereValue: W): LoDashArrayWrapper<T>;\n+    }\n+\n+    //_.toArray\n+    interface LoDashStatic {\n+        /**\n+        * Converts the collection to an array.\n+        * @param collection The collection to convert.\n+        * @return The new converted array.\n+        **/\n+        toArray<T>(collection: Array<T>): T[];\n+\n+        /**\n+        * @see _.toArray\n+        **/\n+        toArray<T>(collection: List<T>): T[];\n+\n+        /**\n+        * @see _.toArray\n+        **/\n+        toArray<T>(collection: Dictionary<T>): T[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.toArray\n+        **/\n+        toArray(): LoDashArrayWrapper<T>;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.toArray\n+        **/\n+        toArray<TValue>(): LoDashArrayWrapper<TValue>;\n+    }\n+\n+    //_.where\n+    interface LoDashStatic {\n+        /**\n+        * Performs a deep comparison of each element in a collection to the given properties \n+        * object, returning an array of all elements that have equivalent property values.\n+        * @param collection The collection to iterate over.\n+        * @param properties The object of property values to filter by.\n+        * @return A new array of elements that have the given properties.\n+        **/\n+        where<T, U extends {}>(\n+            list: Array<T>,\n+            properties: U): T[];\n+\n+        /**\n+        * @see _.where\n+        **/\n+        where<T, U extends {}>(\n+            list: List<T>,\n+            properties: U): T[];\n+\n+        /**\n+        * @see _.where\n+        **/\n+        where<T, U extends {}>(\n+            list: Dictionary<T>,\n+            properties: U): T[];\n+    }\n+\n+    interface LoDashArrayWrapper<T> {\n+        /**\n+        * @see _.where\n+        **/\n+        where<T, U extends {}>(properties: U): LoDashArrayWrapper<T>;\n+    }\n+\n+    /*************\n+     * Functions *\n+     *************/\n+\n+    //_.after\n+    interface LoDashStatic {\n+        /**\n+        * Creates a function that executes func, with the this binding and arguments of the \n+        * created function, only after being called n times.\n+        * @param n The number of times the function must be called before func is executed.\n+        * @param func The function to restrict.\n+        * @return The new restricted function.\n+        **/\n+        after(\n+            n: number,\n+            func: Function): Function;\n+    }\n+\n+    interface LoDashWrapper<T> {\n+        /**\n+        * @see _.after\n+        **/\n+        after(func: Function): LoDashObjectWrapper<Function>;\n+    }\n+\n+    //_.bind\n+    interface LoDashStatic {\n+        /**\n+        * Creates a function that, when called, invokes func with the this binding of thisArg \n+        * and prepends any additional bind arguments to those provided to the bound function.\n+        * @param func The function to bind.\n+        * @param thisArg The this binding of func.\n+        * @param args Arguments to be partially applied.\n+        * @return The new bound function.\n+        **/\n+        bind(\n+            func: Function,\n+            thisArg: any,\n+            ...args: any[]): () => any;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.bind\n+        **/\n+        bind(\n+            thisArg: any,\n+            ...args: any[]): LoDashObjectWrapper<() => any>;\n+    }\n+\n+    //_.bindAll\n+    interface LoDashStatic {\n+        /**\n+        * Binds methods of an object to the object itself, overwriting the existing method. Method \n+        * names may be specified as individual arguments or as arrays of method names. If no method \n+        * names are provided all the function properties of object will be bound.\n+        * @param object The object to bind and assign the bound methods to.\n+        * @param methodNames The object method names to bind, specified as individual method names \n+        * or arrays of method names.\n+        * @return object\n+        **/\n+        bindAll<T>(\n+            object: T,\n+            ...methodNames: string[]): T;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.bindAll\n+        **/\n+        bindAll(...methodNames: string[]): LoDashWrapper<T>;\n+    }\n+\n+    //_.bindKey\n+    interface LoDashStatic {\n+        /**\n+        * Creates a function that, when called, invokes the method at object[key] and prepends any \n+        * additional bindKey arguments to those provided to the bound function. This method differs \n+        * from _.bind by allowing bound functions to reference methods that will be redefined or don\'t \n+        * yet exist. See http://michaux.ca/articles/lazy-function-definition-pattern.\n+        * @param object The object the method belongs to.\n+        * @param key The key of the method.\n+        * @param args Arguments to be partially applied.\n+        * @return The new bound function.\n+        **/\n+        bindKey<T>(\n+            object: T,\n+            key: string,\n+            ...args: any[]): Function;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.bindKey\n+        **/\n+        bindKey(\n+            key: string,\n+            ...args: any[]): LoDashObjectWrapper<Function>;\n+    }\n+\n+    //_.compose\n+    interface LoDashStatic {\n+        /**\n+        * Creates a function that is the composition of the provided functions, where each function \n+        * consumes the return value of the function that follows. For example, composing the functions \n+        * f(), g(), and h() produces f(g(h())). Each function is executed with the this binding of the \n+        * composed function.\n+        * @param funcs Functions to compose.\n+        * @return The new composed function.\n+        **/\n+        compose(...funcs: Function[]): Function;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.compose\n+        **/\n+        compose(...funcs: Function[]): LoDashObjectWrapper<Function>;\n+    }\n+\n+    //_.createCallback\n+    interface LoDashStatic {\n+        /**\n+        * Produces a callback bound to an optional thisArg. If func is a property name the created \n+        * callback will return the property value for a given element. If func is an object the created \n+        * callback will return true for elements that contain the equivalent object properties, \n+        * otherwise it will return false.\n+        * @param func The value to convert to a callback.\n+        * @param thisArg The this binding of the created callback.\n+        * @param argCount The number of arguments the callback accepts.\n+        * @return A callback function.\n+        **/\n+        createCallback(\n+            func: string,\n+            thisArg?: any,\n+            argCount?: number): () => any;\n+\n+        /**\n+        * @see _.createCallback\n+        **/\n+        createCallback(\n+            func: Dictionary<any>,\n+            thisArg?: any,\n+            argCount?: number): () => boolean;\n+    }\n+\n+    interface LoDashWrapper<T> {\n+        /**\n+        * @see _.createCallback\n+        **/\n+        createCallback(\n+            thisArg?: any,\n+            argCount?: number): LoDashObjectWrapper<() => any>;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.createCallback\n+        **/\n+        createCallback(\n+            thisArg?: any,\n+            argCount?: number): LoDashObjectWrapper<() => any>;\n+    }\n+\n+    //_.curry\n+    interface LoDashStatic {\n+        /**\n+        * Creates a function which accepts one or more arguments of func that when invoked either \n+        * executes func returning its result, if all func arguments have been provided, or returns \n+        * a function that accepts one or more of the remaining func arguments, and so on. The arity \n+        * of func can be specified if func.length is not sufficient.\n+        * @param func The function to curry.\n+        * @param arity The arity of func.\n+        * @return The new curried function.\n+        **/\n+        curry(\n+            func: Function,\n+            arity?: number): Function;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.curry\n+        **/\n+        curry(arity?: number): LoDashObjectWrapper<Function>;\n+    }\n+\n+    //_.debounce\n+    interface LoDashStatic {\n+        /**\n+        * Creates a function that will delay the execution of func until after wait milliseconds have \n+        * elapsed since the last time it was invoked. Provide an options object to indicate that func \n+        * should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent calls \n+        * to the debounced function will return the result of the last func call.\n+        *\n+        * Note: If leading and trailing options are true func will be called on the trailing edge of \n+        * the timeout only if the the debounced function is invoked more than once during the wait \n+        * timeout.\n+        * @param func The function to debounce.\n+        * @param wait The number of milliseconds to delay.\n+        * @param options The options object.\n+        * @param options.leading Specify execution on the leading edge of the timeout.\n+        * @param options.maxWait The maximum time func is allowed to be delayed before it’s called.\n+        * @param options.trailing Specify execution on the trailing edge of the timeout.\n+        * @return The new debounced function.\n+        **/\n+        debounce<T extends Function>(\n+            func: T,\n+            wait: number,\n+            options?: DebounceSettings): T;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.debounce\n+        **/\n+        debounce(\n+            wait: number,\n+            options?: DebounceSettings): LoDashObjectWrapper<Function>;\n+    }\n+\n+    interface DebounceSettings {\n+        /**\n+        * Specify execution on the leading edge of the timeout.\n+        **/\n+        leading?: boolean;\n+\n+        /**\n+        * The maximum time func is allowed to be delayed before it’s called.\n+        **/\n+        maxWait?: number;\n+\n+        /**\n+        * Specify execution on the trailing edge of the timeout.\n+        **/\n+        trailing?: boolean;\n+    }\n+\n+    //_.defer\n+    interface LoDashStatic {\n+        /**\n+        * Defers executing the func function until the current call stack has cleared. Additional \n+        * arguments will be provided to func when it is invoked.\n+        * @param func The function to defer.\n+        * @param args Arguments to invoke the function with.\n+        * @return The timer id.\n+        **/\n+        defer(\n+            func: Function,\n+            ...args: any[]): number;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.defer\n+        **/\n+        defer(...args: any[]): LoDashWrapper<number>;\n+    }\n+\n+    //_.delay\n+    interface LoDashStatic {\n+        /**\n+        * Executes the func function after wait milliseconds. Additional arguments will be provided \n+        * to func when it is invoked.\n+        * @param func The function to delay.\n+        * @param wait The number of milliseconds to delay execution.\n+        * @param args Arguments to invoke the function with.\n+        * @return The timer id.\n+        **/\n+        delay(\n+            func: Function,\n+            wait: number,\n+            ...args: any[]): number;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.delay\n+        **/\n+        delay(\n+            wait: number,\n+            ...args: any[]): LoDashWrapper<number>;\n+    }\n+\n+    //_.memoize\n+    interface LoDashStatic {\n+        /**\n+        * Creates a function that memoizes the result of func. If resolver is provided it will be \n+        * used to determine the cache key for storing the result based on the arguments provided to \n+        * the memoized function. By default, the first argument provided to the memoized function is \n+        * used as the cache key. The func is executed with the this binding of the memoized function. \n+        * The result cache is exposed as the cache property on the memoized function.\n+        * @param func Computationally expensive function that will now memoized results.\n+        * @param resolver Hash function for storing the result of `fn`.\n+        * @return Returns the new memoizing function.\n+        **/\n+        memoize<T extends Function>(\n+            func: T,\n+            resolver?: Function): T;\n+    }\n+\n+    //_.once\n+    interface LoDashStatic {\n+        /**\n+        * Creates a function that is restricted to execute func once. Repeat calls to the function \n+        * will return the value of the first call. The func is executed with the this binding of the \n+        * created function.\n+        * @param func Function to only execute once.\n+        * @return The new restricted function.\n+        **/\n+        once<T extends Function>(func: T): T;\n+    }\n+\n+    //_.partial\n+    interface LoDashStatic {\n+        /**\n+        * Creates a function that, when called, invokes func with any additional partial arguments \n+        * prepended to those provided to the new function. This method is similar to _.bind except \n+        * it does not alter the this binding.\n+        * @param func The function to partially apply arguments to.\n+        * @param args Arguments to be partially applied.\n+        * @return The new partially applied function.\n+        **/\n+        partial(\n+            func: Function,\n+            ...args: any[]): Function;\n+    }\n+\n+    //_.partialRight\n+    interface LoDashStatic {\n+        /**\n+        * This method is like _.partial except that partial arguments are appended to those provided \n+        * to the new function.\n+        * @param func The function to partially apply arguments to.\n+        * @param args Arguments to be partially applied.\n+        * @return The new partially applied function.\n+        **/\n+        partialRight(\n+            func: Function,\n+            ...args: any[]): Function;\n+    }\n+\n+    //_.throttle\n+    interface LoDashStatic {\n+        /**\n+        * Creates a function that, when executed, will only call the func function at most once per \n+        * every wait milliseconds. Provide an options object to indicate that func should be invoked \n+        * on the leading and/or trailing edge of the wait timeout. Subsequent calls to the throttled \n+        * function will return the result of the last func call.\n+        *\n+        * Note: If leading and trailing options are true func will be called on the trailing edge of \n+        * the timeout only if the the throttled function is invoked more than once during the wait timeout.\n+        * @param func The function to throttle.\n+        * @param wait The number of milliseconds to throttle executions to.\n+        * @param options The options object.\n+        * @param options.leading Specify execution on the leading edge of the timeout.\n+        * @param options.trailing Specify execution on the trailing edge of the timeout.\n+        * @return The new throttled function.\n+        **/\n+        throttle<T extends Function>(\n+            func: T,\n+            wait: number,\n+            options?: ThrottleSettings): T;\n+    }\n+\n+    interface ThrottleSettings {\n+\n+        /**\n+        * If you\'d like to disable the leading-edge call, pass this as false.\n+        **/\n+        leading?: boolean;\n+\n+        /**\n+        * If you\'d like to disable the execution on the trailing-edge, pass false.\n+        **/\n+        trailing?: boolean;\n+    }\n+\n+    //_.wrap\n+    interface LoDashStatic {\n+        /**\n+        * Creates a function that provides value to the wrapper function as its first argument. \n+        * Additional arguments provided to the function are appended to those provided to the \n+        * wrapper function. The wrapper is executed with the this binding of the created function.\n+        * @param value The value to wrap.\n+        * @param wrapper The wrapper function.\n+        * @return The new function.\n+        **/\n+        wrap(\n+            value: any,\n+            wrapper: (func: Function, ...args: any[]) => any): Function;\n+    }\n+\n+    /*************\n+     * Objects   *\n+     *************/\n+\n+    //_.assign\n+    interface LoDashStatic {\n+        /**\n+        * Assigns own enumerable properties of source object(s) to the destination object. Subsequent \n+        * sources will overwrite property assignments of previous sources. If a callback is provided \n+        * it will be executed to produce the assigned values. The callback is bound to thisArg and \n+        * invoked with two arguments; (objectValue, sourceValue).\n+        * @param object The destination object.\n+        * @param s1-8 The source object(s)\n+        * @param callback The function to customize merging properties.\n+        * @param thisArg The this binding of callback.\n+        * @return The destination object.\n+        **/\n+        assign<P, T, S1, Value, Result>(\n+            object: T,\n+            s1: S1,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): Result;\n+\n+        /**\n+        * @see _.assign\n+        **/\n+        assign<P, T, S1, S2, Value, Result>(\n+            object: T,\n+            s1: S1,\n+            s2: S2,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): Result;\n+\n+        /**\n+        * @see _.assign\n+        **/\n+        assign<P, T, S1, S2, S3, Value, Result>(\n+            object: T,\n+            s1: S1,\n+            s2: S2,\n+            s3: S3,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): Result;\n+\n+        /**\n+        * @see _.assign\n+        **/\n+        assign<P, T, S1, S2, S3, S4, Value, Result>(\n+            object: T,\n+            s1: S1,\n+            s2: S2,\n+            s3: S3,\n+            s4: S4,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): Result;\n+\n+        /**\n+        * @see _.assign\n+        **/\n+        extend<P, T, S1, Value, Result>(\n+            object: T,\n+            s1: S1,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): Result;\n+\n+        /**\n+        * @see _.assign\n+        **/\n+        extend<P, T, S1, S2, Value, Result>(\n+            object: T,\n+            s1: S1,\n+            s2: S2,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): Result;\n+\n+        /**\n+        * @see _.assign\n+        **/\n+        extend<P, T, S1, S2, S3, Value, Result>(\n+            object: T,\n+            s1: S1,\n+            s2: S2,\n+            s3: S3,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): Result;\n+\n+        /**\n+        * @see _.assign\n+        **/\n+        extend<P, T, S1, S2, S3, S4, Value, Result>(\n+            object: T,\n+            s1: S1,\n+            s2: S2,\n+            s3: S3,\n+            s4: S4,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): Result;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.assign\n+        **/\n+        assign<S1, Value, TResult>(\n+            s1: S1,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.assign\n+        **/\n+        assign<S1, S2, Value, TResult>(\n+            s1: S1,\n+            s2: S2,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): TResult;\n+        /**\n+        * @see _.assign\n+        **/\n+        assign<S1, S2, S3, Value, TResult>(\n+            s1: S1,\n+            s2: S2,\n+            s3: S3,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): TResult;\n+        /**\n+        * @see _.assign\n+        **/\n+        assign<S1, S2, S3, S4, Value, TResult>(\n+            s1: S1,\n+            s2: S2,\n+            s3: S3,\n+            s4: S4,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): TResult;\n+        /**\n+        * @see _.assign\n+        **/\n+        assign<S1, S2, S3, S4, S5, Value, TResult>(\n+            s1: S1,\n+            s2: S2,\n+            s3: S3,\n+            s4: S4,\n+            s5: S5,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.assign\n+        **/\n+        extend<S1, Value, TResult>(\n+            s1: S1,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): TResult;\n+\n+        /**\n+        * @see _.assign\n+        **/\n+        extend<S1, S2, Value, TResult>(\n+            s1: S1,\n+            s2: S2,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): TResult;\n+        /**\n+        * @see _.assign\n+        **/\n+        extend<S1, S2, S3, Value, TResult>(\n+            s1: S1,\n+            s2: S2,\n+            s3: S3,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): TResult;\n+        /**\n+        * @see _.assign\n+        **/\n+        extend<S1, S2, S3, S4, Value, TResult>(\n+            s1: S1,\n+            s2: S2,\n+            s3: S3,\n+            s4: S4,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): TResult;\n+        /**\n+        * @see _.assign\n+        **/\n+        extend<S1, S2, S3, S4, S5, Value, TResult>(\n+            s1: S1,\n+            s2: S2,\n+            s3: S3,\n+            s4: S4,\n+            s5: S5,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): TResult;\n+\n+    }\n+\n+    //_.clone\n+    interface LoDashStatic {\n+        /**\n+        * Creates a clone of value. If deep is true nested objects will also be cloned, otherwise \n+        * they will be assigned by reference. If a callback is provided it will be executed to produce \n+        * the cloned values. If the callback returns undefined cloning will be handled by the method \n+        * instead. The callback is bound to thisArg and invoked with one argument; (value).\n+        * @param value The value to clone.\n+        * @param deep Specify a deep clone.\n+        * @param callback The function to customize cloning values.\n+        * @param thisArg The this binding of callback.\n+        * @return The cloned value.\n+        **/\n+        clone<T>(\n+            value: T,\n+            deep?: boolean,\n+            callback?: (value: any) => any,\n+            thisArg?: any): T;\n+    }\n+\n+    //_.cloneDeep\n+    interface LoDashStatic {\n+        /**\n+        * Creates a deep clone of value. If a callback is provided it will be executed to produce the \n+        * cloned values. If the callback returns undefined cloning will be handled by the method instead. \n+        * The callback is bound to thisArg and invoked with one argument; (value).\n+        *\n+        * Note: This method is loosely based on the structured clone algorithm. Functions and DOM nodes \n+        * are not cloned. The enumerable properties of arguments objects and objects created by constructors \n+        * other than Object are cloned to plain Object objects. \n+        * See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.\n+        * @param value The value to clone.\n+        * @param callback The function to customize cloning values.\n+        * @param thisArg The this binding of callback.\n+        * @return The cloned value.\n+        **/\n+        cloneDeep<T>(\n+            value: T,\n+            callback?: (value: any) => any,\n+            thisArg?: any): T;\n+    }\n+\n+    //_.defaults\n+    interface LoDashStatic {\n+        /**\n+        * Assigns own enumerable properties of source object(s) to the destination object for all \n+        * destination properties that resolve to undefined. Once a property is set, additional defaults \n+        * of the same property will be ignored.\n+        * @param object The destination object.\n+        * @param sources The source objects.\n+        * @return The destination object.\n+        **/\n+        defaults<T, TResult>(\n+            object: T,\n+            ...sources: any[]): TResult;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.defaults\n+        **/\n+        defaults<T, TResult>(...sources: any[]): LoDashObjectWrapper<TResult>\n+    }\n+\n+    //_.findKey\n+    interface LoDashStatic {\n+        /**\n+        * This method is like _.findIndex except that it returns the key of the first element that \n+        * passes the callback check, instead of the element itself.\n+        * @param object The object to search.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return The key of the found element, else undefined.\n+        **/\n+        findKey(\n+            object: any,\n+            callback: (value: any) => boolean,\n+            thisArg?: any): string;\n+\n+        /**\n+        * @see _.findKey\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        findKey(\n+            object: any,\n+            pluckValue: string): string;\n+\n+        /**\n+        * @see _.findKey\n+        * @param whereValue _.where style callback\n+        **/\n+        findKey<W extends Dictionary<any>, T>(\n+            object: T,\n+            whereValue: W): string;\n+    }\n+\n+    //_.findLastKey\n+    interface LoDashStatic {\n+        /**\n+        * This method is like _.findKey except that it iterates over elements of a collection in the opposite order.\n+        * @param object The object to search.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return The key of the found element, else undefined.\n+        **/\n+        findLastKey(\n+            object: any,\n+            callback: (value: any) => boolean,\n+            thisArg?: any): string;\n+\n+        /**\n+        * @see _.findLastKey\n+        * @param pluckValue _.pluck style callback\n+        **/\n+        findLastKey(\n+            object: any,\n+            pluckValue: string): string;\n+\n+        /**\n+        * @see _.findLastKey\n+        * @param whereValue _.where style callback\n+        **/\n+        findLastKey<W extends Dictionary<any>, T>(\n+            object: T,\n+            whereValue: W): string;\n+    }\n+\n+    //_.forIn\n+    interface LoDashStatic {\n+        /**\n+        * Iterates over own and inherited enumerable properties of an object, executing the callback for \n+        * each property. The callback is bound to thisArg and invoked with three arguments; (value, key, \n+        * object). Callbacks may exit iteration early by explicitly returning false.\n+        * @param object The object to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return object\n+        **/\n+        forIn<T>(\n+            object: Dictionary<T>,\n+            callback?: ObjectIterator<T, void>,\n+            thisArg?: any): Dictionary<T>;\n+\n+        /**\n+        * @see _.forIn\n+        **/\n+        forIn<T>(\n+            object: T,\n+            callback?: ObjectIterator<any, void>,\n+            thisArg?: any): T;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.forIn\n+        **/\n+        forIn<T extends {}>(\n+            callback: ObjectIterator<T, void>,\n+            thisArg?: any): _.LoDashObjectWrapper<T>;\n+    }\n+\n+    //_.forInRight\n+    interface LoDashStatic {\n+        /**\n+        * This method is like _.forIn except that it iterates over elements of a collection in the \n+        * opposite order.\n+        * @param object The object to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return object\n+        **/\n+        forInRight<T extends {}>(\n+            object: Dictionary<T>,\n+            callback?: ObjectIterator<T, void>,\n+            thisArg?: any): Dictionary<T>;\n+\n+        /**\n+        * @see _.forInRight\n+        **/\n+        forInRight<T extends {}>(\n+            object: T,\n+            callback?: ObjectIterator<T, void>,\n+            thisArg?: any): T;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.forInRight\n+        **/\n+        forInRight<T extends {}>(\n+            callback: ObjectIterator<T, void>,\n+            thisArg?: any): _.LoDashObjectWrapper<T>;\n+    }\n+\n+    //_.forOwn\n+    interface LoDashStatic {\n+        /**\n+        * Iterates over own enumerable properties of an object, executing the callback for each \n+        * property. The callback is bound to thisArg and invoked with three arguments; (value, key, \n+        * object). Callbacks may exit iteration early by explicitly returning false.\n+        * @param object The object to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return object\n+        **/\n+        forOwn<T extends {}>(\n+            object: Dictionary<T>,\n+            callback?: ObjectIterator<T, void>,\n+            thisArg?: any): Dictionary<T>;\n+\n+        /**\n+        * @see _.forOwn\n+        **/\n+        forOwn<T extends {}>(\n+            object: T,\n+            callback?: ObjectIterator<any, void>,\n+            thisArg?: any): T;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.forOwn\n+        **/\n+        forOwn<T extends {}>(\n+            callback: ObjectIterator<T, void>,\n+            thisArg?: any): _.LoDashObjectWrapper<T>;\n+    }\n+\n+    //_.forOwnRight\n+    interface LoDashStatic {\n+        /**\n+        * This method is like _.forOwn except that it iterates over elements of a collection in the \n+        * opposite order.\n+        * @param object The object to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        * @return object\n+        **/\n+        forOwnRight<T extends {}>(\n+            object: Dictionary<T>,\n+            callback?: ObjectIterator<T, void>,\n+            thisArg?: any): Dictionary<T>;\n+        /**\n+        * @see _.forOwnRight\n+        **/\n+        forOwnRight<T extends {}>(\n+            object: T,\n+            callback?: ObjectIterator<any, void>,\n+            thisArg?: any): T;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.forOwnRight\n+        **/\n+        forOwnRight<T extends {}>(\n+            callback: ObjectIterator<T, void>,\n+            thisArg?: any): _.LoDashObjectWrapper<T>;\n+    }\n+\n+    //_.functions\n+    interface LoDashStatic {\n+        /**\n+        * Creates a sorted array of property names of all enumerable properties, own and inherited, of \n+        * object that have function values.\n+        * @param object The object to inspect.\n+        * @return An array of property names that have function values.\n+        **/\n+        functions(object: any): string[];\n+\n+        /**\n+        * @see _functions\n+        **/\n+        methods(object: any): string[];\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.functions\n+        **/\n+        functions(): _.LoDashArrayWrapper<string>;\n+\n+        /**\n+        * @see _.functions\n+        **/\n+        methods(): _.LoDashArrayWrapper<string>;\n+    }\n+\n+    //_.has\n+    interface LoDashStatic {\n+        /**\n+        * Checks if the specified object property exists and is a direct property, instead of an \n+        * inherited property.\n+        * @param object The object to check.\n+        * @param property The property to check for.\n+        * @return True if key is a direct property, else false.\n+        **/\n+        has(object: any, property: string): boolean;\n+    }\n+\n+    //_.invert\n+    interface LoDashStatic {\n+        /**\n+        * Creates an object composed of the inverted keys and values of the given object.\n+        * @param object The object to invert.\n+        * @return The created inverted object.\n+        **/\n+        invert(object: any): any;\n+    }\n+\n+    //_.isArguments\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is an arguments object.\n+        * @param value The value to check.\n+        * @return True if the value is an arguments object, else false.\n+        **/\n+        isArguments(value: any): boolean;\n+    }\n+\n+    //_.isArray\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is an array.\n+        * @param value The value to check.\n+        * @return True if the value is an array, else false.\n+        **/\n+        isArray(value: any): boolean;\n+    }\n+\n+    //_.isBoolean\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is a boolean value.\n+        * @param value The value to check.\n+        * @return True if the value is a boolean value, else false.\n+        **/\n+        isBoolean(value: any): boolean;\n+    }\n+\n+    //_.isDate\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is a date.\n+        * @param value The value to check.\n+        * @return True if the value is a date, else false.\n+        **/\n+        isDate(value: any): boolean;\n+    }\n+\n+    //_.isElement\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is a DOM element.\n+        * @param value The value to check.\n+        * @return True if the value is a DOM element, else false.\n+        **/\n+        isElement(value: any): boolean;\n+    }\n+\n+    //_.isEmpty\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is empty. Arrays, strings, or arguments objects with a length of 0 and objects \n+        * with no own enumerable properties are considered "empty".\n+        * @param value The value to inspect.\n+        * @return True if the value is empty, else false.\n+        **/\n+        isEmpty(value: any[]): boolean;\n+\n+        /**\n+        * @see _.isEmpty\n+        **/\n+        isEmpty(value: Dictionary<any>): boolean;\n+\n+        /**\n+        * @see _.isEmpty\n+        **/\n+        isEmpty(value: string): boolean;\n+\n+        /**\n+        * @see _.isEmpty\n+        **/\n+        isEmpty(value: any): boolean;\n+    }\n+\n+    //_.isEqual\n+    interface LoDashStatic {\n+        /**\n+        * Performs a deep comparison between two values to determine if they are equivalent to each \n+        * other. If a callback is provided it will be executed to compare values. If the callback \n+        * returns undefined comparisons will be handled by the method instead. The callback is bound to \n+        * thisArg and invoked with two arguments; (a, b).\n+        * @param a The value to compare.\n+        * @param b The other value to compare.\n+        * @param callback The function to customize comparing values.\n+        * @param thisArg The this binding of callback.\n+        * @return True if the values are equivalent, else false.\n+        **/\n+        isEqual(\n+            a: any,\n+            b: any,\n+            callback?: (a: any, b: any) => boolean,\n+            thisArg?: any): boolean;\n+    }\n+\n+    //_.isFinite\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is, or can be coerced to, a finite number.\n+        *\n+        * Note: This is not the same as native isFinite which will return true for booleans and empty \n+        * strings. See http://es5.github.io/#x15.1.2.5.\n+        * @param value The value to check.\n+        * @return True if the value is finite, else false.\n+        **/\n+        isFinite(value: any): boolean;\n+    }\n+\n+    //_.isFunction\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is a function.\n+        * @param value The value to check.\n+        * @return True if the value is a function, else false.\n+        **/\n+        isFunction(value: any): boolean;\n+    }\n+\n+    //_.isNaN\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is NaN.\n+        *\n+        * Note: This is not the same as native isNaN which will return true for undefined and other \n+        * non-numeric values. See http://es5.github.io/#x15.1.2.4.\n+        * @param value The value to check.\n+        * @return True if the value is NaN, else false.\n+        **/\n+        isNaN(value: any): boolean;\n+    }\n+\n+    //_.isNull\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is null.\n+        * @param value The value to check.\n+        * @return True if the value is null, else false.\n+        **/\n+        isNull(value: any): boolean;\n+    }\n+\n+    //_.isNumber\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is a number.\n+        *\n+        * Note: NaN is considered a number. See http://es5.github.io/#x8.5.\n+        * @param value The value to check.\n+        * @return True if the value is a number, else false.\n+        **/\n+        isNumber(value: any): boolean;\n+    }\n+\n+    //_.isObject\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is the language type of Object. (e.g. arrays, functions, objects, regexes, \n+        * new Number(0), and new String(\'\'))\n+        * @param value The value to check.\n+        * @return True if the value is an object, else false.\n+        **/\n+        isObject(value: any): boolean;\n+    }\n+\n+    //_.isPlainObject\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is an object created by the Object constructor.\n+        * @param value The value to check.\n+        * @return True if value is a plain object, else false.\n+        **/\n+        isPlainObject(value: any): boolean;\n+    }\n+\n+    //_.isRegExp\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is a regular expression.\n+        * @param value The value to check.\n+        * @return True if the value is a regular expression, else false.\n+        **/\n+        isRegExp(value: any): boolean;\n+    }\n+\n+    //_.isString\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is a string.\n+        * @param value The value to check.\n+        * @return True if the value is a string, else false.\n+        **/\n+        isString(value: any): boolean;\n+    }\n+\n+    //_.isUndefined\n+    interface LoDashStatic {\n+        /**\n+        * Checks if value is undefined.\n+        * @param value The value to check.\n+        * @return True if the value is undefined, else false.\n+        **/\n+        isUndefined(value: any): boolean;\n+    }\n+\n+    //_.keys\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array composed of the own enumerable property names of an object.\n+        * @param object The object to inspect.\n+        * @return An array of property names.\n+        **/\n+        keys(object: any): string[];\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.keys\n+        **/\n+        keys(): LoDashArrayWrapper<string>\n+    }\n+\n+    //_.mapValues\n+    interface LoDashStatic {\n+        /**\n+        * Creates an object with the same keys as object and values generated by running each own\n+        * enumerable property of object through the callback. The callback is bound to thisArg and\n+        * invoked with three arguments; (value, key, object).\n+        *\n+        * If a property name is provided for callback the created "_.pluck" style callback will return\n+        * the property value of the given element.\n+        *\n+        * If an object is provided for callback the created "_.where" style callback will return true\n+        * for elements that have the properties of the given object, else false.\n+        *\n+        * @param object The object to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param thisArg `this` object in `iterator`, optional.\n+        * @return Returns a new object with values of the results of each callback execution.\n+        */\n+        mapValues<T, TResult>(obj: Dictionary<T>, callback: ObjectIterator<T, TResult>, thisArg?: any): Dictionary<TResult>;\n+        mapValues<T>(obj: Dictionary<T>, where: Dictionary<T>): Dictionary<boolean>;\n+        mapValues<T, TMapped>(obj: T, pluck: string): TMapped;\n+        mapValues<T>(obj: T, callback: ObjectIterator<any, any>, thisArg?: any): T;\n+    }\n+\n+    //_.merge\n+    interface LoDashStatic {\n+        /**\n+        * Recursively merges own enumerable properties of the source object(s), that don\'t resolve \n+        * to undefined into the destination object. Subsequent sources will overwrite property \n+        * assignments of previous sources. If a callback is provided it will be executed to produce \n+        * the merged values of the destination and source properties. If the callback returns undefined \n+        * merging will be handled by the method instead. The callback is bound to thisArg and invoked \n+        * with two arguments; (objectValue, sourceValue).\n+        * @param object The destination object.\n+        * @param s1-8 The source object(s)\n+        * @param callback The function to customize merging properties.\n+        * @param thisArg The this binding of callback.\n+        * @return The destination object.\n+        **/\n+        merge<P, T, S1, Value, Result>(\n+            object: T,\n+            s1: S1,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): Result;\n+\n+        /**\n+        * @see _.merge\n+        **/\n+        merge<P, T, S1, S2, Value, Result>(\n+            object: T,\n+            s1: S1,\n+            s2: S2,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): Result;\n+\n+        /**\n+        * @see _.merge\n+        **/\n+        merge<P, T, S1, S2, S3, Value, Result>(\n+            object: T,\n+            s1: S1,\n+            s2: S2,\n+            s3: S3,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): Result;\n+\n+        /**\n+        * @see _.merge\n+        **/\n+        merge<P, T, S1, S2, S3, S4, Value, Result>(\n+            object: T,\n+            s1: S1,\n+            s2: S2,\n+            s3: S3,\n+            s4: S4,\n+            callback?: (objectValue: Value, sourceValue: Value) => Value,\n+            thisArg?: any): Result;\n+    }\n+\n+    //_.omit\n+    interface LoDashStatic {\n+        /**\n+        * Creates a shallow clone of object excluding the specified properties. Property names may be \n+        * specified as individual arguments or as arrays of property names. If a callback is provided \n+        * it will be executed for each property of object omitting the properties the callback returns \n+        * truey for. The callback is bound to thisArg and invoked with three arguments; (value, key, \n+        * object).\n+        * @param object The source object.\n+        * @param keys The properties to omit.\n+        * @return An object without the omitted properties.\n+        **/\n+        omit<Omitted, T>(\n+            object: T,\n+            ...keys: string[]): Omitted;\n+\n+        /**\n+        * @see _.omit\n+        **/\n+        omit<Omitted, T>(\n+            object: T,\n+            keys: string[]): Omitted;\n+\n+        /**\n+        * @see _.omit\n+        **/\n+        omit<Omitted, T>(\n+            object: T,\n+            callback: ObjectIterator<any, boolean>,\n+            thisArg?: any): Omitted;\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.omit\n+        **/\n+        omit<Omitted>(\n+            ...keys: string[]): LoDashObjectWrapper<Omitted>;\n+\n+        /**\n+        * @see _.omit\n+        **/\n+        omit<Omitted>(\n+            keys: string[]): LoDashObjectWrapper<Omitted>;\n+\n+        /**\n+        * @see _.omit\n+        **/\n+        omit<Omitted>(\n+            callback: ObjectIterator<any, boolean>,\n+            thisArg?: any): LoDashObjectWrapper<Omitted>;\n+    }\n+\n+    //_.pairs\n+    interface LoDashStatic {\n+        /**\n+        * Creates a two dimensional array of an object’s key-value pairs, \n+        * i.e. [[key1, value1], [key2, value2]].\n+        * @param object The object to inspect.\n+        * @return Aew array of key-value pairs.\n+        **/\n+        pairs(object: any): any[][];\n+    }\n+\n+    interface LoDashObjectWrapper<T> {\n+        /**\n+        * @see _.pairs\n+        **/\n+        pairs(): LoDashArrayWrapper<any[]>;\n+    }\n+\n+    //_.picks\n+    interface LoDashStatic {\n+        /**\n+        * Creates a shallow clone of object composed of the specified properties. Property names may be \n+        * specified as individual arguments or as arrays of property names. If a callback is provided \n+        * it will be executed for each property of object picking the properties the callback returns \n+        * truey for. The callback is bound to thisArg and invoked with three arguments; (value, key, \n+        * object).\n+        * @param object Object to strip unwanted key/value pairs.\n+        * @param keys Property names to pick\n+        * @return An object composed of the picked properties.\n+        **/\n+        pick<Picked, T>(\n+            object: T,\n+            ...keys: string[]): Picked;\n+\n+        /**\n+        * @see _.pick\n+        **/\n+        pick<Picked, T>(\n+            object: T,\n+            keys: string[]): Picked;\n+\n+        /**\n+        * @see _.pick\n+        **/\n+        pick<Picked, T>(\n+            object: T,\n+            callback: ObjectIterator<any, boolean>,\n+            thisArg?: any): Picked;\n+    }\n+\n+    //_.transform\n+    interface LoDashStatic {\n+        /**\n+        * An alternative to _.reduce this method transforms object to a new accumulator object which is \n+        * the result of running each of its elements through a callback, with each callback execution \n+        * potentially mutating the accumulator object. The callback is bound to thisArg and invoked with \n+        * four arguments; (accumulator, value, key, object). Callbacks may exit iteration early by \n+        * explicitly returning false.\n+        * @param collection The collection to iterate over.\n+        * @param callback The function called per iteration.\n+        * @param accumulator The custom accumulator value.\n+        * @param thisArg The this binding of callback.\n+        * @return The accumulated value.\n+        **/\n+        transform<T, Acc>(\n+            collection: Array<T>,\n+            callback: MemoVoidIterator<T, Acc>,\n+            accumulator: Acc,\n+            thisArg?: any): Acc;\n+\n+        /**\n+        * @see _.transform\n+        **/\n+        transform<T, Acc>(\n+            collection: List<T>,\n+            callback: MemoVoidIterator<T, Acc>,\n+            accumulator: Acc,\n+            thisArg?: any): Acc;\n+\n+        /**\n+        * @see _.transform\n+        **/\n+        transform<T, Acc>(\n+            collection: Dictionary<T>,\n+            callback: MemoVoidIterator<T, Acc>,\n+            accumulator: Acc,\n+            thisArg?: any): Acc;\n+\n+        /**\n+        * @see _.transform\n+        **/\n+        transform<T, Acc>(\n+            collection: Array<T>,\n+            callback?: MemoVoidIterator<T, Acc>,\n+            thisArg?: any): Acc;\n+\n+        /**\n+        * @see _.transform\n+        **/\n+        transform<T, Acc>(\n+            collection: List<T>,\n+            callback?: MemoVoidIterator<T, Acc>,\n+            thisArg?: any): Acc;\n+\n+        /**\n+        * @see _.transform\n+        **/\n+        transform<T, Acc>(\n+            collection: Dictionary<T>,\n+            callback?: MemoVoidIterator<T, Acc>,\n+            thisArg?: any): Acc;\n+    }\n+\n+    //_.values\n+    interface LoDashStatic {\n+        /**\n+        * Creates an array composed of the own enumerable property values of object.\n+        * @param object The object to inspect.\n+        * @return Returns an array of property values.\n+        **/\n+        values(object: any): any[];\n+    }\n+\n+    /*************\n+     * Utilities *\n+     *************/\n+    //_.escape\n+    interface LoDashStatic {\n+        /**\n+        * Converts the characters &, <, >, ", and \' in string to their corresponding HTML entities.\n+        * @param string The string to escape.\n+        * @return The escaped string.\n+        **/\n+        escape(str: string): string;\n+    }\n+\n+    //_.identity\n+    interface LoDashStatic {\n+        /**\n+        * This method returns the first argument provided to it.\n+        * @param value Any value.\n+        * @return value.\n+        **/\n+        identity<T>(value: T): T;\n+    }\n+\n+    //_.mixin\n+    interface LoDashStatic {\n+        /**\n+        * Adds function properties of a source object to the lodash function and chainable wrapper.\n+        * @param object The object of function properties to add to lodash.\n+        **/\n+        mixin(object: Dictionary<(value: any) => any>): void;\n+    }\n+\n+    //_.noConflict\n+    interface LoDashStatic {\n+        /**\n+        * Reverts the \'_\' variable to its previous value and returns a reference to the lodash function.\n+        * @return The lodash function.\n+        **/\n+        noConflict(): typeof _;\n+    }\n+\n+    //_.parseInt\n+    interface LoDashStatic {\n+        /**\n+        * Converts the given value into an integer of the specified radix. If radix is undefined or 0 a \n+        * radix of 10 is used unless the value is a hexadecimal, in which case a radix of 16 is used.\n+        *\n+        * Note: This method avoids differences in native ES3 and ES5 parseInt implementations. See \n+        * http://es5.github.io/#E.\n+        * @param value The value to parse.\n+        * @param radix The radix used to interpret the value to parse.\n+        * @return The new integer value.\n+        **/\n+        parseInt(value: string): number;\n+    }\n+\n+    //_.random\n+    interface LoDashStatic {\n+        /**\n+        * Produces a random number between min and max (inclusive). If only one argument is provided a \n+        * number between 0 and the given number will be returned. If floating is truey or either min or \n+        * max are floats a floating-point number will be returned instead of an integer.\n+        * @param max The maximum possible value.\n+        * @param floating Specify returning a floating-point number.\n+        * @return A random number.\n+        **/\n+        random(max: number, floating?: boolean): number;\n+\n+        /**\n+        * @see _.random\n+        * @param min The minimum possible value.\n+        * @return A random number between `min` and `max`.\n+        **/\n+        random(min: number, max: number, floating?: boolean): number;\n+    }\n+\n+    //_.result\n+    interface LoDashStatic {\n+        /**\n+        * Resolves the value of property on object. If property is a function it will be invoked with \n+        * the this binding of object and its result returned, else the property value is returned. If \n+        * object is falsey then undefined is returned.\n+        * @param object The object to inspect.\n+        * @param property The property to get the value of.\n+        * @return The resolved value.\n+        **/\n+        result(object: any, property: string): any;\n+    }\n+\n+    //_.runInContext\n+    interface LoDashStatic {\n+        /**\n+        * Create a new lodash function using the given context object.\n+        * @param context The context object\n+        * @returns The lodash function.\n+        **/\n+        runInContext(context: any): typeof _;\n+    }\n+\n+    //_.template\n+    interface LoDashStatic {\n+        /**\n+        * A micro-templating method that handles arbitrary delimiters, preserves whitespace, and \n+        * correctly escapes quotes within interpolated code.\n+        *\n+        * Note: In the development build, _.template utilizes sourceURLs for easier debugging. See \n+        * http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl\n+        *\n+        * For more information on precompiling templates see:\n+        * http://lodash.com/#custom-builds\n+        *\n+        * For more information on Chrome extension sandboxes see:\n+        * http://developer.chrome.com/stable/extensions/sandboxingEval.html\n+        * @param text The template text.\n+        * @param data The data object used to populate the text.\n+        * @param options The options object.\n+        * @param options.escape The "escape" delimiter.\n+        * @param options.evaluate The "evaluate" delimiter.\n+        * @param options.import An object to import into the template as local variables.\n+        * @param options.interpolate The "interpolate" delimiter.\n+        * @param sourceURL The sourceURL of the template’s compiled source.\n+        * @param variable The data object variable name.\n+        * @return Returns the compiled Lo-Dash HTML template or a TemplateExecutor if no data is passed.\n+        **/\n+        template(\n+            text: string): TemplateExecutor;\n+\n+        /**\n+        * @see _.template\n+        **/\n+        template(\n+            text: string,\n+            data: any,\n+            options?: TemplateSettings,\n+            sourceURL?: string,\n+            variable?: string): any /* string or TemplateExecutor*/;\n+    }\n+\n+    interface TemplateExecutor {\n+        (...data: any[]): string;\n+        source: string;\n+    }\n+\n+    //_.times\n+    interface LoDashStatic {\n+        /**\n+        * Executes the callback n times, returning an array of the results of each callback execution. \n+        * The callback is bound to thisArg and invoked with one argument; (index).\n+        * @param n The number of times to execute the callback.\n+        * @param callback The function called per iteration.\n+        * @param thisArg The this binding of callback.\n+        **/\n+        times<TResult>(\n+            n: number,\n+            callback: (num: number) => TResult,\n+            context?: any): TResult[];\n+    }\n+\n+    //_.unescape\n+    interface LoDashStatic {\n+        /**\n+        * The inverse of _.escape this method converts the HTML entities &amp;, <, &gt;, &quot;, and \n+        * &#39; in string to their corresponding characters.\n+        * @param string The string to unescape.\n+        * @return The unescaped string.\n+        **/\n+        unescape(\n+            string: string): string;\n+    }\n+\n+    //_.uniqueId\n+    interface LoDashStatic {\n+        /**\n+        * Generates a unique ID. If prefix is provided the ID will be appended to it.\n+        * @param prefix The value to prefix the ID with.\n+        * @return Returns the unique ID.\n+        **/\n+        uniqueId(prefix?: string): string;\n+    }\n+    \n+    //_.noop\n+    interface LoDashStatic {\n+        /**\n+         * A no-operation function.\n+         **/\n+        noop(): void;\n+    }\n+\n+    //_.create\n+    interface LoDashStatic {\n+        /**\n+         * 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.\n+         * @param prototype The object to inherit from.\n+         * @param properties The properties to assign to the object.\n+         */\n+        create<T>(prototype: Object, properties?: Object): Object;\n+    }\n+    \n+    interface ListIterator<T, TResult> {\n+        (value: T, index: number, list: T[]): TResult;\n+    }\n+\n+    interface ObjectIterator<T, TResult> {\n+        (element: T, key: string, list: any): TResult;\n+    }\n+\n+    interface MemoVoidIterator<T, TResult> {\n+        (prev: TResult, curr: T, indexOrKey: any, list?: T[]): void;\n+    }\n+    interface MemoIterator<T, TResult> {\n+        (prev: TResult, curr: T, indexOrKey: any, list?: T[]): TResult;\n+    }\n+    /*\n+    interface MemoListIterator<T, TResult> {\n+        (prev: TResult, curr: T, index: number, list?: T[]): TResult;\n+    }\n+    interface MemoObjectIterator<T, TResult> {\n+        (prev: TResult, curr: T, index: string, object?: Dictionary<T>): TResult;\n+    }\n+    */\n+\n+    //interface Collection<T> {}\n+\n+    // Common interface between Arrays and jQuery objects\n+    interface List<T> {\n+        [index: number]: T;\n+        length: number;\n+    }\n+\n+    interface Dictionary<T> {\n+        [index: string]: T;\n+    }\n+}\n+\n+declare module "lodash" {\n+    export = _;\n+}\ndiff --git a/defs/tsd.d.ts b/defs/tsd.d.ts\nindex be9741e..e501c65 100644\n--- a/defs/tsd.d.ts\n+++ b/defs/tsd.d.ts\n@@ -1,6 +1,5 @@\n /// <reference path="node/node.d.ts" />\n /// <reference path="underscore.string/underscore.string.d.ts" />\n-/// <reference path="underscore/underscore.d.ts" />\n+/// <reference path="lodash/lodash.d.ts" />\n /// <reference path="gruntjs/gruntjs.d.ts" />\n /// <reference path="es6-promises/es6-promises.d.ts" />\n-\ndiff --git a/package.json b/package.json\nindex dee4e9c..0d64394 100644\n--- a/package.json\n+++ b/package.json\n@@ -41,6 +41,7 @@\n   "dependencies": {\n     "typescript": "1.0.1",\n     "chokidar": "0.8.2",\n+    "lodash": "2.4.1",\n     "underscore": "1.5.1",\n     "underscore.string": "2.3.3",\n     "es6-promise": "~0.1.1",\ndiff --git a/tasks-internal/modules/amdLoader.ts b/tasks-internal/modules/amdLoader.ts\nindex c979548..a9f1d10 100644\n--- a/tasks-internal/modules/amdLoader.ts\n+++ b/tasks-internal/modules/amdLoader.ts\n@@ -1,6 +1,6 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n \n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import _str = require(\'underscore.string\');\n import path = require(\'path\');\n import fs = require(\'fs\');\ndiff --git a/tasks-internal/modules/cacheUtils.ts b/tasks-internal/modules/cacheUtils.ts\nindex 66b2fb4..745dc5f 100644\n--- a/tasks-internal/modules/cacheUtils.ts\n+++ b/tasks-internal/modules/cacheUtils.ts\n@@ -3,7 +3,7 @@\n // Source based on : https://github.com/tschaub/grunt-newer/blob/master/lib/util.js\n \n import fs = require(\'fs\');\n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import path = require(\'path\');\n import crypto = require(\'crypto\');\n var grunt: IGrunt = require(\'grunt\');\ndiff --git a/tasks-internal/modules/compile.ts b/tasks-internal/modules/compile.ts\nindex 99ffaa8..5d879d2 100644\n--- a/tasks-internal/modules/compile.ts\n+++ b/tasks-internal/modules/compile.ts\n@@ -3,7 +3,7 @@\n \n import path = require(\'path\');\n import fs = require(\'fs\');\n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import utils = require(\'./utils\');\n import cache = require(\'./cacheUtils\');\n import transformers = require(\'./transformers\');\ndiff --git a/tasks-internal/modules/html2ts.ts b/tasks-internal/modules/html2ts.ts\nindex 7bd766f..9f5cbee 100644\n--- a/tasks-internal/modules/html2ts.ts\n+++ b/tasks-internal/modules/html2ts.ts\n@@ -1,6 +1,6 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n \n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import fs = require(\'fs\');\n import path = require(\'path\');\n \ndiff --git a/tasks-internal/modules/reference.ts b/tasks-internal/modules/reference.ts\nindex 3d6bef9..650cef8 100644\n--- a/tasks-internal/modules/reference.ts\n+++ b/tasks-internal/modules/reference.ts\n@@ -1,6 +1,6 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n \n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import _str = require(\'underscore.string\');\n import fs = require(\'fs\');\n import grunt = require(\'grunt\');\ndiff --git a/tasks-internal/modules/templateCache.ts b/tasks-internal/modules/templateCache.ts\nindex 530a576..f79a8c4 100644\n--- a/tasks-internal/modules/templateCache.ts\n+++ b/tasks-internal/modules/templateCache.ts\n@@ -1,6 +1,6 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n \n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import fs = require(\'fs\');\n import path = require(\'path\');\n import os = require(\'os\');\ndiff --git a/tasks-internal/modules/transformers.ts b/tasks-internal/modules/transformers.ts\nindex 0dbbfcd..027d52f 100644\n--- a/tasks-internal/modules/transformers.ts\n+++ b/tasks-internal/modules/transformers.ts\n@@ -5,7 +5,7 @@ import fs = require(\'fs\');\n import path = require(\'path\');\n import grunt = require(\'grunt\');\n import _str = require(\'underscore.string\');\n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import os = require(\'os\');\n import utils = require(\'./utils\');\n \ndiff --git a/tasks-internal/ts-internal.js b/tasks-internal/ts-internal.js\nindex dc5c8f6..329fd59 100644\n--- a/tasks-internal/ts-internal.js\n+++ b/tasks-internal/ts-internal.js\n@@ -6,7 +6,7 @@\n * Licensed under the MIT license.\n */\n // Typescript imports\n-var _ = require(\'underscore\');\n+var _ = require(\'lodash\');\n var path = require(\'path\');\n var fs = require(\'fs\');\n \ndiff --git a/tasks-internal/ts.ts b/tasks-internal/ts.ts\nindex 237b829..bcdec35 100644\n--- a/tasks-internal/ts.ts\n+++ b/tasks-internal/ts.ts\n@@ -7,7 +7,7 @@\n  */\n \n // Typescript imports\n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import path = require(\'path\');\n import fs = require(\'fs\');\n \ndiff --git a/tasks/modules/amdLoader.js b/tasks/modules/amdLoader.js\nindex 832ae4e..34285dd 100644\n--- a/tasks/modules/amdLoader.js\n+++ b/tasks/modules/amdLoader.js\n@@ -1,5 +1,5 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n-var _ = require(\'underscore\');\n+var _ = require(\'lodash\');\n var _str = require(\'underscore.string\');\n var path = require(\'path\');\n var fs = require(\'fs\');\ndiff --git a/tasks/modules/amdLoader.ts b/tasks/modules/amdLoader.ts\nindex c979548..a9f1d10 100644\n--- a/tasks/modules/amdLoader.ts\n+++ b/tasks/modules/amdLoader.ts\n@@ -1,6 +1,6 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n \n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import _str = require(\'underscore.string\');\n import path = require(\'path\');\n import fs = require(\'fs\');\ndiff --git a/tasks/modules/cacheUtils.js b/tasks/modules/cacheUtils.js\nindex 28d4298..366ef1d 100644\n--- a/tasks/modules/cacheUtils.js\n+++ b/tasks/modules/cacheUtils.js\n@@ -1,7 +1,7 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n // Source based on : https://github.com/tschaub/grunt-newer/blob/master/lib/util.js\n var fs = require(\'fs\');\n-var _ = require(\'underscore\');\n+var _ = require(\'lodash\');\n var path = require(\'path\');\n var crypto = require(\'crypto\');\n var grunt = require(\'grunt\');\ndiff --git a/tasks/modules/cacheUtils.ts b/tasks/modules/cacheUtils.ts\nindex 66b2fb4..745dc5f 100644\n--- a/tasks/modules/cacheUtils.ts\n+++ b/tasks/modules/cacheUtils.ts\n@@ -3,7 +3,7 @@\n // Source based on : https://github.com/tschaub/grunt-newer/blob/master/lib/util.js\n \n import fs = require(\'fs\');\n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import path = require(\'path\');\n import crypto = require(\'crypto\');\n var grunt: IGrunt = require(\'grunt\');\ndiff --git a/tasks/modules/compile.js b/tasks/modules/compile.js\nindex 92b7e41..e64dd88 100644\n--- a/tasks/modules/compile.js\n+++ b/tasks/modules/compile.js\n@@ -2,7 +2,7 @@\n /// <reference path="./interfaces.d.ts"/>\n var path = require(\'path\');\n var fs = require(\'fs\');\n-var _ = require(\'underscore\');\n+var _ = require(\'lodash\');\n var utils = require(\'./utils\');\n var cache = require(\'./cacheUtils\');\n \ndiff --git a/tasks/modules/compile.ts b/tasks/modules/compile.ts\nindex 16df2dc..11a92b3 100644\n--- a/tasks/modules/compile.ts\n+++ b/tasks/modules/compile.ts\n@@ -3,7 +3,7 @@\n \n import path = require(\'path\');\n import fs = require(\'fs\');\n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import utils = require(\'./utils\');\n import cache = require(\'./cacheUtils\');\n \ndiff --git a/tasks/modules/html2ts.js b/tasks/modules/html2ts.js\nindex 58c5efe..d732af4 100644\n--- a/tasks/modules/html2ts.js\n+++ b/tasks/modules/html2ts.js\n@@ -1,5 +1,5 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n-var _ = require(\'underscore\');\n+var _ = require(\'lodash\');\n var fs = require(\'fs\');\n var path = require(\'path\');\n \ndiff --git a/tasks/modules/html2ts.ts b/tasks/modules/html2ts.ts\nindex 7bd766f..9f5cbee 100644\n--- a/tasks/modules/html2ts.ts\n+++ b/tasks/modules/html2ts.ts\n@@ -1,6 +1,6 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n \n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import fs = require(\'fs\');\n import path = require(\'path\');\n \ndiff --git a/tasks/modules/reference.js b/tasks/modules/reference.js\nindex acef934..102d9b9 100644\n--- a/tasks/modules/reference.js\n+++ b/tasks/modules/reference.js\n@@ -1,5 +1,5 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n-var _ = require(\'underscore\');\n+var _ = require(\'lodash\');\n var _str = require(\'underscore.string\');\n var fs = require(\'fs\');\n var grunt = require(\'grunt\');\ndiff --git a/tasks/modules/reference.ts b/tasks/modules/reference.ts\nindex 3d6bef9..650cef8 100644\n--- a/tasks/modules/reference.ts\n+++ b/tasks/modules/reference.ts\n@@ -1,6 +1,6 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n \n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import _str = require(\'underscore.string\');\n import fs = require(\'fs\');\n import grunt = require(\'grunt\');\ndiff --git a/tasks/modules/templateCache.js b/tasks/modules/templateCache.js\nindex 1bfccc9..120ec54 100644\n--- a/tasks/modules/templateCache.js\n+++ b/tasks/modules/templateCache.js\n@@ -1,5 +1,5 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n-var _ = require(\'underscore\');\n+var _ = require(\'lodash\');\n var fs = require(\'fs\');\n var path = require(\'path\');\n var os = require(\'os\');\ndiff --git a/tasks/modules/templateCache.ts b/tasks/modules/templateCache.ts\nindex 530a576..f79a8c4 100644\n--- a/tasks/modules/templateCache.ts\n+++ b/tasks/modules/templateCache.ts\n@@ -1,6 +1,6 @@\n /// <reference path="../../defs/tsd.d.ts"/>\n \n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import fs = require(\'fs\');\n import path = require(\'path\');\n import os = require(\'os\');\ndiff --git a/tasks/modules/transformers.js b/tasks/modules/transformers.js\nindex 42898ff..66b5b45 100644\n--- a/tasks/modules/transformers.js\n+++ b/tasks/modules/transformers.js\n@@ -10,7 +10,7 @@ var fs = require(\'fs\');\n var path = require(\'path\');\n var grunt = require(\'grunt\');\n var _str = require(\'underscore.string\');\n-var _ = require(\'underscore\');\n+var _ = require(\'lodash\');\n var os = require(\'os\');\n var utils = require(\'./utils\');\n \ndiff --git a/tasks/modules/transformers.ts b/tasks/modules/transformers.ts\nindex 3082357..bd974dc 100644\n--- a/tasks/modules/transformers.ts\n+++ b/tasks/modules/transformers.ts\n@@ -5,7 +5,7 @@ import fs = require(\'fs\');\n import path = require(\'path\');\n import grunt = require(\'grunt\');\n import _str = require(\'underscore.string\');\n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import os = require(\'os\');\n import utils = require(\'./utils\');\n \ndiff --git a/tasks/ts.js b/tasks/ts.js\nindex fc61e6e..36d5993 100644\n--- a/tasks/ts.js\n+++ b/tasks/ts.js\n@@ -5,7 +5,7 @@\n * Licensed under the MIT license.\n */\n // Typescript imports\n-var _ = require(\'underscore\');\n+var _ = require(\'lodash\');\n var path = require(\'path\');\n var fs = require(\'fs\');\n \ndiff --git a/tasks/ts.ts b/tasks/ts.ts\nindex 4ec50cd..c5dbe0f 100644\n--- a/tasks/ts.ts\n+++ b/tasks/ts.ts\n@@ -7,7 +7,7 @@\n  */\n \n // Typescript imports\n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n import path = require(\'path\');\n import fs = require(\'fs\');\n \ndiff --git a/test/test.js b/test/test.js\nindex 8e2f469..f9193c8 100644\n--- a/test/test.js\n+++ b/test/test.js\n@@ -2,7 +2,7 @@\n var grunt = require(\'grunt\');\n \n var utils = require(\'../tasks/modules/utils\');\n-var _ = require(\'underscore\');\n+var _ = require(\'lodash\');\n \n function testFile(test, path) {\n     var actual = grunt.file.read(\'test/\' + path);\ndiff --git a/test/test.ts b/test/test.ts\nindex 96524f1..9d18090 100644\n--- a/test/test.ts\n+++ b/test/test.ts\n@@ -4,7 +4,7 @@ var grunt: IGrunt = require(\'grunt\');\n import fs = require(\'fs\');\n import path = require(\'path\');\n import utils = require(\'../tasks/modules/utils\');\n-import _ = require(\'underscore\');\n+import _ = require(\'lodash\');\n \n function testFile(test, path) {\n     var actual = grunt.file.read(\'test/\' + path);\n', 'commit_subject': 'Switch to Lo-Dash from Underscore', 'repo_name': 'TypeStrong/grunt-ts', 'committer': {'name': 'Panu Horsmalahti', 'email': 'ecd792dda0162de21b231b8d40ef3308bb91601a@iki.fi', 'time_sec': '1413222307', 'tz_offset': '180', 'date': {'seconds': '1413222307'}}, 'commit_tree': '073eedae515b0e10ab714bb1e52a9a5d12e9766d', 'commit_message': 'Switch to Lo-Dash from Underscore\n', 'language_name': 'HTML', 'license': 'mit', 'hunks': "@@ -4,7 +4,7 @@ var grunt: IGrunt = require('grunt');\n import fs = require('fs');\n import path = require('path');\n import utils = require('../tasks/modules/utils');\n-import _ = require('underscore');\n+import _ = require('lodash');\n \n function testFile(test, path) {\n     var actual = grunt.file.read('test/' + path);\n", 'addition_count': 1, 'deletion_count': 1, 'src_file': 'a/test/test.ts', 'tgt_file': 'b/test/test.ts', 'file_extension': '.ts', 'before_file': '/// <reference path="../defs/tsd.d.ts" />\n\nvar grunt: IGrunt = require(\'grunt\');\nimport fs = require(\'fs\');\nimport path = require(\'path\');\nimport utils = require(\'../tasks/modules/utils\');\nimport _ = require(\'underscore\');\n\nfunction testFile(test, path) {\n    var actual = grunt.file.read(\'test/\' + path);\n} from \'./testHelpers\';\n\nexport var tests : nodeunit.ITestGroup = {\n    setUp: (callback) => {\n       callback();\n    },\n\t  tearDown: (callback) => {\n       callback();\n    },\n    simple: function (test) {\n        testFile(test, \'simple/js/zoo.js\', true);\n        testFile(test, \'simple/js/zoo.d.ts\');\n        test.done();\n    },\n    simple_with_rootDir: function (test) {\n        testDirectory(test, \'simple_with_rootDir\');\n        test.done();\n    },\n    abtest: function (test) {\n        testFile(test, \'abtest/reference.ts\');\n        testFile(test, \'abtest/out.js\', true);\n        test.done();\n    },\n    allowJs: function (test) {\n        testDirectory(test, \'allowJs\');\n        test.done();\n    },\n    amdloader: function (test) {\n        testDirectory(test, \'amdloader\');\n        test.done();\n    },\n    templateCache: function (test) {\n        testDirectory(test, \'templateCache\');\n        test.done();\n    },\n    html2ts: function (test) {\n        testDirectory(test, \'html\');\n        testDirectory(test, \'htmlTemplate\');\n        testDirectory(test, \'htmlSnakeModuleName\');\n        test.done();\n    },\n    index: function (test) {\n        testDirectory(test, \'index\');\n        test.done();\n    },\n    transform: function (test) {\n        testDirectory(test, \'transform\', true);\n        test.done();\n    },\n    referencesTransform: function (test) {\n        testDirectory(test, \'references-transform\');\n        test.done();\n    },\n    customcompiler: function (test) {\n        testDirectory(test, \'customcompiler\');\n        test.done();\n    },\n    fail: function (test) {\n        testDirectory(test, \'fail\'); // tested to make sure transformers still run for failing task\n        test.done();\n    },\n    es6: function (test) {\n        testDirectory(test, \'es6\');\n        test.done();\n    },\n    noEmitOnError: function (test) {\n        testDirectory(test, \'noEmitOnError\');\n        assertFileDoesNotExist(test, \'test/noEmitOnError/testNoEmitOnError_true.js\');\n        test.done();\n    },\n    preserveConstEnums: function (test) {\n        testDirectory(test, \'preserveConstEnums\');\n        test.done();\n    },\n    suppressImplicitAnyIndexErrors: function (test) {\n        testDirectory(test, \'suppressImplicitAnyIndexErrors\');\n        assertFileDoesNotExist(test, \'test/suppressImplicitAnyIndexErrors/test_suppressImplicitAnyIndexError_false.js\');\n        test.done();\n    },\n    varReplacedTest: function (test) {\n        testDirectory(test, \'varreplacedtest\');\n        test.done();\n    },\n    vsproj_test_ignoreSettings: function (test) {\n        testDirectory(test, \'vsproj/ignoreSettings\');\n        test.done();\n    },\n    files_ObjectFormat: function (test) {\n        testDirectory(test, \'files_ObjectFormat\', true);\n        test.done();\n    },\n    out_and_outdir_with_spaces: function (test) {\n        testDirectory(test, \'out with spaces\');\n        test.done();\n    },\n    htmlExternal: function (test) {\n        testDirectory(test, \'htmlExternal\');\n        test.done();\n    },\n    nestedSources: function (test) {\n        testDirectory(test, \'nestedSources\');\n        test.done();\n    }\n}\n', 'message': 'Switch to Lo-Dash from Underscore\n', 'author_name': 'Panu Horsmalahti', 'lang': 'ts'}