aboutsummaryrefslogtreecommitdiffstats
path: root/catalog-ui/typings/lodash
diff options
context:
space:
mode:
Diffstat (limited to 'catalog-ui/typings/lodash')
-rw-r--r--catalog-ui/typings/lodash/lodash.d.ts22949
1 files changed, 22949 insertions, 0 deletions
diff --git a/catalog-ui/typings/lodash/lodash.d.ts b/catalog-ui/typings/lodash/lodash.d.ts
new file mode 100644
index 0000000000..9d23982103
--- /dev/null
+++ b/catalog-ui/typings/lodash/lodash.d.ts
@@ -0,0 +1,22949 @@
+// Type definitions for Lo-Dash 4.14
+// Project: http://lodash.com/
+// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+/**
+ ### 4.0.0 Changelog (https://github.com/lodash/lodash/wiki/Changelog)
+
+ #### TODO:
+ removed:
+ - [x] Removed _.support
+ - [x] Removed _.findWhere in favor of _.find with iteratee shorthand
+ - [x] Removed _.where in favor of _.filter with iteratee shorthand
+ - [x] Removed _.pluck in favor of _.map with iteratee shorthand
+
+ renamed:
+ - [x] Renamed _.first to _.head
+ - [x] Renamed _.indexBy to _.keyBy
+ - [x] Renamed _.invoke to _.invokeMap
+ - [x] Renamed _.overArgs to _.overArgs
+ - [x] Renamed _.padLeft & _.padRight to _.padStart & _.padEnd
+ - [x] Renamed _.pairs to _.toPairs
+ - [x] Renamed _.rest to _.tail
+ - [x] Renamed _.restParam to _.rest
+ - [x] Renamed _.sortByOrder to _.orderBy
+ - [x] Renamed _.trimLeft & _.trimRight to _.trimStart & _.trimEnd
+ - [x] Renamed _.trunc to _.truncate
+
+ split:
+ - [x] Split _.indexOf & _.lastIndexOf into _.sortedIndexOf & _.sortedLastIndexOf
+ - [x] Split _.max & _.min into _.maxBy & _.minBy
+ - [x] Split _.omit & _.pick into _.omitBy & _.pickBy
+ - [x] Split _.sample into _.sampleSize
+ - [x] Split _.sortedIndex into _.sortedIndexBy
+ - [x] Split _.sortedLastIndex into _.sortedLastIndexBy
+ - [x] Split _.uniq into _.sortedUniq, _.sortedUniqBy, & _.uniqBy
+
+ changes:
+ - [x] Absorbed _.sortByAll into _.sortBy
+ - [x] Changed the category of _.at to “Object”
+ - [x] Changed the category of _.bindAll to “Utility”
+ - [x] Made _.capitalize uppercase the first character & lowercase the rest
+ - [x] Made _.functions return only own method names
+
+
+ added 23 array methods:
+ - [x] _.concat
+ - [x] _.differenceBy
+ - [x] _.differenceWith
+ - [x] _.flatMap
+ - [x] _.fromPairs
+ - [x] _.intersectionBy
+ - [x] _.intersectionWith
+ - [x] _.join
+ - [x] _.pullAll
+ - [x] _.pullAllBy
+ - [x] _.reverse
+ - [x] _.sortedIndexBy
+ - [x] _.sortedIndexOf
+ - [x] _.sortedLastIndexBy
+ - [x] _.sortedLastIndexOf
+ - [x] _.sortedUniq
+ - [x] _.sortedUniqBy
+ - [x] _.unionBy
+ - [x] _.unionWith
+ - [x] _.uniqBy
+ - [x] _.uniqWith
+ - [x] _.xorBy
+ - [x] _.xorWith
+
+ added 18 lang methods:
+ - [x] _.cloneDeepWith
+ - [x] _.cloneWith
+ - [x] _.eq
+ - [x] _.isArrayLike
+ - [x] _.isArrayLikeObject
+ - [x] _.isEqualWith
+ - [x] _.isInteger
+ - [x] _.isLength
+ - [x] _.isMatchWith
+ - [x] _.isNil
+ - [x] _.isObjectLike
+ - [x] _.isSafeInteger
+ - [x] _.isSymbol
+ - [x] _.toInteger
+ - [x] _.toLength
+ - [x] _.toNumber
+ - [x] _.toSafeInteger
+ - [x] _.toString
+
+ added 13 object methods:
+ - [x] _.assignIn
+ - [x] _.assignInWith
+ - [x] _.assignWith
+ - [x] _.functionsIn
+ - [x] _.hasIn
+ - [x] _.mergeWith
+ - [x] _.omitBy
+ - [x] _.pickBy
+
+
+ added 8 string methods:
+ - [x] _.lowerCase
+ - [x] _.lowerFirst
+ - [x] _.upperCase
+ - [x] _.upperFirst
+ - [x] _.toLower
+ - [x] _.toUpper
+
+ added 8 utility methods:
+ - [x] _.toPath
+
+ added 4 math methods:
+ - [x] _.maxBy
+ - [x] _.mean
+ - [x] _.minBy
+ - [x] _.sumBy
+
+ added 2 function methods:
+ - [x] _.flip
+ - [x] _.unary
+
+ added 2 number methods:
+ - [x] _.clamp
+ - [x] _.subtract
+
+ added collection method:
+ - [x] _.sampleSize
+
+ Added 3 aliases
+
+ - [x] _.first as an alias of _.head
+
+ Removed 17 aliases
+ - [x] Removed aliase _.all
+ - [x] Removed aliase _.any
+ - [x] Removed aliase _.backflow
+ - [x] Removed aliase _.callback
+ - [x] Removed aliase _.collect
+ - [x] Removed aliase _.compose
+ - [x] Removed aliase _.contains
+ - [x] Removed aliase _.detect
+ - [x] Removed aliase _.foldl
+ - [x] Removed aliase _.foldr
+ - [x] Removed aliase _.include
+ - [x] Removed aliase _.inject
+ - [x] Removed aliase _.methods
+ - [x] Removed aliase _.object
+ - [x] Removed aliase _.run
+ - [x] Removed aliase _.select
+ - [x] Removed aliase _.unique
+
+ Other changes
+ - [x] Added support for array buffers to _.isEqual
+ - [x] Added support for converting iterators to _.toArray
+ - [x] Added support for deep paths to _.zipObject
+ - [x] Changed UMD to export to window or self when available regardless of other exports
+ - [x] Ensured debounce cancel clears args & thisArg references
+ - [x] Ensured _.add, _.subtract, & _.sum don’t skip NaN values
+ - [x] Ensured _.clone treats generators like functions
+ - [x] Ensured _.clone produces clones with the source’s [[Prototype]]
+ - [x] Ensured _.defaults assigns properties that shadow Object.prototype
+ - [x] Ensured _.defaultsDeep doesn’t merge a string into an array
+ - [x] Ensured _.defaultsDeep & _.merge don’t modify sources
+ - [x] Ensured _.defaultsDeep works with circular references
+ - [x] Ensured _.keys skips “length” on strict mode arguments objects in Safari 9
+ - [x] Ensured _.merge doesn’t convert strings to arrays
+ - [x] Ensured _.merge merges plain-objects onto non plain-objects
+ - [x] Ensured _#plant resets iterator data of cloned sequences
+ - [x] Ensured _.random swaps min & max if min is greater than max
+ - [x] Ensured _.range preserves the sign of start of -0
+ - [x] Ensured _.reduce & _.reduceRight use getIteratee in their array branch
+ - [x] Fixed rounding issue with the precision param of _.floor
+ - [x] Added flush method to debounced & throttled functions
+
+ ** LATER **
+ Misc:
+ - [ ] Made _.forEach, _.forIn, _.forOwn, & _.times implicitly end a chain sequence
+ - [ ] Removed thisArg params from most methods
+ - [ ] Made “By” methods provide a single param to iteratees
+ - [ ] Made _.words chainable by default
+ - [ ] Removed isDeep params from _.clone & _.flatten
+ - [ ] Removed _.bindAll support for binding all methods when no names are provided
+ - [ ] Removed func-first param signature from _.before & _.after
+ - [ ] _.extend as an alias of _.assignIn
+ - [ ] _.extendWith as an alias of _.assignInWith
+ - [ ] Added clear method to _.memoize.Cache
+ - [ ] Added support for ES6 maps, sets, & symbols to _.clone, _.isEqual, & _.toArray
+ - [ ] Enabled _.flow & _.flowRight to accept an array of functions
+ - [ ] Ensured “Collection” methods treat functions as objects
+ - [ ] Ensured _.assign, _.defaults, & _.merge coerce object values to objects
+ - [ ] Ensured _.bindKey bound functions call object[key] when called with the new operator
+ - [ ] Ensured _.isFunction returns true for generator functions
+ - [ ] Ensured _.merge assigns typed arrays directly
+ - [ ] Made _(...) an iterator & iterable
+ - [ ] Made _.drop, _.take, & right forms coerce n of undefined to 0
+
+ Methods:
+ - [ ] _.concat
+ - [ ] _.differenceBy
+ - [ ] _.differenceWith
+ - [ ] _.flatMap
+ - [ ] _.fromPairs
+ - [ ] _.intersectionBy
+ - [ ] _.intersectionWith
+ - [ ] _.join
+ - [ ] _.pullAll
+ - [ ] _.pullAllBy
+ - [ ] _.reverse
+ - [ ] _.sortedLastIndexOf
+ - [ ] _.unionBy
+ - [ ] _.unionWith
+ - [ ] _.uniqWith
+ - [ ] _.xorBy
+ - [ ] _.xorWith
+ - [ ] _.toString
+
+ - [ ] _.invoke
+ - [ ] _.setWith
+ - [ ] _.toPairs
+ - [ ] _.toPairsIn
+ - [ ] _.unset
+
+ - [ ] _.replace
+ - [ ] _.split
+
+ - [ ] _.cond
+ - [ ] _.conforms
+ - [ ] _.nthArg
+ - [ ] _.over
+ - [ ] _.overEvery
+ - [ ] _.overSome
+ - [ ] _.rangeRight
+
+ - [ ] _.next
+ */
+
+declare var _: _.LoDashStatic;
+
+declare module _ {
+ interface LoDashStatic {
+ /**
+ * Creates a lodash object which wraps the given value to enable intuitive method chaining.
+ *
+ * In addition to Lo-Dash methods, wrappers also have the following Array methods:
+ * concat, join, pop, push, reverse, shift, slice, sort, splice, and unshift
+ *
+ * Chaining is supported in custom builds as long as the value method is implicitly or
+ * explicitly included in the build.
+ *
+ * The chainable wrapper functions are:
+ * after, assign, bind, bindAll, bindKey, chain, chunk, compact, compose, concat, countBy,
+ * createCallback, curry, debounce, defaults, defer, delay, difference, filter, flatten,
+ * forEach, forEachRight, forIn, forInRight, forOwn, forOwnRight, functions, groupBy,
+ * keyBy, initial, intersection, invert, invoke, keys, map, max, memoize, merge, min,
+ * object, omit, once, pairs, partial, partialRight, pick, pluck, pull, push, range, reject,
+ * remove, rest, reverse, sample, shuffle, slice, sort, sortBy, splice, tap, throttle, times,
+ * toArray, transform, union, uniq, unset, unshift, unzip, values, where, without, wrap, and zip
+ *
+ * The non-chainable wrapper functions are:
+ * clone, cloneDeep, contains, escape, every, find, findIndex, findKey, findLast,
+ * findLastIndex, findLastKey, has, identity, indexOf, isArguments, isArray, isBoolean,
+ * isDate, isElement, isEmpty, isEqual, isFinite, isFunction, isNaN, isNull, isNumber,
+ * isObject, isPlainObject, isRegExp, isString, isUndefined, join, lastIndexOf, mixin,
+ * noConflict, parseInt, pop, random, reduce, reduceRight, result, shift, size, some,
+ * sortedIndex, runInContext, template, unescape, uniqueId, and value
+ *
+ * The wrapper functions first and last return wrapped values when n is provided, otherwise
+ * they return unwrapped values.
+ *
+ * Explicit chaining can be enabled by using the _.chain method.
+ **/
+ (value: number): LoDashImplicitWrapper<number>;
+ (value: string): LoDashImplicitStringWrapper;
+ (value: boolean): LoDashImplicitWrapper<boolean>;
+ (value: Array<number>): LoDashImplicitNumberArrayWrapper;
+ <T>(value: Array<T>): LoDashImplicitArrayWrapper<T>;
+ <T extends {}>(value: T): LoDashImplicitObjectWrapper<T>;
+ (value: any): LoDashImplicitWrapper<any>;
+
+ /**
+ * The semantic version number.
+ **/
+ VERSION: string;
+
+ /**
+ * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby
+ * (ERB). Change the following template settings to use alternative delimiters.
+ **/
+ templateSettings: TemplateSettings;
+ }
+
+ /**
+ * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby
+ * (ERB). Change the following template settings to use alternative delimiters.
+ **/
+ interface TemplateSettings {
+ /**
+ * The "escape" delimiter.
+ **/
+ escape?: RegExp;
+
+ /**
+ * The "evaluate" delimiter.
+ **/
+ evaluate?: RegExp;
+
+ /**
+ * An object to import into the template as local variables.
+ **/
+ imports?: Dictionary<any>;
+
+ /**
+ * The "interpolate" delimiter.
+ **/
+ interpolate?: RegExp;
+
+ /**
+ * Used to reference the data object in the template text.
+ **/
+ variable?: string;
+ }
+
+ /**
+ * Creates a cache object to store key/value pairs.
+ */
+ interface MapCache {
+ /**
+ * Removes `key` and its value from the cache.
+ * @param key The key of the value to remove.
+ * @return Returns `true` if the entry was removed successfully, else `false`.
+ */
+ delete(key: string): boolean;
+
+ /**
+ * Gets the cached value for `key`.
+ * @param key The key of the value to get.
+ * @return Returns the cached value.
+ */
+ get(key: string): any;
+
+ /**
+ * Checks if a cached value for `key` exists.
+ * @param key The key of the entry to check.
+ * @return Returns `true` if an entry for `key` exists, else `false`.
+ */
+ has(key: string): boolean;
+
+ /**
+ * Sets `value` to `key` of the cache.
+ * @param key The key of the value to cache.
+ * @param value The value to cache.
+ * @return Returns the cache object.
+ */
+ set(key: string, value: any): _.Dictionary<any>;
+ }
+ interface MapCacheConstructor {
+ new (): MapCache;
+ }
+
+ interface LoDashWrapperBase<T, TWrapper> { }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> extends LoDashWrapperBase<T, TWrapper> { }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> extends LoDashWrapperBase<T, TWrapper> { }
+
+ interface LoDashImplicitWrapper<T> extends LoDashImplicitWrapperBase<T, LoDashImplicitWrapper<T>> { }
+
+ interface LoDashExplicitWrapper<T> extends LoDashExplicitWrapperBase<T, LoDashExplicitWrapper<T>> { }
+
+ interface LoDashImplicitStringWrapper extends LoDashImplicitWrapper<string> { }
+
+ interface LoDashExplicitStringWrapper extends LoDashExplicitWrapper<string> { }
+
+ interface LoDashImplicitObjectWrapper<T> extends LoDashImplicitWrapperBase<T, LoDashImplicitObjectWrapper<T>> { }
+
+ interface LoDashExplicitObjectWrapper<T> extends LoDashExplicitWrapperBase<T, LoDashExplicitObjectWrapper<T>> { }
+
+ interface LoDashImplicitArrayWrapper<T> extends LoDashImplicitWrapperBase<T[], LoDashImplicitArrayWrapper<T>> {
+ pop(): T;
+ push(...items: T[]): LoDashImplicitArrayWrapper<T>;
+ shift(): T;
+ sort(compareFn?: (a: T, b: T) => number): LoDashImplicitArrayWrapper<T>;
+ splice(start: number): LoDashImplicitArrayWrapper<T>;
+ splice(start: number, deleteCount: number, ...items: any[]): LoDashImplicitArrayWrapper<T>;
+ unshift(...items: T[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> extends LoDashExplicitWrapperBase<T[], LoDashExplicitArrayWrapper<T>> {
+ pop(): LoDashExplicitObjectWrapper<T>;
+ push(...items: T[]): LoDashExplicitArrayWrapper<T>;
+ shift(): LoDashExplicitObjectWrapper<T>;
+ sort(compareFn?: (a: T, b: T) => number): LoDashExplicitArrayWrapper<T>;
+ splice(start: number): LoDashExplicitArrayWrapper<T>;
+ splice(start: number, deleteCount: number, ...items: any[]): LoDashExplicitArrayWrapper<T>;
+ unshift(...items: T[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitNumberArrayWrapper extends LoDashImplicitArrayWrapper<number> { }
+
+ interface LoDashExplicitNumberArrayWrapper extends LoDashExplicitArrayWrapper<number> { }
+
+ /*********
+ * Array *
+ *********/
+
+ //_.chunk
+ interface LoDashStatic {
+ /**
+ * Creates an array of elements split into groups the length of size. If collection can’t be split evenly, the
+ * final chunk will be the remaining elements.
+ *
+ * @param array The array to process.
+ * @param size The length of each chunk.
+ * @return Returns the new array containing chunks.
+ */
+ chunk<T>(
+ array: List<T>,
+ size?: number
+ ): T[][];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.chunk
+ */
+ chunk(size?: number): LoDashImplicitArrayWrapper<T[]>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.chunk
+ */
+ chunk<TResult>(size?: number): LoDashImplicitArrayWrapper<TResult[]>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.chunk
+ */
+ chunk(size?: number): LoDashExplicitArrayWrapper<T[]>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.chunk
+ */
+ chunk<TResult>(size?: number): LoDashExplicitArrayWrapper<TResult[]>;
+ }
+
+ //_.compact
+ interface LoDashStatic {
+ /**
+ * Creates an array with all falsey values removed. The values false, null, 0, "", undefined, and NaN are
+ * falsey.
+ *
+ * @param array The array to compact.
+ * @return (Array) Returns the new array of filtered values.
+ */
+ compact<T>(array?: List<T>): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.compact
+ */
+ compact(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.compact
+ */
+ compact<TResult>(): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.compact
+ */
+ compact(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.compact
+ */
+ compact<TResult>(): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ //_.concat DUMMY
+ interface LoDashStatic {
+ /**
+ * Creates a new array concatenating `array` with any additional arrays
+ * and/or values.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to concatenate.
+ * @param {...*} [values] The values to concatenate.
+ * @returns {Array} Returns the new concatenated array.
+ * @example
+ *
+ * var array = [1];
+ * var other = _.concat(array, 2, [3], [[4]]);
+ *
+ * console.log(other);
+ * // => [1, 2, 3, [4]]
+ *
+ * console.log(array);
+ * // => [1]
+ */
+ concat<T>(array: T[]|List<T>, ...values: (T|T[]|List<T>)[]) : T[];
+ }
+
+ //_.difference
+ interface LoDashStatic {
+ /**
+ * Creates an array of unique array values not included in the other provided arrays using SameValueZero for
+ * equality comparisons.
+ *
+ * @param array The array to inspect.
+ * @param values The arrays of values to exclude.
+ * @return Returns the new array of filtered values.
+ */
+ difference<T>(
+ array: T[]|List<T>,
+ ...values: Array<T[]|List<T>>
+ ): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.difference
+ */
+ difference(...values: (T[]|List<T>)[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.difference
+ */
+ difference<TValue>(...values: (TValue[]|List<TValue>)[]): LoDashImplicitArrayWrapper<TValue>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.difference
+ */
+ difference(...values: (T[]|List<T>)[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.difference
+ */
+ difference<TValue>(...values: (TValue[]|List<TValue>)[]): LoDashExplicitArrayWrapper<TValue>;
+ }
+
+ //_.differenceBy
+ interface LoDashStatic {
+ /**
+ * This method is like _.difference except that it accepts iteratee which is invoked for each element of array
+ * and values to generate the criterion by which uniqueness is computed. The iteratee is invoked with one
+ * argument: (value).
+ *
+ * @param array The array to inspect.
+ * @param values The values to exclude.
+ * @param iteratee The iteratee invoked per element.
+ * @returns Returns the new array of filtered values.
+ */
+ differenceBy<T>(
+ array: T[]|List<T>,
+ values?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): T[];
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ array: T[]|List<T>,
+ values?: T[]|List<T>,
+ iteratee?: W
+ ): T[];
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ array: T[]|List<T>,
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): T[];
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ array: T[]|List<T>,
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ iteratee?: W
+ ): T[];
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ array: T[]|List<T>,
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): T[];
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ array: T[]|List<T>,
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ iteratee?: W
+ ): T[];
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ array: T[]|List<T>,
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ iteratee?: W
+ ): T[];
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ array: T[]|List<T>,
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): T[];
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ array: T[]|List<T>,
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ values5?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): T[];
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ array: T[]|List<T>,
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ values5?: T[]|List<T>,
+ iteratee?: W
+ ): T[];
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ array: T[]|List<T>,
+ ...values: any[]
+ ): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ values5?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ values5?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ ...values: any[]
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ values5?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ values5?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ ...values: any[]
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ values5?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ values5?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ ...values: any[]
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ values5?: T[]|List<T>,
+ iteratee?: ((value: T) => any)|string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T, W extends Object>(
+ values1?: T[]|List<T>,
+ values2?: T[]|List<T>,
+ values3?: T[]|List<T>,
+ values4?: T[]|List<T>,
+ values5?: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.differenceBy
+ */
+ differenceBy<T>(
+ ...values: any[]
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.differenceWith DUMMY
+ interface LoDashStatic {
+ /**
+ * Creates an array of unique `array` values not included in the other
+ * provided arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {...Array} [values] The values to exclude.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * _.difference([3, 2, 1], [4, 2]);
+ * // => [3, 1]
+ */
+ differenceWith(
+ array: any[]|List<any>,
+ ...values: any[]
+ ): any[];
+ }
+
+ //_.drop
+ interface LoDashStatic {
+ /**
+ * Creates a slice of array with n elements dropped from the beginning.
+ *
+ * @param array The array to query.
+ * @param n The number of elements to drop.
+ * @return Returns the slice of array.
+ */
+ drop<T>(array: T[]|List<T>, n?: number): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.drop
+ */
+ drop(n?: number): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.drop
+ */
+ drop<T>(n?: number): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.drop
+ */
+ drop(n?: number): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.drop
+ */
+ drop<T>(n?: number): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.dropRight
+ interface LoDashStatic {
+ /**
+ * Creates a slice of array with n elements dropped from the end.
+ *
+ * @param array The array to query.
+ * @param n The number of elements to drop.
+ * @return Returns the slice of array.
+ */
+ dropRight<T>(
+ array: List<T>,
+ n?: number
+ ): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.dropRight
+ */
+ dropRight(n?: number): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.dropRight
+ */
+ dropRight<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.dropRight
+ */
+ dropRight(n?: number): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.dropRight
+ */
+ dropRight<TResult>(n?: number): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ //_.dropRightWhile
+ interface LoDashStatic {
+ /**
+ * Creates a slice of array excluding elements dropped from the end. Elements are dropped until predicate
+ * returns falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array).
+ *
+ * If a property name is provided for predicate the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for predicate the created _.matches style callback returns true for elements that
+ * match the properties of the given object, else false.
+ *
+ * @param array The array to query.
+ * @param predicate The function invoked per iteration.
+ * @param thisArg The this binding of predicate.
+ * @return Returns the slice of array.
+ */
+ dropRightWhile<TValue>(
+ array: List<TValue>,
+ predicate?: ListIterator<TValue, boolean>
+ ): TValue[];
+
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile<TValue>(
+ array: List<TValue>,
+ predicate?: string
+ ): TValue[];
+
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile<TWhere, TValue>(
+ array: List<TValue>,
+ predicate?: TWhere
+ ): TValue[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile(
+ predicate?: ListIterator<T, boolean>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile(
+ predicate?: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile<TWhere>(
+ predicate?: TWhere
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile<TValue>(
+ predicate?: ListIterator<TValue, boolean>
+ ): LoDashImplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile<TValue>(
+ predicate?: string
+ ): LoDashImplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile<TWhere, TValue>(
+ predicate?: TWhere
+ ): LoDashImplicitArrayWrapper<TValue>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile(
+ predicate?: ListIterator<T, boolean>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile(
+ predicate?: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile<TWhere>(
+ predicate?: TWhere
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile<TValue>(
+ predicate?: ListIterator<TValue, boolean>
+ ): LoDashExplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile<TValue>(
+ predicate?: string
+ ): LoDashExplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.dropRightWhile
+ */
+ dropRightWhile<TWhere, TValue>(
+ predicate?: TWhere
+ ): LoDashExplicitArrayWrapper<TValue>;
+ }
+
+ //_.dropWhile
+ interface LoDashStatic {
+ /**
+ * Creates a slice of array excluding elements dropped from the beginning. Elements are dropped until predicate
+ * returns falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array).
+ *
+ * If a property name is provided for predicate the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for predicate the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * @param array The array to query.
+ * @param predicate The function invoked per iteration.
+ * @param thisArg The this binding of predicate.
+ * @return Returns the slice of array.
+ */
+ dropWhile<TValue>(
+ array: List<TValue>,
+ predicate?: ListIterator<TValue, boolean>
+ ): TValue[];
+
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile<TValue>(
+ array: List<TValue>,
+ predicate?: string
+ ): TValue[];
+
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile<TWhere, TValue>(
+ array: List<TValue>,
+ predicate?: TWhere
+ ): TValue[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile(
+ predicate?: ListIterator<T, boolean>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile(
+ predicate?: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile<TWhere>(
+ predicate?: TWhere
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile<TValue>(
+ predicate?: ListIterator<TValue, boolean>
+ ): LoDashImplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile<TValue>(
+ predicate?: string
+ ): LoDashImplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile<TWhere, TValue>(
+ predicate?: TWhere
+ ): LoDashImplicitArrayWrapper<TValue>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile(
+ predicate?: ListIterator<T, boolean>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile(
+ predicate?: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile<TWhere>(
+ predicate?: TWhere
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile<TValue>(
+ predicate?: ListIterator<TValue, boolean>
+ ): LoDashExplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile<TValue>(
+ predicate?: string
+ ): LoDashExplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.dropWhile
+ */
+ dropWhile<TWhere, TValue>(
+ predicate?: TWhere
+ ): LoDashExplicitArrayWrapper<TValue>;
+ }
+
+ //_.fill
+ interface LoDashStatic {
+ /**
+ * Fills elements of array with value from start up to, but not including, end.
+ *
+ * Note: This method mutates array.
+ *
+ * @param array The array to fill.
+ * @param value The value to fill array with.
+ * @param start The start position.
+ * @param end The end position.
+ * @return Returns array.
+ */
+ fill<T>(
+ array: any[],
+ value: T,
+ start?: number,
+ end?: number
+ ): T[];
+
+ /**
+ * @see _.fill
+ */
+ fill<T>(
+ array: List<any>,
+ value: T,
+ start?: number,
+ end?: number
+ ): List<T>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.fill
+ */
+ fill<T>(
+ value: T,
+ start?: number,
+ end?: number
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.fill
+ */
+ fill<T>(
+ value: T,
+ start?: number,
+ end?: number
+ ): LoDashImplicitObjectWrapper<List<T>>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.fill
+ */
+ fill<T>(
+ value: T,
+ start?: number,
+ end?: number
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.fill
+ */
+ fill<T>(
+ value: T,
+ start?: number,
+ end?: number
+ ): LoDashExplicitObjectWrapper<List<T>>;
+ }
+
+ //_.findIndex
+ interface LoDashStatic {
+ /**
+ * This method is like _.find except that it returns the index of the first element predicate returns truthy
+ * for instead of the element itself.
+ *
+ * If a property name is provided for predicate the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for predicate the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * @param array The array to search.
+ * @param predicate The function invoked per iteration.
+ * @param fromIndex The index to search from.
+ * @return Returns the index of the found element, else -1.
+ */
+ findIndex<T>(
+ array: List<T>,
+ predicate?: ListIterator<T, boolean>,
+ fromIndex?: number
+ ): number;
+
+ /**
+ * @see _.findIndex
+ */
+ findIndex<T>(
+ array: List<T>,
+ predicate?: string,
+ fromIndex?: number
+ ): number;
+
+ /**
+ * @see _.findIndex
+ */
+ findIndex<W, T>(
+ array: List<T>,
+ predicate?: W,
+ fromIndex?: number
+ ): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.findIndex
+ */
+ findIndex(
+ predicate?: ListIterator<T, boolean>,
+ fromIndex?: number
+ ): number;
+
+ /**
+ * @see _.findIndex
+ */
+ findIndex(
+ predicate?: string,
+ fromIndex?: number
+ ): number;
+
+ /**
+ * @see _.findIndex
+ */
+ findIndex<W>(
+ predicate?: W,
+ fromIndex?: number
+ ): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.findIndex
+ */
+ findIndex<TResult>(
+ predicate?: ListIterator<TResult, boolean>,
+ fromIndex?: number
+ ): number;
+
+ /**
+ * @see _.findIndex
+ */
+ findIndex(
+ predicate?: string,
+ fromIndex?: number
+ ): number;
+
+ /**
+ * @see _.findIndex
+ */
+ findIndex<W>(
+ predicate?: W,
+ fromIndex?: number
+ ): number;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.findIndex
+ */
+ findIndex(
+ predicate?: ListIterator<T, boolean>,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.findIndex
+ */
+ findIndex(
+ predicate?: string,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.findIndex
+ */
+ findIndex<W>(
+ predicate?: W,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.findIndex
+ */
+ findIndex<TResult>(
+ predicate?: ListIterator<TResult, boolean>,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.findIndex
+ */
+ findIndex(
+ predicate?: string,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.findIndex
+ */
+ findIndex<W>(
+ predicate?: W,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ //_.findLastIndex
+ interface LoDashStatic {
+ /**
+ * This method is like _.findIndex except that it iterates over elements of collection from right to left.
+ *
+ * If a property name is provided for predicate the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for predicate the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * @param array The array to search.
+ * @param predicate The function invoked per iteration.
+ * @param fromIndex The index to search from.
+ * @return Returns the index of the found element, else -1.
+ */
+ findLastIndex<T>(
+ array: List<T>,
+ predicate?: ListIterator<T, boolean>,
+ fromIndex?: number
+ ): number;
+
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex<T>(
+ array: List<T>,
+ predicate?: string,
+ fromIndex?: number
+ ): number;
+
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex<W, T>(
+ array: List<T>,
+ predicate?: W,
+ fromIndex?: number
+ ): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex(
+ predicate?: ListIterator<T, boolean>,
+ fromIndex?: number
+ ): number;
+
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex(
+ predicate?: string,
+ fromIndex?: number
+ ): number;
+
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex<W>(
+ predicate?: W,
+ fromIndex?: number
+ ): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex<TResult>(
+ predicate?: ListIterator<TResult, boolean>,
+ fromIndex?: number
+ ): number;
+
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex(
+ predicate?: string,
+ fromIndex?: number
+ ): number;
+
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex<W>(
+ predicate?: W,
+ fromIndex?: number
+ ): number;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex(
+ predicate?: ListIterator<T, boolean>,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex(
+ predicate?: string,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex<W>(
+ predicate?: W,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex<TResult>(
+ predicate?: ListIterator<TResult, boolean>,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex(
+ predicate?: string,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.findLastIndex
+ */
+ findLastIndex<W>(
+ predicate?: W,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ //_.first
+ interface LoDashStatic {
+ /**
+ * @see _.head
+ */
+ first<T>(array: List<T>): T;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.head
+ */
+ first(): string;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.head
+ */
+ first(): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.head
+ */
+ first<T>(): T;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.head
+ */
+ first(): LoDashExplicitWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.head
+ */
+ first<T>(): T;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.head
+ */
+ first<T>(): T;
+ }
+
+ interface RecursiveArray<T> extends Array<T|RecursiveArray<T>> {}
+ interface ListOfRecursiveArraysOrValues<T> extends List<T|RecursiveArray<T>> {}
+
+ //_.flatten
+ interface LoDashStatic {
+ /**
+ * Flattens a nested array. If isDeep is true the array is recursively flattened, otherwise it’s only
+ * flattened a single level.
+ *
+ * @param array The array to flatten.
+ * @param isDeep Specify a deep flatten.
+ * @return Returns the new flattened array.
+ */
+ flatten<T>(array: ListOfRecursiveArraysOrValues<T>, isDeep: boolean): T[];
+
+ /**
+ * @see _.flatten
+ */
+ flatten<T>(array: List<T|T[]>): T[];
+
+ /**
+ * @see _.flatten
+ */
+ flatten<T>(array: ListOfRecursiveArraysOrValues<T>): RecursiveArray<T>;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.flatten
+ */
+ flatten(): LoDashImplicitArrayWrapper<string>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.flatten
+ */
+ flatten<TResult>(isDeep?: boolean): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.flatten
+ */
+ flatten<TResult>(isDeep?: boolean): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.flatten
+ */
+ flatten(): LoDashExplicitArrayWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.flatten
+ */
+ flatten<TResult>(isDeep?: boolean): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.flatten
+ */
+ flatten<TResult>(isDeep?: boolean): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ //_.flattenDeep
+ interface LoDashStatic {
+ /**
+ * Recursively flattens a nested array.
+ *
+ * @param array The array to recursively flatten.
+ * @return Returns the new flattened array.
+ */
+ flattenDeep<T>(array: ListOfRecursiveArraysOrValues<T>): T[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.flattenDeep
+ */
+ flattenDeep(): LoDashImplicitArrayWrapper<string>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.flattenDeep
+ */
+ flattenDeep<T>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.flattenDeep
+ */
+ flattenDeep<T>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.flattenDeep
+ */
+ flattenDeep(): LoDashExplicitArrayWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.flattenDeep
+ */
+ flattenDeep<T>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.flattenDeep
+ */
+ flattenDeep<T>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ // _.flattenDepth
+ interface LoDashStatic {
+ /**
+ * Recursively flatten array up to depth times.
+ *
+ * @param array The array to recursively flatten.
+ * @param number The maximum recursion depth.
+ * @return Returns the new flattened array.
+ */
+ flattenDepth<T>(array: ListOfRecursiveArraysOrValues<T>, depth?: number): T[];
+ }
+
+ //_.fromPairs
+ interface LoDashStatic {
+ /**
+ * The inverse of `_.toPairs`; this method returns an object composed
+ * from key-value `pairs`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} pairs The key-value pairs.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * _.fromPairs([['fred', 30], ['barney', 40]]);
+ * // => { 'fred': 30, 'barney': 40 }
+ */
+ fromPairs<T>(
+ array: List<[_.StringRepresentable, T]>
+ ): Dictionary<T>;
+
+ /**
+ @see _.fromPairs
+ */
+ fromPairs(
+ array: List<any[]>
+ ): Dictionary<any>;
+ }
+
+ //_.fromPairs DUMMY
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.fromPairs
+ */
+ fromPairs(): LoDashImplicitObjectWrapper<any>;
+ }
+
+ //_.fromPairs DUMMY
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.fromPairs
+ */
+ fromPairs(): LoDashExplicitObjectWrapper<any>;
+ }
+
+ //_.head
+ interface LoDashStatic {
+ /**
+ * Gets the first element of array.
+ *
+ * @alias _.first
+ *
+ * @param array The array to query.
+ * @return Returns the first element of array.
+ */
+ head<T>(array: List<T>): T;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.head
+ */
+ head(): string;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.head
+ */
+ head(): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.head
+ */
+ head<T>(): T;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.head
+ */
+ head(): LoDashExplicitWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.head
+ */
+ head<T>(): T;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.head
+ */
+ head<T>(): T;
+ }
+
+ //_.indexOf
+ interface LoDashStatic {
+ /**
+ * Gets the index at which the first occurrence of `value` is found in `array`
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+ * for equality comparisons. If `fromIndex` is negative, it's used as the offset
+ * from the end of `array`. If `array` is sorted providing `true` for `fromIndex`
+ * performs a faster binary search.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ * @example
+ *
+ * _.indexOf([1, 2, 1, 2], 2);
+ * // => 1
+ *
+ * // using `fromIndex`
+ * _.indexOf([1, 2, 1, 2], 2, 2);
+ * // => 3
+ */
+ indexOf<T>(
+ array: List<T>,
+ value: T,
+ fromIndex?: boolean|number
+ ): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.indexOf
+ */
+ indexOf(
+ value: T,
+ fromIndex?: boolean|number
+ ): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.indexOf
+ */
+ indexOf<TValue>(
+ value: TValue,
+ fromIndex?: boolean|number
+ ): number;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.indexOf
+ */
+ indexOf(
+ value: T,
+ fromIndex?: boolean|number
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.indexOf
+ */
+ indexOf<TValue>(
+ value: TValue,
+ fromIndex?: boolean|number
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ //_.intersectionBy DUMMY
+ interface LoDashStatic {
+ /**
+ * This method is like `_.intersection` except that it accepts `iteratee`
+ * which is invoked for each element of each `arrays` to generate the criterion
+ * by which uniqueness is computed. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Array} Returns the new array of shared values.
+ * @example
+ *
+ * _.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
+ * // => [2.1]
+ *
+ * // using the `_.property` iteratee shorthand
+ * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 1 }]
+ */
+ intersectionBy(
+ array: any[]|List<any>,
+ ...values: any[]
+ ): any[];
+ }
+
+ //_.intersectionWith DUMMY
+ interface LoDashStatic {
+ /**
+ * This method is like `_.intersection` except that it accepts `comparator`
+ * which is invoked to compare elements of `arrays`. The comparator is invoked
+ * with two arguments: (arrVal, othVal).
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of shared values.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+ * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
+ *
+ * _.intersectionWith(objects, others, _.isEqual);
+ * // => [{ 'x': 1, 'y': 2 }]
+ */
+ intersectionWith(
+ array: any[]|List<any>,
+ ...values: any[]
+ ): any[];
+ }
+
+ //_.join
+ interface LoDashStatic {
+ /**
+ * Converts all elements in `array` into a string separated by `separator`.
+ *
+ * @param array The array to convert.
+ * @param separator The element separator.
+ * @returns Returns the joined string.
+ */
+ join(
+ array: List<any>,
+ separator?: string
+ ): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.join
+ */
+ join(separator?: string): string;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.join
+ */
+ join(separator?: string): string;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.join
+ */
+ join(separator?: string): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.join
+ */
+ join(separator?: string): LoDashExplicitWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.join
+ */
+ join(separator?: string): LoDashExplicitWrapper<string>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.join
+ */
+ join(separator?: string): LoDashExplicitWrapper<string>;
+ }
+
+ //_.pullAll DUMMY
+ interface LoDashStatic {
+ /**
+ * This method is like `_.pull` except that it accepts an array of values to remove.
+ *
+ * **Note:** Unlike `_.difference`, this method mutates `array`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to remove.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [1, 2, 3, 1, 2, 3];
+ *
+ * _.pull(array, [2, 3]);
+ * console.log(array);
+ * // => [1, 1]
+ */
+ pullAll(
+ array: any[]|List<any>,
+ ...values: any[]
+ ): any[];
+ }
+
+ //_.pullAllBy DUMMY
+ interface LoDashStatic {
+ /**
+ * This method is like `_.pullAll` except that it accepts `iteratee` which is
+ * invoked for each element of `array` and `values` to to generate the criterion
+ * by which uniqueness is computed. The iteratee is invoked with one argument: (value).
+ *
+ * **Note:** Unlike `_.differenceBy`, this method mutates `array`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to remove.
+ * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
+ *
+ * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
+ * console.log(array);
+ * // => [{ 'x': 2 }]
+ */
+ pullAllBy(
+ array: any[]|List<any>,
+ ...values: any[]
+ ): any[];
+ }
+
+ //_.reverse DUMMY
+ interface LoDashStatic {
+ /**
+ * Reverses `array` so that the first element becomes the last, the second
+ * element becomes the second to last, and so on.
+ *
+ * **Note:** This method mutates `array` and is based on
+ * [`Array#reverse`](https://mdn.io/Array/reverse).
+ *
+ * @memberOf _
+ * @category Array
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [1, 2, 3];
+ *
+ * _.reverse(array);
+ * // => [3, 2, 1]
+ *
+ * console.log(array);
+ * // => [3, 2, 1]
+ */
+ reverse(
+ array: any[]|List<any>,
+ ...values: any[]
+ ): any[];
+ }
+
+ //_.sortedIndexOf
+ interface LoDashStatic {
+ /**
+ * This method is like `_.indexOf` except that it performs a binary
+ * search on a sorted `array`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ * @example
+ *
+ * _.sortedIndexOf([1, 1, 2, 2], 2);
+ * // => 2
+ */
+ sortedIndexOf<T>(
+ array: List<T>,
+ value: T
+ ): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedIndexOf
+ */
+ sortedIndexOf(
+ value: T
+ ): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedIndexOf
+ */
+ sortedIndexOf<TValue>(
+ value: TValue
+ ): number;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedIndexOf
+ */
+ sortedIndexOf(
+ value: T
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedIndexOf
+ */
+ sortedIndexOf<TValue>(
+ value: TValue
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ //_.initial
+ interface LoDashStatic {
+ /**
+ * Gets all but the last element of array.
+ *
+ * @param array The array to query.
+ * @return Returns the slice of array.
+ */
+ initial<T>(array: List<T>): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.initial
+ */
+ initial(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.initial
+ */
+ initial<T>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.initial
+ */
+ initial(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.initial
+ */
+ initial<T>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.intersection
+ interface LoDashStatic {
+ /**
+ * Creates an array of unique values that are included in all of the provided arrays using SameValueZero for
+ * equality comparisons.
+ *
+ * @param arrays The arrays to inspect.
+ * @return Returns the new array of shared values.
+ */
+ intersection<T>(...arrays: (T[]|List<T>)[]): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.intersection
+ */
+ intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.intersection
+ */
+ intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.intersection
+ */
+ intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.intersection
+ */
+ intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ //_.last
+ interface LoDashStatic {
+ /**
+ * Gets the last element of array.
+ *
+ * @param array The array to query.
+ * @return Returns the last element of array.
+ */
+ last<T>(array: List<T>): T;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.last
+ */
+ last(): string;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.last
+ */
+ last(): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.last
+ */
+ last<T>(): T;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.last
+ */
+ last(): LoDashExplicitWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.last
+ */
+ last<T>(): T;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.last
+ */
+ last<T>(): T;
+ }
+
+ //_.lastIndexOf
+ interface LoDashStatic {
+ /**
+ * This method is like _.indexOf except that it iterates over elements of array from right to left.
+ *
+ * @param array The array to search.
+ * @param value The value to search for.
+ * @param fromIndex The index to search from or true to perform a binary search on a sorted array.
+ * @return Returns the index of the matched value, else -1.
+ */
+ lastIndexOf<T>(
+ array: List<T>,
+ value: T,
+ fromIndex?: boolean|number
+ ): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.lastIndexOf
+ */
+ lastIndexOf(
+ value: T,
+ fromIndex?: boolean|number
+ ): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.lastIndexOf
+ */
+ lastIndexOf<TResult>(
+ value: TResult,
+ fromIndex?: boolean|number
+ ): number;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.lastIndexOf
+ */
+ lastIndexOf(
+ value: T,
+ fromIndex?: boolean|number
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.lastIndexOf
+ */
+ lastIndexOf<TResult>(
+ value: TResult,
+ fromIndex?: boolean|number
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ //_.pull
+ interface LoDashStatic {
+ /**
+ * Removes all provided values from array using SameValueZero for equality comparisons.
+ *
+ * Note: Unlike _.without, this method mutates array.
+ *
+ * @param array The array to modify.
+ * @param values The values to remove.
+ * @return Returns array.
+ */
+ pull<T>(
+ array: T[],
+ ...values: T[]
+ ): T[];
+
+ /**
+ * @see _.pull
+ */
+ pull<T>(
+ array: List<T>,
+ ...values: T[]
+ ): List<T>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.pull
+ */
+ pull(...values: T[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.pull
+ */
+ pull<TValue>(...values: TValue[]): LoDashImplicitObjectWrapper<List<TValue>>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.pull
+ */
+ pull(...values: T[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.pull
+ */
+ pull<TValue>(...values: TValue[]): LoDashExplicitObjectWrapper<List<TValue>>;
+ }
+
+ //_.pullAt
+ interface LoDashStatic {
+ /**
+ * Removes elements from array corresponding to the given indexes and returns an array of the removed elements.
+ * Indexes may be specified as an array of indexes or as individual arguments.
+ *
+ * Note: Unlike _.at, this method mutates array.
+ *
+ * @param array The array to modify.
+ * @param indexes The indexes of elements to remove, specified as individual indexes or arrays of indexes.
+ * @return Returns the new array of removed elements.
+ */
+ pullAt<T>(
+ array: List<T>,
+ ...indexes: (number|number[])[]
+ ): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.pullAt
+ */
+ pullAt(...indexes: (number|number[])[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.pullAt
+ */
+ pullAt<T>(...indexes: (number|number[])[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.pullAt
+ */
+ pullAt(...indexes: (number|number[])[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.pullAt
+ */
+ pullAt<T>(...indexes: (number|number[])[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.remove
+ interface LoDashStatic {
+ /**
+ * Removes all elements from array that predicate returns truthy for and returns an array of the removed
+ * elements. The predicate is bound to thisArg and invoked with three arguments: (value, index, array).
+ *
+ * If a property name is provided for predicate the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for predicate the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * Note: Unlike _.filter, this method mutates array.
+ *
+ * @param array The array to modify.
+ * @param predicate The function invoked per iteration.
+ * @param thisArg The this binding of predicate.
+ * @return Returns the new array of removed elements.
+ */
+ remove<T>(
+ array: List<T>,
+ predicate?: ListIterator<T, boolean>
+ ): T[];
+
+ /**
+ * @see _.remove
+ */
+ remove<T>(
+ array: List<T>,
+ predicate?: string
+ ): T[];
+
+ /**
+ * @see _.remove
+ */
+ remove<W, T>(
+ array: List<T>,
+ predicate?: W
+ ): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.remove
+ */
+ remove(
+ predicate?: ListIterator<T, boolean>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.remove
+ */
+ remove(
+ predicate?: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.remove
+ */
+ remove<W>(
+ predicate?: W
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.remove
+ */
+ remove<TResult>(
+ predicate?: ListIterator<TResult, boolean>
+ ): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.remove
+ */
+ remove<TResult>(
+ predicate?: string
+ ): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.remove
+ */
+ remove<W, TResult>(
+ predicate?: W
+ ): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.remove
+ */
+ remove(
+ predicate?: ListIterator<T, boolean>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.remove
+ */
+ remove(
+ predicate?: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.remove
+ */
+ remove<W>(
+ predicate?: W
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.remove
+ */
+ remove<TResult>(
+ predicate?: ListIterator<TResult, boolean>
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.remove
+ */
+ remove<TResult>(
+ predicate?: string
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.remove
+ */
+ remove<W, TResult>(
+ predicate?: W
+ ): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ //_.tail
+ interface LoDashStatic {
+ /**
+ * Gets all but the first element of array.
+ *
+ * @alias _.tail
+ *
+ * @param array The array to query.
+ * @return Returns the slice of array.
+ */
+ tail<T>(array: List<T>): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.tail
+ */
+ tail(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.tail
+ */
+ tail<T>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.tail
+ */
+ tail(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.tail
+ */
+ tail<T>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.slice
+ interface LoDashStatic {
+ /**
+ * Creates a slice of array from start up to, but not including, end.
+ *
+ * @param array The array to slice.
+ * @param start The start position.
+ * @param end The end position.
+ * @return Returns the slice of array.
+ */
+ slice<T>(
+ array: T[],
+ start?: number,
+ end?: number
+ ): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.slice
+ */
+ slice(
+ start?: number,
+ end?: number
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.slice
+ */
+ slice(
+ start?: number,
+ end?: number
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.sortedIndex
+ interface LoDashStatic {
+ /**
+ * Uses a binary search to determine the lowest index at which `value` should
+ * be inserted into `array` in order to maintain its sort order.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted into `array`.
+ * @example
+ *
+ * _.sortedIndex([30, 50], 40);
+ * // => 1
+ *
+ * _.sortedIndex([4, 5], 4);
+ * // => 0
+ */
+ sortedIndex<T, TSort>(
+ array: List<T>,
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<T>(
+ array: List<T>,
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<T>(
+ array: List<T>,
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<W, T>(
+ array: List<T>,
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<T>(
+ array: List<T>,
+ value: T
+ ): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<TSort>(
+ value: string
+ ): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<TSort>(
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex(
+ value: T
+ ): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<T, TSort>(
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<T>(
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<W, T>(
+ value: T
+ ): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<TSort>(
+ value: string
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<TSort>(
+ value: T
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex(
+ value: T
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<W>(
+ value: T
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<T, TSort>(
+ value: T
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<T>(
+ value: T
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedIndex
+ */
+ sortedIndex<W, T>(
+ value: T
+ ): LoDashExplicitWrapper<number>;
+
+
+ }
+
+ //_.sortedIndexBy
+ interface LoDashStatic {
+ /**
+ * This method is like `_.sortedIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted into `array`.
+ * @example
+ *
+ * var dict = { 'thirty': 30, 'forty': 40, 'fifty': 50 };
+ *
+ * _.sortedIndexBy(['thirty', 'fifty'], 'forty', _.propertyOf(dict));
+ * // => 1
+ *
+ * // using the `_.property` iteratee shorthand
+ * _.sortedIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x');
+ * // => 0
+ */
+ sortedIndexBy<T, TSort>(
+ array: List<T>,
+ value: T,
+ iteratee: (x: T) => TSort
+ ): number;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<T>(
+ array: List<T>,
+ value: T,
+ iteratee: (x: T) => any
+ ): number;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<T>(
+ array: List<T>,
+ value: T,
+ iteratee: string
+ ): number;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<W, T>(
+ array: List<T>,
+ value: T,
+ iteratee: W
+ ): number;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<T>(
+ array: List<T>,
+ value: T,
+ iteratee: Object
+ ): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<TSort>(
+ value: string,
+ iteratee: (x: string) => TSort
+ ): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<TSort>(
+ value: T,
+ iteratee: (x: T) => TSort
+ ): number;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy(
+ value: T,
+ iteratee: string
+ ): number;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<W>(
+ value: T,
+ iteratee: W
+ ): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<T, TSort>(
+ value: T,
+ iteratee: (x: T) => TSort
+ ): number;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<T>(
+ value: T,
+ iteratee: (x: T) => any
+ ): number;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<T>(
+ value: T,
+ iteratee: string
+ ): number;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<W, T>(
+ value: T,
+ iteratee: W
+ ): number;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<T>(
+ value: T,
+ iteratee: Object
+ ): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<TSort>(
+ value: string,
+ iteratee: (x: string) => TSort
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<TSort>(
+ value: T,
+ iteratee: (x: T) => TSort
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy(
+ value: T,
+ iteratee: string
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<W>(
+ value: T,
+ iteratee: W
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<T, TSort>(
+ value: T,
+ iteratee: (x: T) => TSort
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<T>(
+ value: T,
+ iteratee: (x: T) => any
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<T>(
+ value: T,
+ iteratee: string
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<W, T>(
+ value: T,
+ iteratee: W
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedIndexBy
+ */
+ sortedIndexBy<T>(
+ value: T,
+ iteratee: Object
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ //_.sortedLastIndex
+ interface LoDashStatic {
+ /**
+ * This method is like `_.sortedIndex` except that it returns the highest
+ * index at which `value` should be inserted into `array` in order to
+ * maintain its sort order.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted into `array`.
+ * @example
+ *
+ * _.sortedLastIndex([4, 5], 4);
+ * // => 1
+ */
+ sortedLastIndex<T, TSort>(
+ array: List<T>,
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<T>(
+ array: List<T>,
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<T>(
+ array: List<T>,
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<W, T>(
+ array: List<T>,
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<T>(
+ array: List<T>,
+ value: T
+ ): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<TSort>(
+ value: string
+ ): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<TSort>(
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex(
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<W>(
+ value: T
+ ): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<T, TSort>(
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<T>(
+ value: T
+ ): number;
+
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<W, T>(
+ value: T
+ ): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<TSort>(
+ value: string
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<TSort>(
+ value: T
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex(
+ value: T
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<T, TSort>(
+ value: T
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<T>(
+ value: T
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedLastIndex
+ */
+ sortedLastIndex<W, T>(
+ value: T
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ //_.sortedLastIndexBy
+ interface LoDashStatic {
+ /**
+ * This method is like `_.sortedLastIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted into `array`.
+ * @example
+ *
+ * // using the `_.property` iteratee shorthand
+ * _.sortedLastIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x');
+ * // => 1
+ */
+ sortedLastIndexBy<T, TSort>(
+ array: List<T>,
+ value: T,
+ iteratee: (x: T) => TSort
+ ): number;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<T>(
+ array: List<T>,
+ value: T,
+ iteratee: (x: T) => any
+ ): number;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<T>(
+ array: List<T>,
+ value: T,
+ iteratee: string
+ ): number;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<W, T>(
+ array: List<T>,
+ value: T,
+ iteratee: W
+ ): number;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<T>(
+ array: List<T>,
+ value: T,
+ iteratee: Object
+ ): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<TSort>(
+ value: string,
+ iteratee: (x: string) => TSort
+ ): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<TSort>(
+ value: T,
+ iteratee: (x: T) => TSort
+ ): number;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy(
+ value: T,
+ iteratee: string
+ ): number;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<W>(
+ value: T,
+ iteratee: W
+ ): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<T, TSort>(
+ value: T,
+ iteratee: (x: T) => TSort
+ ): number;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<T>(
+ value: T,
+ iteratee: (x: T) => any
+ ): number;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<T>(
+ value: T,
+ iteratee: string
+ ): number;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<W, T>(
+ value: T,
+ iteratee: W
+ ): number;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<T>(
+ value: T,
+ iteratee: Object
+ ): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<TSort>(
+ value: string,
+ iteratee: (x: string) => TSort
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<TSort>(
+ value: T,
+ iteratee: (x: T) => TSort
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy(
+ value: T,
+ iteratee: string
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<W>(
+ value: T,
+ iteratee: W
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<T, TSort>(
+ value: T,
+ iteratee: (x: T) => TSort
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<T>(
+ value: T,
+ iteratee: (x: T) => any
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<T>(
+ value: T,
+ iteratee: string
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<W, T>(
+ value: T,
+ iteratee: W
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sortedLastIndexBy
+ */
+ sortedLastIndexBy<T>(
+ value: T,
+ iteratee: Object
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ //_.sortedLastIndexOf DUMMY
+ interface LoDashStatic {
+ /**
+ * This method is like `_.lastIndexOf` except that it performs a binary
+ * search on a sorted `array`.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to search.
+ * @param {*} value The value to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ * @example
+ *
+ * _.sortedLastIndexOf([1, 1, 2, 2], 2);
+ * // => 3
+ */
+ sortedLastIndexOf(
+ array: any[]|List<any>,
+ ...values: any[]
+ ): any[];
+ }
+
+ //_.tail
+ interface LoDashStatic {
+ /**
+ * @see _.rest
+ */
+ tail<T>(array: List<T>): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.rest
+ */
+ tail(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.rest
+ */
+ tail<T>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.rest
+ */
+ tail(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.rest
+ */
+ tail<T>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.take
+ interface LoDashStatic {
+ /**
+ * Creates a slice of array with n elements taken from the beginning.
+ *
+ * @param array The array to query.
+ * @param n The number of elements to take.
+ * @return Returns the slice of array.
+ */
+ take<T>(
+ array: List<T>,
+ n?: number
+ ): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.take
+ */
+ take(n?: number): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.take
+ */
+ take<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.take
+ */
+ take(n?: number): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.take
+ */
+ take<TResult>(n?: number): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ //_.takeRight
+ interface LoDashStatic {
+ /**
+ * Creates a slice of array with n elements taken from the end.
+ *
+ * @param array The array to query.
+ * @param n The number of elements to take.
+ * @return Returns the slice of array.
+ */
+ takeRight<T>(
+ array: List<T>,
+ n?: number
+ ): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.takeRight
+ */
+ takeRight(n?: number): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.takeRight
+ */
+ takeRight<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.takeRight
+ */
+ takeRight(n?: number): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.takeRight
+ */
+ takeRight<TResult>(n?: number): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ //_.takeRightWhile
+ interface LoDashStatic {
+ /**
+ * Creates a slice of array with elements taken from the end. Elements are taken until predicate returns
+ * falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array).
+ *
+ * If a property name is provided for predicate the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for predicate the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * @param array The array to query.
+ * @param predicate The function invoked per iteration.
+ * @param thisArg The this binding of predicate.
+ * @return Returns the slice of array.
+ */
+ takeRightWhile<TValue>(
+ array: List<TValue>,
+ predicate?: ListIterator<TValue, boolean>
+ ): TValue[];
+
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile<TValue>(
+ array: List<TValue>,
+ predicate?: string
+ ): TValue[];
+
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile<TWhere, TValue>(
+ array: List<TValue>,
+ predicate?: TWhere
+ ): TValue[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile(
+ predicate?: ListIterator<T, boolean>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile(
+ predicate?: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile<TWhere>(
+ predicate?: TWhere
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile<TValue>(
+ predicate?: ListIterator<TValue, boolean>
+ ): LoDashImplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile<TValue>(
+ predicate?: string
+ ): LoDashImplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile<TWhere, TValue>(
+ predicate?: TWhere
+ ): LoDashImplicitArrayWrapper<TValue>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile(
+ predicate?: ListIterator<T, boolean>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile(
+ predicate?: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile<TWhere>(
+ predicate?: TWhere
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile<TValue>(
+ predicate?: ListIterator<TValue, boolean>
+ ): LoDashExplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile<TValue>(
+ predicate?: string
+ ): LoDashExplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.takeRightWhile
+ */
+ takeRightWhile<TWhere, TValue>(
+ predicate?: TWhere
+ ): LoDashExplicitArrayWrapper<TValue>;
+ }
+
+ //_.takeWhile
+ interface LoDashStatic {
+ /**
+ * Creates a slice of array with elements taken from the beginning. Elements are taken until predicate returns
+ * falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array).
+ *
+ * If a property name is provided for predicate the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for predicate the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * @param array The array to query.
+ * @param predicate The function invoked per iteration.
+ * @param thisArg The this binding of predicate.
+ * @return Returns the slice of array.
+ */
+ takeWhile<TValue>(
+ array: List<TValue>,
+ predicate?: ListIterator<TValue, boolean>
+ ): TValue[];
+
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile<TValue>(
+ array: List<TValue>,
+ predicate?: string
+ ): TValue[];
+
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile<TWhere, TValue>(
+ array: List<TValue>,
+ predicate?: TWhere
+ ): TValue[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile(
+ predicate?: ListIterator<T, boolean>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile(
+ predicate?: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile<TWhere>(
+ predicate?: TWhere
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile<TValue>(
+ predicate?: ListIterator<TValue, boolean>
+ ): LoDashImplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile<TValue>(
+ predicate?: string
+ ): LoDashImplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile<TWhere, TValue>(
+ predicate?: TWhere
+ ): LoDashImplicitArrayWrapper<TValue>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile(
+ predicate?: ListIterator<T, boolean>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile(
+ predicate?: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile<TWhere>(
+ predicate?: TWhere
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile<TValue>(
+ predicate?: ListIterator<TValue, boolean>
+ ): LoDashExplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile<TValue>(
+ predicate?: string
+ ): LoDashExplicitArrayWrapper<TValue>;
+
+ /**
+ * @see _.takeWhile
+ */
+ takeWhile<TWhere, TValue>(
+ predicate?: TWhere
+ ): LoDashExplicitArrayWrapper<TValue>;
+ }
+
+ //_.union
+ interface LoDashStatic {
+ /**
+ * Creates an array of unique values, in order, from all of the provided arrays using SameValueZero for
+ * equality comparisons.
+ *
+ * @param arrays The arrays to inspect.
+ * @return Returns the new array of combined values.
+ */
+ union<T>(...arrays: List<T>[]): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.union
+ */
+ union(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.union
+ */
+ union<T>(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.union
+ */
+ union<T>(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.union
+ */
+ union(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.union
+ */
+ union<T>(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.union
+ */
+ union<T>(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.unionBy
+ interface LoDashStatic {
+ /**
+ * This method is like `_.union` except that it accepts `iteratee` which is
+ * invoked for each element of each `arrays` to generate the criterion by which
+ * uniqueness is computed. The iteratee is invoked with one argument: (value).
+ *
+ * @param arrays The arrays to inspect.
+ * @param iteratee The iteratee invoked per element.
+ * @return Returns the new array of combined values.
+ */
+ unionBy<T>(
+ arrays: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): T[];
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays: T[]|List<T>,
+ iteratee?: W
+ ): T[];
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays1: T[]|List<T>,
+ arrays2: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): T[];
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays1: T[]|List<T>,
+ arrays2: T[]|List<T>,
+ iteratee?: W
+ ): T[];
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays1: T[]|List<T>,
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): T[];
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays1: T[]|List<T>,
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ iteratee?: W
+ ): T[];
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays1: T[]|List<T>,
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): T[];
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays1: T[]|List<T>,
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ iteratee?: W
+ ): T[];
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays1: T[]|List<T>,
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ arrays5: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): T[];
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays1: T[]|List<T>,
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ arrays5: T[]|List<T>,
+ iteratee?: W
+ ): T[];
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays: T[]|List<T>,
+ ...iteratee: any[]
+ ): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ iteratee?: (value: T) => any
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ arrays5: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ arrays5: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ ...iteratee: any[]
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ iteratee?: (value: T) => any
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ arrays5: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ arrays5: T[]|List<T>,
+ iteratee?: W
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ ...iteratee: any[]
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ iteratee?: (value: T) => any
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ arrays5: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ arrays5: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ ...iteratee: any[]
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ iteratee?: (value: T) => any
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ arrays5: T[]|List<T>,
+ iteratee?: (value: T) => any
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T, W extends Object>(
+ arrays2: T[]|List<T>,
+ arrays3: T[]|List<T>,
+ arrays4: T[]|List<T>,
+ arrays5: T[]|List<T>,
+ iteratee?: W
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.unionBy
+ */
+ unionBy<T>(
+ ...iteratee: any[]
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.uniq
+ interface LoDashStatic {
+ /**
+ * Creates a duplicate-free version of an array, using
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+ * for equality comparisons, in which only the first occurrence of each element
+ * is kept.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.uniq([2, 1, 2]);
+ * // => [2, 1]
+ */
+ uniq<T>(
+ array: List<T>
+ ): T[];
+
+ /**
+ * @see _.uniq
+ */
+ uniq<T, TSort>(
+ array: List<T>
+ ): T[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.uniq
+ */
+ uniq<TSort>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.uniq
+ */
+ uniq<TSort>(): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniq
+ */
+ uniq(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ uniq<T>(): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniq
+ */
+ uniq<T, TSort>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.uniq
+ */
+ uniq<TSort>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.uniq
+ */
+ uniq<TSort>(): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniq
+ */
+ uniq(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.uniq
+ */
+ uniq<T>(): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniq
+ */
+ uniq<T, TSort>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.uniqBy
+ interface LoDashStatic {
+ /**
+ * This method is like `_.uniq` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the criterion by which
+ * uniqueness is computed. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
+ * // => [2.1, 1.2]
+ *
+ * // using the `_.property` iteratee shorthand
+ * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 1 }, { 'x': 2 }]
+ */
+ uniqBy<T>(
+ array: List<T>,
+ iteratee: ListIterator<T, any>
+ ): T[];
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<T, TSort>(
+ array: List<T>,
+ iteratee: ListIterator<T, TSort>
+ ): T[];
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<T>(
+ array: List<T>,
+ iteratee: string
+ ): T[];
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<T>(
+ array: List<T>,
+ iteratee: Object
+ ): T[];
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<TWhere extends {}, T>(
+ array: List<T>,
+ iteratee: TWhere
+ ): T[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<TSort>(
+ iteratee: ListIterator<T, TSort>
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<TSort>(
+ iteratee: ListIterator<T, TSort>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy(
+ iteratee: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<TWhere extends {}>(
+ iteratee: TWhere
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<T>(
+ iteratee: ListIterator<T, any>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<T, TSort>(
+ iteratee: ListIterator<T, TSort>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<T>(
+ iteratee: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<T>(
+ iteratee: Object
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<TWhere extends {}, T>(
+ iteratee: TWhere
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<TSort>(
+ iteratee: ListIterator<T, TSort>
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<TSort>(
+ iteratee: ListIterator<T, TSort>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy(
+ iteratee: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<TWhere extends {}>(
+ iteratee: TWhere
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<T>(
+ iteratee: ListIterator<T, any>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<T, TSort>(
+ iteratee: ListIterator<T, TSort>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<T>(
+ iteratee: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<T>(
+ iteratee: Object
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.uniqBy
+ */
+ uniqBy<TWhere extends {}, T>(
+ iteratee: TWhere
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.sortedUniq
+ interface LoDashStatic {
+ /**
+ * This method is like `_.uniq` except that it's designed and optimized
+ * for sorted arrays.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.sortedUniq([1, 1, 2]);
+ * // => [1, 2]
+ */
+ sortedUniq<T>(
+ array: List<T>
+ ): T[];
+
+ /**
+ * @see _.sortedUniq
+ */
+ sortedUniq<T, TSort>(
+ array: List<T>
+ ): T[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.sortedUniq
+ */
+ sortedUniq<TSort>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedUniq
+ */
+ sortedUniq<TSort>(): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniq
+ */
+ sortedUniq(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ sortedUniq<T>(): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniq
+ */
+ sortedUniq<T, TSort>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.sortedUniq
+ */
+ sortedUniq<TSort>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedUniq
+ */
+ sortedUniq<TSort>(): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniq
+ */
+ sortedUniq(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedUniq
+ */
+ sortedUniq<T>(): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniq
+ */
+ sortedUniq<T, TSort>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.sortedUniqBy
+ interface LoDashStatic {
+ /**
+ * This method is like `_.uniqBy` except that it's designed and optimized
+ * for sorted arrays.
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
+ * // => [1.1, 2.2]
+ */
+ sortedUniqBy<T>(
+ array: List<T>,
+ iteratee: ListIterator<T, any>
+ ): T[];
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<T, TSort>(
+ array: List<T>,
+ iteratee: ListIterator<T, TSort>
+ ): T[];
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<T>(
+ array: List<T>,
+ iteratee: string
+ ): T[];
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<T>(
+ array: List<T>,
+ iteratee: Object
+ ): T[];
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<TWhere extends {}, T>(
+ array: List<T>,
+ iteratee: TWhere
+ ): T[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<TSort>(
+ iteratee: ListIterator<T, TSort>
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<TSort>(
+ iteratee: ListIterator<T, TSort>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy(
+ iteratee: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<TWhere extends {}>(
+ iteratee: TWhere
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<T>(
+ iteratee: ListIterator<T, any>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<T, TSort>(
+ iteratee: ListIterator<T, TSort>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<T>(
+ iteratee: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<T>(
+ iteratee: Object
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<TWhere extends {}, T>(
+ iteratee: TWhere
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<TSort>(
+ iteratee: ListIterator<T, TSort>
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<TSort>(
+ iteratee: ListIterator<T, TSort>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy(
+ iteratee: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<TWhere extends {}>(
+ iteratee: TWhere
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<T>(
+ iteratee: ListIterator<T, any>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<T, TSort>(
+ iteratee: ListIterator<T, TSort>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<T>(
+ iteratee: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<T>(
+ iteratee: Object
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortedUniqBy
+ */
+ sortedUniqBy<TWhere extends {}, T>(
+ iteratee: TWhere
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.unionWith DUMMY
+ interface LoDashStatic {
+ /**
+ * This method is like `_.union` except that it accepts `comparator` which
+ * is invoked to compare elements of `arrays`. The comparator is invoked
+ * with two arguments: (arrVal, othVal).
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of combined values.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+ * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
+ *
+ * _.unionWith(objects, others, _.isEqual);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
+ */
+ unionWith(
+ array: any[]|List<any>,
+ ...values: any[]
+ ): any[];
+ }
+
+ //_.uniqWith DUMMY
+ interface LoDashStatic {
+ /**
+ * This method is like `_.uniq` except that it accepts `comparator` which
+ * is invoked to compare elements of `array`. The comparator is invoked with
+ * two arguments: (arrVal, othVal).
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
+ *
+ * _.uniqWith(objects, _.isEqual);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
+ */
+ uniqWith(
+ array: any[]|List<any>,
+ ...values: any[]
+ ): any[];
+ }
+
+ //_.unzip
+ interface LoDashStatic {
+ /**
+ * This method is like _.zip except that it accepts an array of grouped elements and creates an array
+ * regrouping the elements to their pre-zip configuration.
+ *
+ * @param array The array of grouped elements to process.
+ * @return Returns the new array of regrouped elements.
+ */
+ unzip<T>(array: List<List<T>>): T[][];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.unzip
+ */
+ unzip<T>(): LoDashImplicitArrayWrapper<T[]>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.unzip
+ */
+ unzip<T>(): LoDashImplicitArrayWrapper<T[]>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.unzip
+ */
+ unzip<T>(): LoDashExplicitArrayWrapper<T[]>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.unzip
+ */
+ unzip<T>(): LoDashExplicitArrayWrapper<T[]>;
+ }
+
+ //_.unzipWith
+ interface LoDashStatic {
+ /**
+ * This method is like _.unzip except that it accepts an iteratee to specify how regrouped values should be
+ * combined. The iteratee is bound to thisArg and invoked with four arguments: (accumulator, value, index,
+ * group).
+ *
+ * @param array The array of grouped elements to process.
+ * @param iteratee The function to combine regrouped values.
+ * @param thisArg The this binding of iteratee.
+ * @return Returns the new array of regrouped elements.
+ */
+ unzipWith<TArray, TResult>(
+ array: List<List<TArray>>,
+ iteratee?: MemoIterator<TArray, TResult>
+ ): TResult[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.unzipWith
+ */
+ unzipWith<TArr, TResult>(
+ iteratee?: MemoIterator<TArr, TResult>
+ ): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.unzipWith
+ */
+ unzipWith<TArr, TResult>(
+ iteratee?: MemoIterator<TArr, TResult>
+ ): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ //_.without
+ interface LoDashStatic {
+ /**
+ * Creates an array excluding all provided values using SameValueZero for equality comparisons.
+ *
+ * @param array The array to filter.
+ * @param values The values to exclude.
+ * @return Returns the new array of filtered values.
+ */
+ without<T>(
+ array: List<T>,
+ ...values: T[]
+ ): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.without
+ */
+ without(...values: T[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.without
+ */
+ without<T>(...values: T[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.without
+ */
+ without(...values: T[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.without
+ */
+ without<T>(...values: T[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.xor
+ interface LoDashStatic {
+ /**
+ * Creates an array of unique values that is the symmetric difference of the provided arrays.
+ *
+ * @param arrays The arrays to inspect.
+ * @return Returns the new array of values.
+ */
+ xor<T>(...arrays: List<T>[]): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.xor
+ */
+ xor(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.xor
+ */
+ xor<T>(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.xor
+ */
+ xor(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.xor
+ */
+ xor<T>(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.xorBy DUMMY
+ interface LoDashStatic {
+ /**
+ * This method is like `_.xor` except that it accepts `iteratee` which is
+ * invoked for each element of each `arrays` to generate the criterion by which
+ * uniqueness is computed. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {Array} Returns the new array of values.
+ * @example
+ *
+ * _.xorBy([2.1, 1.2], [4.3, 2.4], Math.floor);
+ * // => [1.2, 4.3]
+ *
+ * // using the `_.property` iteratee shorthand
+ * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
+ * // => [{ 'x': 2 }]
+ */
+ xorBy(
+ array: any[]|List<any>,
+ ...values: any[]
+ ): any[];
+ }
+
+ //_.xorWith DUMMY
+ interface LoDashStatic {
+ /**
+ * This method is like `_.xor` except that it accepts `comparator` which is
+ * invoked to compare elements of `arrays`. The comparator is invoked with
+ * two arguments: (arrVal, othVal).
+ *
+ * @static
+ * @memberOf _
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of values.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+ * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
+ *
+ * _.xorWith(objects, others, _.isEqual);
+ * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
+ */
+ xorWith(
+ array: any[]|List<any>,
+ ...values: any[]
+ ): any[];
+ }
+
+ //_.zip
+ interface LoDashStatic {
+ /**
+ * Creates an array of grouped elements, the first of which contains the first elements of the given arrays,
+ * the second of which contains the second elements of the given arrays, and so on.
+ *
+ * @param arrays The arrays to process.
+ * @return Returns the new array of grouped elements.
+ */
+ zip<T>(...arrays: List<T>[]): T[][];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.zip
+ */
+ zip<T>(...arrays: List<T>[]): _.LoDashImplicitArrayWrapper<T[]>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.zip
+ */
+ zip<T>(...arrays: List<T>[]): _.LoDashImplicitArrayWrapper<T[]>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.zip
+ */
+ zip<T>(...arrays: List<T>[]): _.LoDashExplicitArrayWrapper<T[]>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.zip
+ */
+ zip<T>(...arrays: List<T>[]): _.LoDashExplicitArrayWrapper<T[]>;
+ }
+
+ //_.zipObject
+ interface LoDashStatic {
+ /**
+ * The inverse of _.pairs; this method returns an object composed from arrays of property names and values.
+ * Provide either a single two dimensional array, e.g. [[key1, value1], [key2, value2]] or two arrays, one of
+ * property names and one of corresponding values.
+ *
+ * @param props The property names.
+ * @param values The property values.
+ * @return Returns the new object.
+ */
+ zipObject<TValues, TResult extends {}>(
+ props: List<StringRepresentable>|List<List<any>>,
+ values?: List<TValues>
+ ): TResult;
+
+ /**
+ * @see _.zipObject
+ */
+ zipObject<TResult extends {}>(
+ props: List<StringRepresentable>|List<List<any>>,
+ values?: List<any>
+ ): TResult;
+
+ /**
+ * @see _.zipObject
+ */
+ zipObject(
+ props: List<StringRepresentable>|List<List<any>>,
+ values?: List<any>
+ ): _.Dictionary<any>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.zipObject
+ */
+ zipObject<TValues, TResult extends {}>(
+ values?: List<TValues>
+ ): _.LoDashImplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.zipObject
+ */
+ zipObject<TResult extends {}>(
+ values?: List<any>
+ ): _.LoDashImplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.zipObject
+ */
+ zipObject(
+ values?: List<any>
+ ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.zipObject
+ */
+ zipObject<TValues, TResult extends {}>(
+ values?: List<TValues>
+ ): _.LoDashImplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.zipObject
+ */
+ zipObject<TResult extends {}>(
+ values?: List<any>
+ ): _.LoDashImplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.zipObject
+ */
+ zipObject(
+ values?: List<any>
+ ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.zipObject
+ */
+ zipObject<TValues, TResult extends {}>(
+ values?: List<TValues>
+ ): _.LoDashExplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.zipObject
+ */
+ zipObject<TResult extends {}>(
+ values?: List<any>
+ ): _.LoDashExplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.zipObject
+ */
+ zipObject(
+ values?: List<any>
+ ): _.LoDashExplicitObjectWrapper<_.Dictionary<any>>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.zipObject
+ */
+ zipObject<TValues, TResult extends {}>(
+ values?: List<TValues>
+ ): _.LoDashExplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.zipObject
+ */
+ zipObject<TResult extends {}>(
+ values?: List<any>
+ ): _.LoDashExplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.zipObject
+ */
+ zipObject(
+ values?: List<any>
+ ): _.LoDashExplicitObjectWrapper<_.Dictionary<any>>;
+ }
+
+ //_.zipWith
+ interface LoDashStatic {
+ /**
+ * This method is like _.zip except that it accepts an iteratee to specify how grouped values should be
+ * combined. The iteratee is bound to thisArg and invoked with four arguments: (accumulator, value, index,
+ * group).
+ * @param {...Array} [arrays] The arrays to process.
+ * @param {Function} [iteratee] The function to combine grouped values.
+ * @param {*} [thisArg] The `this` binding of `iteratee`.
+ * @return Returns the new array of grouped elements.
+ */
+ zipWith<TResult>(...args: any[]): TResult[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.zipWith
+ */
+ zipWith<TResult>(...args: any[]): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ /*********
+ * Chain *
+ *********/
+
+ //_.chain
+ interface LoDashStatic {
+ /**
+ * Creates a lodash object that wraps value with explicit method chaining enabled.
+ *
+ * @param value The value to wrap.
+ * @return Returns the new lodash wrapper instance.
+ */
+ chain(value: number): LoDashExplicitWrapper<number>;
+ chain(value: string): LoDashExplicitWrapper<string>;
+ chain(value: boolean): LoDashExplicitWrapper<boolean>;
+ chain<T>(value: T[]): LoDashExplicitArrayWrapper<T>;
+ chain<T extends {}>(value: T): LoDashExplicitObjectWrapper<T>;
+ chain(value: any): LoDashExplicitWrapper<any>;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.chain
+ */
+ chain(): LoDashExplicitWrapper<T>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.chain
+ */
+ chain(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.chain
+ */
+ chain(): LoDashExplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.chain
+ */
+ chain(): TWrapper;
+ }
+
+ //_.tap
+ interface LoDashStatic {
+ /**
+ * This method invokes interceptor and returns value. The interceptor is bound to thisArg and invoked with one
+ * argument; (value). The purpose of this method is to "tap into" a method chain in order to perform operations
+ * on intermediate results within the chain.
+ *
+ * @param value The value to provide to interceptor.
+ * @param interceptor The function to invoke.
+ * @parem thisArg The this binding of interceptor.
+ * @return Returns value.
+ **/
+ tap<T>(
+ value: T,
+ interceptor: (value: T) => void
+ ): T;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.tap
+ */
+ tap(
+ interceptor: (value: T) => void
+ ): TWrapper;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.tap
+ */
+ tap(
+ interceptor: (value: T) => void
+ ): TWrapper;
+ }
+
+ //_.thru
+ interface LoDashStatic {
+ /**
+ * This method is like _.tap except that it returns the result of interceptor.
+ *
+ * @param value The value to provide to interceptor.
+ * @param interceptor The function to invoke.
+ * @param thisArg The this binding of interceptor.
+ * @return Returns the result of interceptor.
+ */
+ thru<T, TResult>(
+ value: T,
+ interceptor: (value: T) => TResult
+ ): TResult;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.thru
+ */
+ thru<TResult extends number>(
+ interceptor: (value: T) => TResult): LoDashImplicitWrapper<TResult>;
+
+ /**
+ * @see _.thru
+ */
+ thru<TResult extends string>(
+ interceptor: (value: T) => TResult): LoDashImplicitWrapper<TResult>;
+
+ /**
+ * @see _.thru
+ */
+ thru<TResult extends boolean>(
+ interceptor: (value: T) => TResult): LoDashImplicitWrapper<TResult>;
+
+ /**
+ * @see _.thru
+ */
+ thru<TResult extends {}>(
+ interceptor: (value: T) => TResult): LoDashImplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.thru
+ */
+ thru<TResult>(
+ interceptor: (value: T) => TResult[]): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.thru
+ */
+ thru<TResult extends number>(
+ interceptor: (value: T) => TResult
+ ): LoDashExplicitWrapper<TResult>;
+
+ /**
+ * @see _.thru
+ */
+ thru<TResult extends string>(
+ interceptor: (value: T) => TResult
+ ): LoDashExplicitWrapper<TResult>;
+
+ /**
+ * @see _.thru
+ */
+ thru<TResult extends boolean>(
+ interceptor: (value: T) => TResult
+ ): LoDashExplicitWrapper<TResult>;
+
+ /**
+ * @see _.thru
+ */
+ thru<TResult extends {}>(
+ interceptor: (value: T) => TResult
+ ): LoDashExplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.thru
+ */
+ thru<TResult>(
+ interceptor: (value: T) => TResult[]
+ ): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ //_.prototype.commit
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * Executes the chained sequence and returns the wrapped result.
+ *
+ * @return Returns the new lodash wrapper instance.
+ */
+ commit(): TWrapper;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.commit
+ */
+ commit(): TWrapper;
+ }
+
+ //_.prototype.concat
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * Creates a new array joining a wrapped array with any additional arrays and/or values.
+ *
+ * @param items
+ * @return Returns the new concatenated array.
+ */
+ concat<TItem>(...items: Array<TItem|Array<TItem>>): LoDashImplicitArrayWrapper<TItem>;
+
+ /**
+ * @see _.concat
+ */
+ concat(...items: Array<T|Array<T>>): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.concat
+ */
+ concat<TItem>(...items: Array<TItem|Array<TItem>>): LoDashExplicitArrayWrapper<TItem>;
+
+ /**
+ * @see _.concat
+ */
+ concat(...items: Array<T|Array<T>>): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.prototype.plant
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * Creates a clone of the chained sequence planting value as the wrapped value.
+ * @param value The value to plant as the wrapped value.
+ * @return Returns the new lodash wrapper instance.
+ */
+ plant(value: number): LoDashImplicitWrapper<number>;
+
+ /**
+ * @see _.plant
+ */
+ plant(value: string): LoDashImplicitStringWrapper;
+
+ /**
+ * @see _.plant
+ */
+ plant(value: boolean): LoDashImplicitWrapper<boolean>;
+
+ /**
+ * @see _.plant
+ */
+ plant(value: number[]): LoDashImplicitNumberArrayWrapper;
+
+ /**
+ * @see _.plant
+ */
+ plant<T>(value: T[]): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.plant
+ */
+ plant<T extends {}>(value: T): LoDashImplicitObjectWrapper<T>;
+
+ /**
+ * @see _.plant
+ */
+ plant(value: any): LoDashImplicitWrapper<any>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.plant
+ */
+ plant(value: number): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.plant
+ */
+ plant(value: string): LoDashExplicitStringWrapper;
+
+ /**
+ * @see _.plant
+ */
+ plant(value: boolean): LoDashExplicitWrapper<boolean>;
+
+ /**
+ * @see _.plant
+ */
+ plant(value: number[]): LoDashExplicitNumberArrayWrapper;
+
+ /**
+ * @see _.plant
+ */
+ plant<T>(value: T[]): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.plant
+ */
+ plant<T extends {}>(value: T): LoDashExplicitObjectWrapper<T>;
+
+ /**
+ * @see _.plant
+ */
+ plant(value: any): LoDashExplicitWrapper<any>;
+ }
+
+ //_.prototype.reverse
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * Reverses the wrapped array so the first element becomes the last, the second element becomes the second to
+ * last, and so on.
+ *
+ * Note: This method mutates the wrapped array.
+ *
+ * @return Returns the new reversed lodash wrapper instance.
+ */
+ reverse(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.reverse
+ */
+ reverse(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.prototype.toJSON
+ interface LoDashWrapperBase<T, TWrapper> {
+ /**
+ * @see _.value
+ */
+ toJSON(): T;
+ }
+
+ //_.prototype.toString
+ interface LoDashWrapperBase<T, TWrapper> {
+ /**
+ * Produces the result of coercing the unwrapped value to a string.
+ *
+ * @return Returns the coerced string value.
+ */
+ toString(): string;
+ }
+
+ //_.prototype.value
+ interface LoDashWrapperBase<T, TWrapper> {
+ /**
+ * Executes the chained sequence to extract the unwrapped value.
+ *
+ * @alias _.toJSON, _.valueOf
+ *
+ * @return Returns the resolved unwrapped value.
+ */
+ value(): T;
+ }
+
+ //_.valueOf
+ interface LoDashWrapperBase<T, TWrapper> {
+ /**
+ * @see _.value
+ */
+ valueOf(): T;
+ }
+
+ /**************
+ * Collection *
+ **************/
+
+ //_.at
+ interface LoDashStatic {
+ /**
+ * Creates an array of elements corresponding to the given keys, or indexes, of collection. Keys may be
+ * specified as individual arguments or as arrays of keys.
+ *
+ * @param collection The collection to iterate over.
+ * @param props The property names or indexes of elements to pick, specified individually or in arrays.
+ * @return Returns the new array of picked elements.
+ */
+ at<T>(
+ collection: List<T>|Dictionary<T>,
+ ...props: (number|string|(number|string)[])[]
+ ): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.at
+ */
+ at(...props: (number|string|(number|string)[])[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.at
+ */
+ at<T>(...props: (number|string|(number|string)[])[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.at
+ */
+ at(...props: (number|string|(number|string)[])[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.at
+ */
+ at<T>(...props: (number|string|(number|string)[])[]): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.countBy
+ interface LoDashStatic {
+ /**
+ * Creates an object composed of keys generated from the results of running each element of collection through
+ * iteratee. The corresponding value of each key is the number of times the key was returned by iteratee. The
+ * iteratee is bound to thisArg and invoked with three arguments:
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for iteratee the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for iteratee the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * @param collection The collection to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @param thisArg The this binding of iteratee.
+ * @return Returns the composed aggregate object.
+ */
+ countBy<T>(
+ collection: List<T>,
+ iteratee?: ListIterator<T, any>
+ ): Dictionary<number>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy<T>(
+ collection: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, any>
+ ): Dictionary<number>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy<T>(
+ collection: NumericDictionary<T>,
+ iteratee?: NumericDictionaryIterator<T, any>
+ ): Dictionary<number>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy<T>(
+ collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+ iteratee?: string
+ ): Dictionary<number>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy<W, T>(
+ collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+ iteratee?: W
+ ): Dictionary<number>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy<T>(
+ collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+ iteratee?: Object
+ ): Dictionary<number>;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.countBy
+ */
+ countBy(
+ iteratee?: ListIterator<T, any>
+ ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.countBy
+ */
+ countBy(
+ iteratee?: ListIterator<T, any>
+ ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy(
+ iteratee?: string
+ ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy<W>(
+ iteratee?: W
+ ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.countBy
+ */
+ countBy<T>(
+ iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>|NumericDictionaryIterator<T, any>
+ ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy(
+ iteratee?: string
+ ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy<W>(
+ iteratee?: W
+ ): LoDashImplicitObjectWrapper<Dictionary<number>>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.countBy
+ */
+ countBy(
+ iteratee?: ListIterator<T, any>
+ ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.countBy
+ */
+ countBy(
+ iteratee?: ListIterator<T, any>
+ ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy(
+ iteratee?: string
+ ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy<W>(
+ iteratee?: W
+ ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.countBy
+ */
+ countBy<T>(
+ iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>|NumericDictionaryIterator<T, any>
+ ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy(
+ iteratee?: string
+ ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+
+ /**
+ * @see _.countBy
+ */
+ countBy<W>(
+ iteratee?: W
+ ): LoDashExplicitObjectWrapper<Dictionary<number>>;
+ }
+
+ //_.each
+ interface LoDashStatic {
+ /**
+ * @see _.forEach
+ */
+ each<T>(
+ collection: T[],
+ iteratee?: ListIterator<T, any>
+ ): T[];
+
+ /**
+ * @see _.forEach
+ */
+ each<T>(
+ collection: List<T>,
+ iteratee?: ListIterator<T, any>
+ ): List<T>;
+
+ /**
+ * @see _.forEach
+ */
+ each<T>(
+ collection: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, any>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.forEach
+ */
+ each<T extends {}>(
+ collection: T,
+ iteratee?: ObjectIterator<any, any>
+ ): T;
+
+ /**
+ * @see _.forEach
+ */
+ each<T extends {}, TValue>(
+ collection: T,
+ iteratee?: ObjectIterator<TValue, any>
+ ): T;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.forEach
+ */
+ each(
+ iteratee: ListIterator<string, any>
+ ): LoDashImplicitWrapper<string>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.forEach
+ */
+ each(
+ iteratee: ListIterator<T, any>
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.forEach
+ */
+ each<TValue>(
+ iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>
+ ): LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.forEach
+ */
+ each(
+ iteratee: ListIterator<string, any>
+ ): LoDashExplicitWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.forEach
+ */
+ each(
+ iteratee: ListIterator<T, any>
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.forEach
+ */
+ each<TValue>(
+ iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>
+ ): LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.eachRight
+ interface LoDashStatic {
+ /**
+ * @see _.forEachRight
+ */
+ eachRight<T>(
+ collection: T[],
+ iteratee?: ListIterator<T, any>
+ ): T[];
+
+ /**
+ * @see _.forEachRight
+ */
+ eachRight<T>(
+ collection: List<T>,
+ iteratee?: ListIterator<T, any>
+ ): List<T>;
+
+ /**
+ * @see _.forEachRight
+ */
+ eachRight<T>(
+ collection: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, any>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.forEachRight
+ */
+ eachRight<T extends {}>(
+ collection: T,
+ iteratee?: ObjectIterator<any, any>
+ ): T;
+
+ /**
+ * @see _.forEachRight
+ */
+ eachRight<T extends {}, TValue>(
+ collection: T,
+ iteratee?: ObjectIterator<TValue, any>
+ ): T;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.forEachRight
+ */
+ eachRight(
+ iteratee: ListIterator<string, any>
+ ): LoDashImplicitWrapper<string>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.forEachRight
+ */
+ eachRight(
+ iteratee: ListIterator<T, any>
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.forEachRight
+ */
+ eachRight<TValue>(
+ iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>
+ ): LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.forEachRight
+ */
+ eachRight(
+ iteratee: ListIterator<string, any>
+ ): LoDashExplicitWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.forEachRight
+ */
+ eachRight(
+ iteratee: ListIterator<T, any>
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.forEachRight
+ */
+ eachRight<TValue>(
+ iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>
+ ): LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.every
+ interface LoDashStatic {
+ /**
+ * Checks if predicate returns truthy for all elements of collection. Iteration is stopped once predicate
+ * returns falsey. The predicate is invoked with three arguments: (value, index|key, collection).
+ *
+ * @param collection The collection to iterate over.
+ * @param predicate The function invoked per iteration.
+ * @return Returns true if all elements pass the predicate check, else false.
+ */
+ every<T>(
+ collection: List<T>,
+ predicate?: ListIterator<T, boolean>
+ ): boolean;
+
+ /**
+ * @see _.every
+ */
+ every<T>(
+ collection: Dictionary<T>,
+ predicate?: DictionaryIterator<T, boolean>
+ ): boolean;
+
+ /**
+ * @see _.every
+ */
+ every<T>(
+ collection: NumericDictionary<T>,
+ predicate?: NumericDictionaryIterator<T, boolean>
+ ): boolean;
+
+ /**
+ * @see _.every
+ */
+ every<T>(
+ collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+ predicate?: string|any[]
+ ): boolean;
+
+ /**
+ * @see _.every
+ */
+ every<TObject extends {}, T>(
+ collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+ predicate?: TObject
+ ): boolean;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.every
+ */
+ every(
+ predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean>
+ ): boolean;
+
+ /**
+ * @see _.every
+ */
+ every(
+ predicate?: string|any[]
+ ): boolean;
+
+ /**
+ * @see _.every
+ */
+ every<TObject extends {}>(
+ predicate?: TObject
+ ): boolean;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.every
+ */
+ every<TResult>(
+ predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean>
+ ): boolean;
+
+ /**
+ * @see _.every
+ */
+ every(
+ predicate?: string|any[]
+ ): boolean;
+
+ /**
+ * @see _.every
+ */
+ every<TObject extends {}>(
+ predicate?: TObject
+ ): boolean;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.every
+ */
+ every(
+ predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean>
+ ): LoDashExplicitWrapper<boolean>;
+
+ /**
+ * @see _.every
+ */
+ every(
+ predicate?: string|any[]
+ ): LoDashExplicitWrapper<boolean>;
+
+ /**
+ * @see _.every
+ */
+ every<TObject extends {}>(
+ predicate?: TObject
+ ): LoDashExplicitWrapper<boolean>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.every
+ */
+ every<TResult>(
+ predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean>
+ ): LoDashExplicitWrapper<boolean>;
+
+ /**
+ * @see _.every
+ */
+ every(
+ predicate?: string|any[]
+ ): LoDashExplicitWrapper<boolean>;
+
+ /**
+ * @see _.every
+ */
+ every<TObject extends {}>(
+ predicate?: TObject
+ ): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.filter
+ interface LoDashStatic {
+ /**
+ * Iterates over elements of collection, returning an array of all elements predicate returns truthy for. The
+ * predicate is bound to thisArg and invoked with three arguments: (value, index|key, collection).
+ *
+ * If a property name is provided for predicate the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for predicate the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * @param collection The collection to iterate over.
+ * @param predicate The function invoked per iteration.
+ * @param thisArg The this binding of predicate.
+ * @return Returns the new filtered array.
+ */
+ filter<T>(
+ collection: List<T>,
+ predicate?: ListIterator<T, boolean>
+ ): T[];
+
+ /**
+ * @see _.filter
+ */
+ filter<T>(
+ collection: Dictionary<T>,
+ predicate?: DictionaryIterator<T, boolean>
+ ): T[];
+
+ /**
+ * @see _.filter
+ */
+ filter(
+ collection: string,
+ predicate?: StringIterator<boolean>
+ ): string[];
+
+ /**
+ * @see _.filter
+ */
+ filter<T>(
+ collection: List<T>|Dictionary<T>,
+ predicate: string
+ ): T[];
+
+ /**
+ * @see _.filter
+ */
+ filter<W extends {}, T>(
+ collection: List<T>|Dictionary<T>,
+ predicate: W
+ ): T[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.filter
+ */
+ filter(
+ predicate?: StringIterator<boolean>
+ ): LoDashImplicitArrayWrapper<string>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.filter
+ */
+ filter(
+ predicate: ListIterator<T, boolean>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.filter
+ */
+ filter(
+ predicate: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.filter
+ */
+ filter<W>(predicate: W): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.filter
+ */
+ filter<T>(
+ predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.filter
+ */
+ filter<T>(
+ predicate: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.filter
+ */
+ filter<W, T>(predicate: W): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.filter
+ */
+ filter(
+ predicate?: StringIterator<boolean>
+ ): LoDashExplicitArrayWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.filter
+ */
+ filter(
+ predicate: ListIterator<T, boolean>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.filter
+ */
+ filter(
+ predicate: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.filter
+ */
+ filter<W>(predicate: W): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.filter
+ */
+ filter<T>(
+ predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.filter
+ */
+ filter<T>(
+ predicate: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.filter
+ */
+ filter<W, T>(predicate: W): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.find
+ interface LoDashStatic {
+ /**
+ * Iterates over elements of collection, returning the first element predicate returns truthy for.
+ * The predicate is bound to thisArg and invoked with three arguments: (value, index|key, collection).
+ *
+ * If a property name is provided for predicate the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for predicate the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * @param collection The collection to search.
+ * @param predicate The function invoked per iteration.
+ * @param fromIndex The index to search from.
+ * @return Returns the matched element, else undefined.
+ */
+ find<T>(
+ collection: List<T>,
+ predicate?: ListIterator<T, boolean>,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ */
+ find<T>(
+ collection: Dictionary<T>,
+ predicate?: DictionaryIterator<T, boolean>,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ */
+ find<T>(
+ collection: List<T>|Dictionary<T>,
+ predicate?: string,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ */
+ find<TObject extends {}, T>(
+ collection: List<T>|Dictionary<T>,
+ predicate?: TObject,
+ fromIndex?: number
+ ): T;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.find
+ */
+ find(
+ predicate?: ListIterator<T, boolean>,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ */
+ find(
+ predicate?: string,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ */
+ find<TObject extends {}>(
+ predicate?: TObject,
+ fromIndex?: number
+ ): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.find
+ */
+ find<TResult>(
+ predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>,
+ fromIndex?: number
+ ): TResult;
+
+ /**
+ * @see _.find
+ */
+ find<TResult>(
+ predicate?: string,
+ fromIndex?: number
+ ): TResult;
+
+ /**
+ * @see _.find
+ */
+ find<TObject extends {}, TResult>(
+ predicate?: TObject,
+ fromIndex?: number
+ ): TResult;
+ }
+
+ //_.findLast
+ interface LoDashStatic {
+ /**
+ * This method is like _.find except that it iterates over elements of a collection from
+ * right to left.
+ * @param collection Searches for a value in this list.
+ * @param callback The function called per iteration.
+ * @param fromIndex The index to search from.
+ * @return The found element, else undefined.
+ **/
+ findLast<T>(
+ collection: Array<T>,
+ callback: ListIterator<T, boolean>,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ **/
+ findLast<T>(
+ collection: List<T>,
+ callback: ListIterator<T, boolean>,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ **/
+ findLast<T>(
+ collection: Dictionary<T>,
+ callback: DictionaryIterator<T, boolean>,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ * @param _.pluck style callback
+ **/
+ findLast<W, T>(
+ collection: Array<T>,
+ whereValue: W,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ * @param _.pluck style callback
+ **/
+ findLast<W, T>(
+ collection: List<T>,
+ whereValue: W,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ * @param _.pluck style callback
+ **/
+ findLast<W, T>(
+ collection: Dictionary<T>,
+ whereValue: W,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ * @param _.where style callback
+ **/
+ findLast<T>(
+ collection: Array<T>,
+ pluckValue: string,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ * @param _.where style callback
+ **/
+ findLast<T>(
+ collection: List<T>,
+ pluckValue: string,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.find
+ * @param _.where style callback
+ **/
+ findLast<T>(
+ collection: Dictionary<T>,
+ pluckValue: string,
+ fromIndex?: number
+ ): T;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.findLast
+ */
+ findLast(
+ callback: ListIterator<T, boolean>,
+ fromIndex?: number
+ ): T;
+ /**
+ * @see _.findLast
+ * @param _.where style callback
+ */
+ findLast<W>(
+ whereValue: W,
+ fromIndex?: number
+ ): T;
+
+ /**
+ * @see _.findLast
+ * @param _.where style callback
+ */
+ findLast(
+ pluckValue: string,
+ fromIndex?: number
+ ): T;
+ }
+
+ //_.flatMap
+ interface LoDashStatic {
+ /**
+ * Creates an array of flattened values by running each element in collection through iteratee
+ * and concating its result to the other mapped values. The iteratee is invoked with three arguments:
+ * (value, index|key, collection).
+ *
+ * @param collection The collection to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @return Returns the new flattened array.
+ */
+ flatMap<T, TResult>(
+ collection: List<T>,
+ iteratee?: ListIterator<T, TResult|TResult[]>
+ ): TResult[];
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(
+ collection: List<any>,
+ iteratee?: ListIterator<any, TResult|TResult[]>
+ ): TResult[];
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<T, TResult>(
+ collection: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, TResult|TResult[]>
+ ): TResult[];
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(
+ collection: Dictionary<any>,
+ iteratee?: DictionaryIterator<any, TResult|TResult[]>
+ ): TResult[];
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<T, TResult>(
+ collection: NumericDictionary<T>,
+ iteratee?: NumericDictionaryIterator<T, TResult|TResult[]>
+ ): TResult[];
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(
+ collection: NumericDictionary<any>,
+ iteratee?: NumericDictionaryIterator<any, TResult|TResult[]>
+ ): TResult[];
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TObject extends Object, TResult>(
+ collection: TObject,
+ iteratee?: ObjectIterator<any, TResult|TResult[]>
+ ): TResult[];
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(
+ collection: Object,
+ iteratee?: ObjectIterator<any, TResult|TResult[]>
+ ): TResult[];
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TWhere extends Object, TObject extends Object>(
+ collection: TObject,
+ iteratee: TWhere
+ ): boolean[];
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TObject extends Object, TResult>(
+ collection: TObject,
+ iteratee: Object|string
+ ): TResult[];
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TObject extends Object>(
+ collection: TObject,
+ iteratee: [string, any]
+ ): boolean[];
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(
+ collection: string
+ ): string[];
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(
+ collection: Object,
+ iteratee?: Object|string
+ ): TResult[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(
+ iteratee: ListIterator<string, TResult|TResult[]>
+ ): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap(): LoDashImplicitArrayWrapper<string>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(
+ iteratee: ListIterator<T, TResult|TResult[]>|string
+ ): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TWhere extends Object>(
+ iteratee: TWhere
+ ): LoDashImplicitArrayWrapper<boolean>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap(
+ iteratee: [string, any]
+ ): LoDashImplicitArrayWrapper<boolean>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.flatMap
+ */
+ flatMap<T, TResult>(
+ iteratee: ListIterator<T, TResult|TResult[]>|DictionaryIterator<T, TResult|TResult[]>|NumericDictionaryIterator<T, TResult|TResult[]>
+ ): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(
+ iteratee: ObjectIterator<any, TResult|TResult[]>|string
+ ): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TWhere extends Object>(
+ iteratee: TWhere
+ ): LoDashImplicitArrayWrapper<boolean>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap(
+ iteratee: [string, any]
+ ): LoDashImplicitArrayWrapper<boolean>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(
+ iteratee: ListIterator<string, TResult|TResult[]>
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap(): LoDashExplicitArrayWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(
+ iteratee: ListIterator<T, TResult|TResult[]>|string
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TWhere extends Object>(
+ iteratee: TWhere
+ ): LoDashExplicitArrayWrapper<boolean>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap(
+ iteratee: [string, any]
+ ): LoDashExplicitArrayWrapper<boolean>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.flatMap
+ */
+ flatMap<T, TResult>(
+ iteratee: ListIterator<T, TResult|TResult[]>|DictionaryIterator<T, TResult|TResult[]>|NumericDictionaryIterator<T, TResult|TResult[]>
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(
+ iteratee: ObjectIterator<any, TResult|TResult[]>|string
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TWhere extends Object>(
+ iteratee: TWhere
+ ): LoDashExplicitArrayWrapper<boolean>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap(
+ iteratee: [string, any]
+ ): LoDashExplicitArrayWrapper<boolean>;
+
+ /**
+ * @see _.flatMap
+ */
+ flatMap<TResult>(): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ //_.forEach
+ interface LoDashStatic {
+ /**
+ * Iterates over elements of collection invoking iteratee for each element. The iteratee is bound to thisArg
+ * and invoked with three arguments:
+ * (value, index|key, collection). Iteratee functions may exit iteration early by explicitly returning false.
+ *
+ * Note: As with other "Collections" methods, objects with a "length" property are iterated like arrays. To
+ * avoid this behavior _.forIn or _.forOwn may be used for object iteration.
+ *
+ * @alias _.each
+ *
+ * @param collection The collection to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @param thisArg The this binding of iteratee.
+ */
+ forEach<T>(
+ collection: T[],
+ iteratee?: ListIterator<T, any>
+ ): T[];
+
+ /**
+ * @see _.forEach
+ */
+ forEach<T>(
+ collection: List<T>,
+ iteratee?: ListIterator<T, any>
+ ): List<T>;
+
+ /**
+ * @see _.forEach
+ */
+ forEach<T>(
+ collection: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, any>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.forEach
+ */
+ forEach<T extends {}>(
+ collection: T,
+ iteratee?: ObjectIterator<any, any>
+ ): T;
+
+ /**
+ * @see _.forEach
+ */
+ forEach<T extends {}, TValue>(
+ collection: T,
+ iteratee?: ObjectIterator<TValue, any>
+ ): T;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.forEach
+ */
+ forEach(
+ iteratee: ListIterator<string, any>
+ ): LoDashImplicitWrapper<string>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.forEach
+ */
+ forEach(
+ iteratee: ListIterator<T, any>
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.forEach
+ */
+ forEach<TValue>(
+ iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>
+ ): LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.forEach
+ */
+ forEach(
+ iteratee: ListIterator<string, any>
+ ): LoDashExplicitWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.forEach
+ */
+ forEach(
+ iteratee: ListIterator<T, any>
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.forEach
+ */
+ forEach<TValue>(
+ iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>
+ ): LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.forEachRight
+ interface LoDashStatic {
+ /**
+ * This method is like _.forEach except that it iterates over elements of collection from right to left.
+ *
+ * @alias _.eachRight
+ *
+ * @param collection The collection to iterate over.
+ * @param iteratee The function called per iteration.
+ * @param thisArg The this binding of callback.
+ */
+ forEachRight<T>(
+ collection: T[],
+ iteratee?: ListIterator<T, any>
+ ): T[];
+
+ /**
+ * @see _.forEachRight
+ */
+ forEachRight<T>(
+ collection: List<T>,
+ iteratee?: ListIterator<T, any>
+ ): List<T>;
+
+ /**
+ * @see _.forEachRight
+ */
+ forEachRight<T>(
+ collection: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, any>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.forEachRight
+ */
+ forEachRight<T extends {}>(
+ collection: T,
+ iteratee?: ObjectIterator<any, any>
+ ): T;
+
+ /**
+ * @see _.forEachRight
+ */
+ forEachRight<T extends {}, TValue>(
+ collection: T,
+ iteratee?: ObjectIterator<TValue, any>
+ ): T;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.forEachRight
+ */
+ forEachRight(
+ iteratee: ListIterator<string, any>
+ ): LoDashImplicitWrapper<string>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.forEachRight
+ */
+ forEachRight(
+ iteratee: ListIterator<T, any>
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.forEachRight
+ */
+ forEachRight<TValue>(
+ iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>
+ ): LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.forEachRight
+ */
+ forEachRight(
+ iteratee: ListIterator<string, any>
+ ): LoDashExplicitWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.forEachRight
+ */
+ forEachRight(
+ iteratee: ListIterator<T, any>
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.forEachRight
+ */
+ forEachRight<TValue>(
+ iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any>
+ ): LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.groupBy
+ interface LoDashStatic {
+ /**
+ * Creates an object composed of keys generated from the results of running each element of collection through
+ * iteratee. The corresponding value of each key is an array of the elements responsible for generating the
+ * key. The iteratee is bound to thisArg and invoked with three arguments:
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for iteratee the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for iteratee the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * @param collection The collection to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @param thisArg The this binding of iteratee.
+ * @return Returns the composed aggregate object.
+ */
+ groupBy<T, TKey>(
+ collection: List<T>,
+ iteratee?: ListIterator<T, TKey>
+ ): Dictionary<T[]>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T>(
+ collection: List<any>,
+ iteratee?: ListIterator<T, any>
+ ): Dictionary<T[]>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T, TKey>(
+ collection: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, TKey>
+ ): Dictionary<T[]>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T>(
+ collection: Dictionary<any>,
+ iteratee?: DictionaryIterator<T, any>
+ ): Dictionary<T[]>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T, TValue>(
+ collection: List<T>|Dictionary<T>,
+ iteratee?: string
+ ): Dictionary<T[]>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T>(
+ collection: List<T>|Dictionary<T>,
+ iteratee?: string
+ ): Dictionary<T[]>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<TWhere, T>(
+ collection: List<T>|Dictionary<T>,
+ iteratee?: TWhere
+ ): Dictionary<T[]>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T>(
+ collection: List<T>|Dictionary<T>,
+ iteratee?: Object
+ ): Dictionary<T[]>;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.groupBy
+ */
+ groupBy<TKey>(
+ iteratee?: ListIterator<T, TKey>
+ ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.groupBy
+ */
+ groupBy<TKey>(
+ iteratee?: ListIterator<T, TKey>
+ ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<TValue>(
+ iteratee?: string
+ ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<TWhere>(
+ iteratee?: TWhere
+ ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T, TKey>(
+ iteratee?: ListIterator<T, TKey>|DictionaryIterator<T, TKey>
+ ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T>(
+ iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>
+ ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T, TValue>(
+ iteratee?: string
+ ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T>(
+ iteratee?: string
+ ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<TWhere, T>(
+ iteratee?: TWhere
+ ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T>(
+ iteratee?: Object
+ ): LoDashImplicitObjectWrapper<Dictionary<T[]>>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.groupBy
+ */
+ groupBy<TKey>(
+ iteratee?: ListIterator<T, TKey>
+ ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.groupBy
+ */
+ groupBy<TKey>(
+ iteratee?: ListIterator<T, TKey>
+ ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<TValue>(
+ iteratee?: string
+ ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<TWhere>(
+ iteratee?: TWhere
+ ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T, TKey>(
+ iteratee?: ListIterator<T, TKey>|DictionaryIterator<T, TKey>
+ ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T>(
+ iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>
+ ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T, TValue>(
+ iteratee?: string
+ ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T>(
+ iteratee?: string
+ ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<TWhere, T>(
+ iteratee?: TWhere
+ ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+
+ /**
+ * @see _.groupBy
+ */
+ groupBy<T>(
+ iteratee?: Object
+ ): LoDashExplicitObjectWrapper<Dictionary<T[]>>;
+ }
+
+ //_.includes
+ interface LoDashStatic {
+ /**
+ * Checks if target is in collection using SameValueZero for equality comparisons. If fromIndex is negative,
+ * it’s used as the offset from the end of collection.
+ *
+ * @param collection The collection to search.
+ * @param target The value to search for.
+ * @param fromIndex The index to search from.
+ * @return True if the target element is found, else false.
+ */
+ includes<T>(
+ collection: List<T>|Dictionary<T>,
+ target: T,
+ fromIndex?: number
+ ): boolean;
+
+ /**
+ * @see _.includes
+ */
+ includes(
+ collection: string,
+ target: string,
+ fromIndex?: number
+ ): boolean;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.includes
+ */
+ includes(
+ target: T,
+ fromIndex?: number
+ ): boolean;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.includes
+ */
+ includes<TValue>(
+ target: TValue,
+ fromIndex?: number
+ ): boolean;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.includes
+ */
+ includes(
+ target: string,
+ fromIndex?: number
+ ): boolean;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.includes
+ */
+ includes(
+ target: T,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<boolean>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.includes
+ */
+ includes<TValue>(
+ target: TValue,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<boolean>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.includes
+ */
+ includes(
+ target: string,
+ fromIndex?: number
+ ): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.keyBy
+ interface LoDashStatic {
+ /**
+ * Creates an object composed of keys generated from the results of running each element of collection through
+ * iteratee. The corresponding value of each key is the last element responsible for generating the key. The
+ * iteratee function is bound to thisArg and invoked with three arguments:
+ * (value, index|key, collection).
+ *
+ * If a property name is provided for iteratee the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for iteratee the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * @param collection The collection to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @param thisArg The this binding of iteratee.
+ * @return Returns the composed aggregate object.
+ */
+ keyBy<T>(
+ collection: List<T>,
+ iteratee?: ListIterator<T, any>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<T>(
+ collection: NumericDictionary<T>,
+ iteratee?: NumericDictionaryIterator<T, any>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<T>(
+ collection: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, any>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<T>(
+ collection: List<T>|NumericDictionary<T>|Dictionary<T>,
+ iteratee?: string
+ ): Dictionary<T>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<W extends Object, T>(
+ collection: List<T>|NumericDictionary<T>|Dictionary<T>,
+ iteratee?: W
+ ): Dictionary<T>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<T>(
+ collection: List<T>|NumericDictionary<T>|Dictionary<T>,
+ iteratee?: Object
+ ): Dictionary<T>;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.keyBy
+ */
+ keyBy(
+ iteratee?: ListIterator<T, any>
+ ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.keyBy
+ */
+ keyBy(
+ iteratee?: ListIterator<T, any>
+ ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy(
+ iteratee?: string
+ ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<W extends Object>(
+ iteratee?: W
+ ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.keyBy
+ */
+ keyBy<T>(
+ iteratee?: ListIterator<T, any>|NumericDictionaryIterator<T, any>|DictionaryIterator<T, any>
+ ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<T>(
+ iteratee?: string
+ ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<W extends Object, T>(
+ iteratee?: W
+ ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<T>(
+ iteratee?: Object
+ ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.keyBy
+ */
+ keyBy(
+ iteratee?: ListIterator<T, any>
+ ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.keyBy
+ */
+ keyBy(
+ iteratee?: ListIterator<T, any>
+ ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy(
+ iteratee?: string
+ ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<W extends Object>(
+ iteratee?: W
+ ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.keyBy
+ */
+ keyBy<T>(
+ iteratee?: ListIterator<T, any>|NumericDictionaryIterator<T, any>|DictionaryIterator<T, any>
+ ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<T>(
+ iteratee?: string
+ ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<W extends Object, T>(
+ iteratee?: W
+ ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.keyBy
+ */
+ keyBy<T>(
+ iteratee?: Object
+ ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+ }
+
+ //_.invoke
+ interface LoDashStatic {
+ /**
+ * Invokes the method at path of object.
+ * @param object The object to query.
+ * @param path The path of the method to invoke.
+ * @param args The arguments to invoke the method with.
+ **/
+ invoke<TObject extends Object, TResult>(
+ object: TObject,
+ path: StringRepresentable|StringRepresentable[],
+ ...args: any[]): TResult;
+
+ /**
+ * @see _.invoke
+ **/
+ invoke<TValue, TResult>(
+ object: Dictionary<TValue>|TValue[],
+ path: StringRepresentable|StringRepresentable[],
+ ...args: any[]): TResult;
+
+ /**
+ * @see _.invoke
+ **/
+ invoke<TResult>(
+ object: any,
+ path: StringRepresentable|StringRepresentable[],
+ ...args: any[]): TResult;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.invoke
+ **/
+ invoke<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ ...args: any[]): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.invoke
+ **/
+ invoke<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ ...args: any[]): TResult;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.invoke
+ **/
+ invoke<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ ...args: any[]): TResult;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.invoke
+ **/
+ invoke<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ ...args: any[]): TResult;
+ }
+
+ //_.invokeMap
+ interface LoDashStatic {
+ /**
+ * Invokes the method named by methodName on each element in the collection returning
+ * an array of the results of each invoked method. Additional arguments will be provided
+ * to each invoked method. If methodName is a function it will be invoked for, and this
+ * bound to, each element in the collection.
+ * @param collection The collection to iterate over.
+ * @param methodName The name of the method to invoke.
+ * @param args Arguments to invoke the method with.
+ **/
+ invokeMap<TValue extends {}, TResult>(
+ collection: TValue[],
+ methodName: string,
+ ...args: any[]): TResult[];
+
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TValue extends {}, TResult>(
+ collection: Dictionary<TValue>,
+ methodName: string,
+ ...args: any[]): TResult[];
+
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TResult>(
+ collection: {}[],
+ methodName: string,
+ ...args: any[]): TResult[];
+
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TResult>(
+ collection: Dictionary<{}>,
+ methodName: string,
+ ...args: any[]): TResult[];
+
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TValue extends {}, TResult>(
+ collection: TValue[],
+ method: (...args: any[]) => TResult,
+ ...args: any[]): TResult[];
+
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TValue extends {}, TResult>(
+ collection: Dictionary<TValue>,
+ method: (...args: any[]) => TResult,
+ ...args: any[]): TResult[];
+
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TResult>(
+ collection: {}[],
+ method: (...args: any[]) => TResult,
+ ...args: any[]): TResult[];
+
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TResult>(
+ collection: Dictionary<{}>,
+ method: (...args: any[]) => TResult,
+ ...args: any[]): TResult[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TResult>(
+ methodName: string,
+ ...args: any[]): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TResult>(
+ method: (...args: any[]) => TResult,
+ ...args: any[]): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TResult>(
+ methodName: string,
+ ...args: any[]): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TResult>(
+ method: (...args: any[]) => TResult,
+ ...args: any[]): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TResult>(
+ methodName: string,
+ ...args: any[]): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TResult>(
+ method: (...args: any[]) => TResult,
+ ...args: any[]): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TResult>(
+ methodName: string,
+ ...args: any[]): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.invokeMap
+ **/
+ invokeMap<TResult>(
+ method: (...args: any[]) => TResult,
+ ...args: any[]): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ //_.map
+ interface LoDashStatic {
+ /**
+ * Creates an array of values by running each element in collection through iteratee. The iteratee is bound to
+ * thisArg and invoked with three arguments: (value, index|key, collection).
+ *
+ * If a property name is provided for iteratee the created _.property style callback returns the property value
+ * of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for iteratee the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * Many lodash methods are guarded to work as iteratees for methods like _.every, _.filter, _.map, _.mapValues,
+ * _.reject, and _.some.
+ *
+ * The guarded methods are:
+ * ary, callback, chunk, clone, create, curry, curryRight, drop, dropRight, every, fill, flatten, invert, max,
+ * min, parseInt, slice, sortBy, take, takeRight, template, trim, trimLeft, trimRight, trunc, random, range,
+ * sample, some, sum, uniq, and words
+ *
+ * @param collection The collection to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @param thisArg The this binding of iteratee.
+ * @return Returns the new mapped array.
+ */
+ map<T, TResult>(
+ collection: List<T>,
+ iteratee?: ListIterator<T, TResult>
+ ): TResult[];
+
+ /**
+ * @see _.map
+ */
+ map<T extends {}, TResult>(
+ collection: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, TResult>
+ ): TResult[];
+
+ map<T extends {}, TResult>(
+ collection: NumericDictionary<T>,
+ iteratee?: NumericDictionaryIterator<T, TResult>
+ ): TResult[];
+
+ /**
+ * @see _.map
+ */
+ map<T, TResult>(
+ collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+ iteratee?: string
+ ): TResult[];
+
+ /**
+ * @see _.map
+ */
+ map<T, TObject extends {}>(
+ collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+ iteratee?: TObject
+ ): boolean[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.map
+ */
+ map<TResult>(
+ iteratee?: ListIterator<T, TResult>
+ ): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.map
+ */
+ map<TResult>(
+ iteratee?: string
+ ): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.map
+ */
+ map<TObject extends {}>(
+ iteratee?: TObject
+ ): LoDashImplicitArrayWrapper<boolean>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.map
+ */
+ map<TValue, TResult>(
+ iteratee?: ListIterator<TValue, TResult>|DictionaryIterator<TValue, TResult>
+ ): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.map
+ */
+ map<TValue, TResult>(
+ iteratee?: string
+ ): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.map
+ */
+ map<TObject extends {}>(
+ iteratee?: TObject
+ ): LoDashImplicitArrayWrapper<boolean>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.map
+ */
+ map<TResult>(
+ iteratee?: ListIterator<T, TResult>
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.map
+ */
+ map<TResult>(
+ iteratee?: string
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.map
+ */
+ map<TObject extends {}>(
+ iteratee?: TObject
+ ): LoDashExplicitArrayWrapper<boolean>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.map
+ */
+ map<TValue, TResult>(
+ iteratee?: ListIterator<TValue, TResult>|DictionaryIterator<TValue, TResult>
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.map
+ */
+ map<TValue, TResult>(
+ iteratee?: string
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.map
+ */
+ map<TObject extends {}>(
+ iteratee?: TObject
+ ): LoDashExplicitArrayWrapper<boolean>;
+ }
+
+ //_.partition
+ interface LoDashStatic {
+ /**
+ * Creates an array of elements split into two groups, the first of which contains elements predicate returns truthy for,
+ * while the second of which contains elements predicate returns falsey for.
+ * The predicate is bound to thisArg and invoked with three arguments: (value, index|key, collection).
+ *
+ * If a property name is provided for predicate the created _.property style callback
+ * returns the property value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback
+ * returns true for elements that have a matching property value, else false.
+ *
+ * If an object is provided for predicate the created _.matches style callback returns
+ * true for elements that have the properties of the given object, else false.
+ *
+ * @param collection The collection to iterate over.
+ * @param callback The function called per iteration.
+ * @param thisArg The this binding of predicate.
+ * @return Returns the array of grouped elements.
+ **/
+ partition<T>(
+ collection: List<T>,
+ callback: ListIterator<T, boolean>): T[][];
+
+ /**
+ * @see _.partition
+ **/
+ partition<T>(
+ collection: Dictionary<T>,
+ callback: DictionaryIterator<T, boolean>): T[][];
+
+ /**
+ * @see _.partition
+ **/
+ partition<W, T>(
+ collection: List<T>,
+ whereValue: W): T[][];
+
+ /**
+ * @see _.partition
+ **/
+ partition<W, T>(
+ collection: Dictionary<T>,
+ whereValue: W): T[][];
+
+ /**
+ * @see _.partition
+ **/
+ partition<T>(
+ collection: List<T>,
+ path: string,
+ srcValue: any): T[][];
+
+ /**
+ * @see _.partition
+ **/
+ partition<T>(
+ collection: Dictionary<T>,
+ path: string,
+ srcValue: any): T[][];
+
+ /**
+ * @see _.partition
+ **/
+ partition<T>(
+ collection: List<T>,
+ pluckValue: string): T[][];
+
+ /**
+ * @see _.partition
+ **/
+ partition<T>(
+ collection: Dictionary<T>,
+ pluckValue: string): T[][];
+ }
+
+ interface LoDashImplicitStringWrapper {
+ /**
+ * @see _.partition
+ */
+ partition(
+ callback: ListIterator<string, boolean>): LoDashImplicitArrayWrapper<string[]>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.partition
+ */
+ partition(
+ callback: ListIterator<T, boolean>): LoDashImplicitArrayWrapper<T[]>;
+ /**
+ * @see _.partition
+ */
+ partition<W>(
+ whereValue: W): LoDashImplicitArrayWrapper<T[]>;
+ /**
+ * @see _.partition
+ */
+ partition(
+ path: string,
+ srcValue: any): LoDashImplicitArrayWrapper<T[]>;
+ /**
+ * @see _.partition
+ */
+ partition(
+ pluckValue: string): LoDashImplicitArrayWrapper<T[]>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.partition
+ */
+ partition<TResult>(
+ callback: ListIterator<TResult, boolean>): LoDashImplicitArrayWrapper<TResult[]>;
+
+ /**
+ * @see _.partition
+ */
+ partition<TResult>(
+ callback: DictionaryIterator<TResult, boolean>): LoDashImplicitArrayWrapper<TResult[]>;
+
+ /**
+ * @see _.partition
+ */
+ partition<W, TResult>(
+ whereValue: W): LoDashImplicitArrayWrapper<TResult[]>;
+
+ /**
+ * @see _.partition
+ */
+ partition<TResult>(
+ path: string,
+ srcValue: any): LoDashImplicitArrayWrapper<TResult[]>;
+
+ /**
+ * @see _.partition
+ */
+ partition<TResult>(
+ pluckValue: string): LoDashImplicitArrayWrapper<TResult[]>;
+ }
+
+ //_.reduce
+ interface LoDashStatic {
+ /**
+ * Reduces a collection to a value which is the accumulated result of running each
+ * element in the collection through the callback, where each successive callback execution
+ * consumes the return value of the previous execution. If accumulator is not provided the
+ * first element of the collection will be used as the initial accumulator value. The callback
+ * is bound to thisArg and invoked with four arguments; (accumulator, value, index|key, collection).
+ * @param collection The collection to iterate over.
+ * @param callback The function called per iteration.
+ * @param accumulator Initial value of the accumulator.
+ * @param thisArg The this binding of callback.
+ * @return Returns the accumulated value.
+ **/
+ reduce<T, TResult>(
+ collection: Array<T>,
+ callback: MemoIterator<T, TResult>,
+ accumulator: TResult): TResult;
+
+ /**
+ * @see _.reduce
+ **/
+ reduce<T, TResult>(
+ collection: List<T>,
+ callback: MemoIterator<T, TResult>,
+ accumulator: TResult): TResult;
+
+ /**
+ * @see _.reduce
+ **/
+ reduce<T, TResult>(
+ collection: Dictionary<T>,
+ callback: MemoIterator<T, TResult>,
+ accumulator: TResult): TResult;
+
+ /**
+ * @see _.reduce
+ **/
+ reduce<T, TResult>(
+ collection: NumericDictionary<T>,
+ callback: MemoIterator<T, TResult>,
+ accumulator: TResult): TResult;
+
+ /**
+ * @see _.reduce
+ **/
+ reduce<T, TResult>(
+ collection: Array<T>,
+ callback: MemoIterator<T, TResult>): TResult;
+
+ /**
+ * @see _.reduce
+ **/
+ reduce<T, TResult>(
+ collection: List<T>,
+ callback: MemoIterator<T, TResult>): TResult;
+
+ /**
+ * @see _.reduce
+ **/
+ reduce<T, TResult>(
+ collection: Dictionary<T>,
+ callback: MemoIterator<T, TResult>): TResult;
+
+ /**
+ * @see _.reduce
+ **/
+ reduce<T, TResult>(
+ collection: NumericDictionary<T>,
+ callback: MemoIterator<T, TResult>): TResult;
+
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.reduce
+ **/
+ reduce<TResult>(
+ callback: MemoIterator<T, TResult>,
+ accumulator: TResult): TResult;
+
+ /**
+ * @see _.reduce
+ **/
+ reduce<TResult>(
+ callback: MemoIterator<T, TResult>): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.reduce
+ **/
+ reduce<TValue, TResult>(
+ callback: MemoIterator<TValue, TResult>,
+ accumulator: TResult): TResult;
+
+ /**
+ * @see _.reduce
+ **/
+ reduce<TValue, TResult>(
+ callback: MemoIterator<TValue, TResult>): TResult;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.reduce
+ **/
+ reduce<TValue, TResult>(
+ callback: MemoIterator<TValue, TResult>,
+ accumulator: TResult): LoDashExplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.reduce
+ **/
+ reduce<TValue, TResult>(
+ callback: MemoIterator<TValue, TResult>): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**LoDashExplicitWrapper
+ * @see _.reduce
+ */
+ reduce<TResult>(
+ callback: MemoIterator<T, TResult>,
+ accumulator: TResult): LoDashExplicitWrapper<TResult>;
+
+ /**
+ * @see _.reduce
+ */
+ reduce<TResult>(
+ callback: MemoIterator<T, TResult>): LoDashExplicitWrapper<TResult>;
+ }
+
+ //_.reduceRight
+ interface LoDashStatic {
+ /**
+ * This method is like _.reduce except that it iterates over elements of a collection from
+ * right to left.
+ * @param collection The collection to iterate over.
+ * @param callback The function called per iteration.
+ * @param accumulator Initial value of the accumulator.
+ * @param thisArg The this binding of callback.
+ * @return The accumulated value.
+ **/
+ reduceRight<T, TResult>(
+ collection: Array<T>,
+ callback: MemoIterator<T, TResult>,
+ accumulator: TResult): TResult;
+
+ /**
+ * @see _.reduceRight
+ **/
+ reduceRight<T, TResult>(
+ collection: List<T>,
+ callback: MemoIterator<T, TResult>,
+ accumulator: TResult): TResult;
+
+ /**
+ * @see _.reduceRight
+ **/
+ reduceRight<T, TResult>(
+ collection: Dictionary<T>,
+ callback: MemoIterator<T, TResult>,
+ accumulator: TResult): TResult;
+
+ /**
+ * @see _.reduceRight
+ **/
+ reduceRight<T, TResult>(
+ collection: Array<T>,
+ callback: MemoIterator<T, TResult>): TResult;
+
+ /**
+ * @see _.reduceRight
+ **/
+ reduceRight<T, TResult>(
+ collection: List<T>,
+ callback: MemoIterator<T, TResult>): TResult;
+
+ /**
+ * @see _.reduceRight
+ **/
+ reduceRight<T, TResult>(
+ collection: Dictionary<T>,
+ callback: MemoIterator<T, TResult>): TResult;
+ }
+
+ //_.reject
+ interface LoDashStatic {
+ /**
+ * The opposite of _.filter; this method returns the elements of collection that predicate does not return
+ * truthy for.
+ *
+ * @param collection The collection to iterate over.
+ * @param predicate The function invoked per iteration.
+ * @param thisArg The this binding of predicate.
+ * @return Returns the new filtered array.
+ */
+ reject<T>(
+ collection: List<T>,
+ predicate?: ListIterator<T, boolean>
+ ): T[];
+
+ /**
+ * @see _.reject
+ */
+ reject<T>(
+ collection: Dictionary<T>,
+ predicate?: DictionaryIterator<T, boolean>
+ ): T[];
+
+ /**
+ * @see _.reject
+ */
+ reject(
+ collection: string,
+ predicate?: StringIterator<boolean>
+ ): string[];
+
+ /**
+ * @see _.reject
+ */
+ reject<T>(
+ collection: List<T>|Dictionary<T>,
+ predicate: string
+ ): T[];
+
+ /**
+ * @see _.reject
+ */
+ reject<W extends {}, T>(
+ collection: List<T>|Dictionary<T>,
+ predicate: W
+ ): T[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.reject
+ */
+ reject(
+ predicate?: StringIterator<boolean>
+ ): LoDashImplicitArrayWrapper<string>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.reject
+ */
+ reject(
+ predicate: ListIterator<T, boolean>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.reject
+ */
+ reject(
+ predicate: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.reject
+ */
+ reject<W>(predicate: W): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.reject
+ */
+ reject<T>(
+ predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.reject
+ */
+ reject<T>(
+ predicate: string
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.reject
+ */
+ reject<W, T>(predicate: W): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.reject
+ */
+ reject(
+ predicate?: StringIterator<boolean>
+ ): LoDashExplicitArrayWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.reject
+ */
+ reject(
+ predicate: ListIterator<T, boolean>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.reject
+ */
+ reject(
+ predicate: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.reject
+ */
+ reject<W>(predicate: W): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.reject
+ */
+ reject<T>(
+ predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.reject
+ */
+ reject<T>(
+ predicate: string
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.reject
+ */
+ reject<W, T>(predicate: W): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.sample
+ interface LoDashStatic {
+ /**
+ * Gets a random element from collection.
+ *
+ * @param collection The collection to sample.
+ * @return Returns the random element.
+ */
+ sample<T>(
+ collection: List<T>|Dictionary<T>|NumericDictionary<T>
+ ): T;
+
+ /**
+ * @see _.sample
+ */
+ sample<O extends Object, T>(
+ collection: O
+ ): T;
+
+ /**
+ * @see _.sample
+ */
+ sample<T>(
+ collection: Object
+ ): T;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.sample
+ */
+ sample(): string;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.sample
+ */
+ sample(): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.sample
+ */
+ sample<T>(): T;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.sample
+ */
+ sample(): LoDashExplicitWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.sample
+ */
+ sample<TWrapper>(): TWrapper;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.sample
+ */
+ sample<TWrapper>(): TWrapper;
+ }
+
+ //_.sampleSize
+ interface LoDashStatic {
+ /**
+ * Gets n random elements at unique keys from collection up to the size of collection.
+ *
+ * @param collection The collection to sample.
+ * @param n The number of elements to sample.
+ * @return Returns the random elements.
+ */
+ sampleSize<T>(
+ collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+ n?: number
+ ): T[];
+
+ /**
+ * @see _.sampleSize
+ */
+ sampleSize<O extends Object, T>(
+ collection: O,
+ n?: number
+ ): T[];
+
+ /**
+ * @see _.sampleSize
+ */
+ sampleSize<T>(
+ collection: Object,
+ n?: number
+ ): T[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.sampleSize
+ */
+ sampleSize(
+ n?: number
+ ): LoDashImplicitArrayWrapper<string>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.sampleSize
+ */
+ sampleSize(
+ n?: number
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.sampleSize
+ */
+ sampleSize<T>(
+ n?: number
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.sampleSize
+ */
+ sampleSize(
+ n?: number
+ ): LoDashExplicitArrayWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.sampleSize
+ */
+ sampleSize(
+ n?: number
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.sampleSize
+ */
+ sampleSize<T>(
+ n?: number
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.shuffle
+ interface LoDashStatic {
+ /**
+ * Creates an array of shuffled values, using a version of the Fisher-Yates shuffle.
+ *
+ * @param collection The collection to shuffle.
+ * @return Returns the new shuffled array.
+ */
+ shuffle<T>(collection: List<T>|Dictionary<T>): T[];
+
+ /**
+ * @see _.shuffle
+ */
+ shuffle(collection: string): string[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.shuffle
+ */
+ shuffle(): LoDashImplicitArrayWrapper<string>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.shuffle
+ */
+ shuffle(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.shuffle
+ */
+ shuffle<T>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.shuffle
+ */
+ shuffle(): LoDashExplicitArrayWrapper<string>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.shuffle
+ */
+ shuffle(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.shuffle
+ */
+ shuffle<T>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.size
+ interface LoDashStatic {
+ /**
+ * Gets the size of collection by returning its length for array-like values or the number of own enumerable
+ * properties for objects.
+ *
+ * @param collection The collection to inspect.
+ * @return Returns the size of collection.
+ */
+ size<T>(collection: List<T>|Dictionary<T>): number;
+
+ /**
+ * @see _.size
+ */
+ size(collection: string): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.size
+ */
+ size(): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.size
+ */
+ size(): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.size
+ */
+ size(): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.size
+ */
+ size(): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.size
+ */
+ size(): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.size
+ */
+ size(): LoDashExplicitWrapper<number>;
+ }
+
+ //_.some
+ interface LoDashStatic {
+ /**
+ * Checks if predicate returns truthy for any element of collection. Iteration is stopped once predicate
+ * returns truthy. The predicate is invoked with three arguments: (value, index|key, collection).
+ *
+ * @param collection The collection to iterate over.
+ * @param predicate The function invoked per iteration.
+ * @return Returns true if any element passes the predicate check, else false.
+ */
+ some<T>(
+ collection: List<T>,
+ predicate?: ListIterator<T, boolean>
+ ): boolean;
+
+ /**
+ * @see _.some
+ */
+ some<T>(
+ collection: Dictionary<T>,
+ predicate?: DictionaryIterator<T, boolean>
+ ): boolean;
+
+ /**
+ * @see _.some
+ */
+ some<T>(
+ collection: NumericDictionary<T>,
+ predicate?: NumericDictionaryIterator<T, boolean>
+ ): boolean;
+
+ /**
+ * @see _.some
+ */
+ some(
+ collection: Object,
+ predicate?: ObjectIterator<any, boolean>
+ ): boolean;
+
+ /**
+ * @see _.some
+ */
+ some<T>(
+ collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+ predicate?: string|[string, any]
+ ): boolean;
+
+
+ /**
+ * @see _.some
+ */
+ some(
+ collection: Object,
+ predicate?: string|[string, any]
+ ): boolean;
+
+ /**
+ * @see _.some
+ */
+ some<TObject extends {}, T>(
+ collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+ predicate?: TObject
+ ): boolean;
+
+ /**
+ * @see _.some
+ */
+ some<T>(
+ collection: List<T>|Dictionary<T>|NumericDictionary<T>,
+ predicate?: Object
+ ): boolean;
+
+ /**
+ * @see _.some
+ */
+ some<TObject extends {}>(
+ collection: Object,
+ predicate?: TObject
+ ): boolean;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.some
+ */
+ some(
+ predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean>
+ ): boolean;
+
+ /**
+ * @see _.some
+ */
+ some(
+ predicate?: string|[string, any]
+ ): boolean;
+
+ /**
+ * @see _.some
+ */
+ some<TObject extends {}>(
+ predicate?: TObject
+ ): boolean;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.some
+ */
+ some<TResult>(
+ predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean>|ObjectIterator<any, boolean>
+ ): boolean;
+
+ /**
+ * @see _.some
+ */
+ some(
+ predicate?: string|[string, any]
+ ): boolean;
+
+ /**
+ * @see _.some
+ */
+ some<TObject extends {}>(
+ predicate?: TObject
+ ): boolean;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.some
+ */
+ some(
+ predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean>
+ ): LoDashExplicitWrapper<boolean>;
+
+ /**
+ * @see _.some
+ */
+ some(
+ predicate?: string|[string, any]
+ ): LoDashExplicitWrapper<boolean>;
+
+ /**
+ * @see _.some
+ */
+ some<TObject extends {}>(
+ predicate?: TObject
+ ): LoDashExplicitWrapper<boolean>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.some
+ */
+ some<TResult>(
+ predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean>|ObjectIterator<any, boolean>
+ ): LoDashExplicitWrapper<boolean>;
+
+ /**
+ * @see _.some
+ */
+ some(
+ predicate?: string|[string, any]
+ ): LoDashExplicitWrapper<boolean>;
+
+ /**
+ * @see _.some
+ */
+ some<TObject extends {}>(
+ predicate?: TObject
+ ): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.sortBy
+ interface LoDashStatic {
+ /**
+ * Creates an array of elements, sorted in ascending order by the results of
+ * running each element in a collection through each iteratee. This method
+ * performs a stable sort, that is, it preserves the original sort order of
+ * equal elements. The iteratees are invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {...(Function|Function[]|Object|Object[]|string|string[])} [iteratees=[_.identity]]
+ * The iteratees to sort by, specified individually or in arrays.
+ * @returns {Array} Returns the new sorted array.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'fred', 'age': 48 },
+ * { 'user': 'barney', 'age': 36 },
+ * { 'user': 'fred', 'age': 42 },
+ * { 'user': 'barney', 'age': 34 }
+ * ];
+ *
+ * _.sortBy(users, function(o) { return o.user; });
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]
+ *
+ * _.sortBy(users, ['user', 'age']);
+ * // => objects for [['barney', 34], ['barney', 36], ['fred', 42], ['fred', 48]]
+ *
+ * _.sortBy(users, 'user', function(o) {
+ * return Math.floor(o.age / 10);
+ * });
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]
+ */
+ sortBy<T, TSort>(
+ collection: List<T>,
+ iteratee?: ListIterator<T, TSort>
+ ): T[];
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<T, TSort>(
+ collection: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, TSort>
+ ): T[];
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<T>(
+ collection: List<T>|Dictionary<T>,
+ iteratee: string
+ ): T[];
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<W extends {}, T>(
+ collection: List<T>|Dictionary<T>,
+ whereValue: W
+ ): T[];
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<T>(
+ collection: List<T>|Dictionary<T>
+ ): T[];
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<T>(
+ collection: (Array<T>|List<T>),
+ iteratees: (ListIterator<T, any>|string|Object)[]): T[];
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<T>(
+ collection: (Array<T>|List<T>),
+ ...iteratees: (ListIterator<T, boolean>|Object|string)[]): T[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.sortBy
+ */
+ sortBy<TSort>(
+ iteratee?: ListIterator<T, TSort>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy(iteratee: string): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<W extends {}>(whereValue: W): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy(): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy(...iteratees: (ListIterator<T, boolean>|Object|string)[]): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ **/
+ sortBy(iteratees: (ListIterator<T, any>|string|Object)[]): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.sortBy
+ */
+ sortBy<T, TSort>(
+ iteratee?: ListIterator<T, TSort>|DictionaryIterator<T, TSort>
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<T>(iteratee: string): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<W extends {}, T>(whereValue: W): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<T>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.sortBy
+ */
+ sortBy<TSort>(
+ iteratee?: ListIterator<T, TSort>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy(iteratee: string): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<W extends {}>(whereValue: W): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.sortBy
+ */
+ sortBy<T, TSort>(
+ iteratee?: ListIterator<T, TSort>|DictionaryIterator<T, TSort>
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<T>(iteratee: string): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<W extends {}, T>(whereValue: W): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.sortBy
+ */
+ sortBy<T>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.orderBy
+ interface LoDashStatic {
+ /**
+ * This method is like `_.sortBy` except that it allows specifying the sort
+ * orders of the iteratees to sort by. If `orders` is unspecified, all values
+ * are sorted in ascending order. Otherwise, specify an order of "desc" for
+ * descending or "asc" for ascending sort order of corresponding values.
+ *
+ * @static
+ * @memberOf _
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function[]|Object[]|string[]} [iteratees=[_.identity]] The iteratees to sort by.
+ * @param {string[]} [orders] The sort orders of `iteratees`.
+ * @param- {Object} [guard] Enables use as an iteratee for functions like `_.reduce`.
+ * @returns {Array} Returns the new sorted array.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'fred', 'age': 48 },
+ * { 'user': 'barney', 'age': 34 },
+ * { 'user': 'fred', 'age': 42 },
+ * { 'user': 'barney', 'age': 36 }
+ * ];
+ *
+ * // sort by `user` in ascending order and by `age` in descending order
+ * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]
+ */
+ orderBy<W extends Object, T>(
+ collection: List<T>,
+ iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): T[];
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<T>(
+ collection: List<T>,
+ iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): T[];
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<W extends Object, T>(
+ collection: NumericDictionary<T>,
+ iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): T[];
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<T>(
+ collection: NumericDictionary<T>,
+ iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): T[];
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<W extends Object, T>(
+ collection: Dictionary<T>,
+ iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): T[];
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<T>(
+ collection: Dictionary<T>,
+ iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): T[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.orderBy
+ */
+ orderBy(
+ iteratees: ListIterator<T, any>|string|(ListIterator<T, any>|string)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.orderBy
+ */
+ orderBy<W extends Object>(
+ iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.orderBy
+ */
+ orderBy<W extends Object, T>(
+ iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<T>(
+ iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<W extends Object, T>(
+ iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<T>(
+ iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<W extends Object, T>(
+ iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashImplicitArrayWrapper<T>;
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<T>(
+ iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.orderBy
+ */
+ orderBy(
+ iteratees: ListIterator<T, any>|string|(ListIterator<T, any>|string)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.orderBy
+ */
+ orderBy<W extends Object>(
+ iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.orderBy
+ */
+ orderBy<W extends Object, T>(
+ iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<T>(
+ iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<W extends Object, T>(
+ iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<T>(
+ iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<W extends Object, T>(
+ iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashExplicitArrayWrapper<T>;
+
+ /**
+ * @see _.orderBy
+ */
+ orderBy<T>(
+ iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[],
+ orders?: boolean|string|(boolean|string)[]
+ ): LoDashExplicitArrayWrapper<T>;
+ }
+
+ /********
+ * Date *
+ ********/
+
+ //_.now
+ interface LoDashStatic {
+ /**
+ * Gets the number of milliseconds that have elapsed since the Unix epoch (1 January 1970 00:00:00 UTC).
+ *
+ * @return The number of milliseconds.
+ */
+ now(): number;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.now
+ */
+ now(): number;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.now
+ */
+ now(): LoDashExplicitWrapper<number>;
+ }
+
+ /*************
+ * Functions *
+ *************/
+
+ //_.after
+ interface LoDashStatic {
+ /**
+ * The opposite of _.before; this method creates a function that invokes func once it’s called n or more times.
+ *
+ * @param n The number of calls before func is invoked.
+ * @param func The function to restrict.
+ * @return Returns the new restricted function.
+ */
+ after<TFunc extends Function>(
+ n: number,
+ func: TFunc
+ ): TFunc;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.after
+ **/
+ after<TFunc extends Function>(func: TFunc): LoDashImplicitObjectWrapper<TFunc>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.after
+ **/
+ after<TFunc extends Function>(func: TFunc): LoDashExplicitObjectWrapper<TFunc>;
+ }
+
+ //_.ary
+ interface LoDashStatic {
+ /**
+ * Creates a function that accepts up to n arguments ignoring any additional arguments.
+ *
+ * @param func The function to cap arguments for.
+ * @param n The arity cap.
+ * @returns Returns the new function.
+ */
+ ary<TResult extends Function>(
+ func: Function,
+ n?: number
+ ): TResult;
+
+ ary<T extends Function, TResult extends Function>(
+ func: T,
+ n?: number
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.ary
+ */
+ ary<TResult extends Function>(n?: number): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.ary
+ */
+ ary<TResult extends Function>(n?: number): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.before
+ interface LoDashStatic {
+ /**
+ * Creates a function that invokes func, with the this binding and arguments of the created function, while
+ * it’s called less than n times. Subsequent calls to the created function return the result of the last func
+ * invocation.
+ *
+ * @param n The number of calls at which func is no longer invoked.
+ * @param func The function to restrict.
+ * @return Returns the new restricted function.
+ */
+ before<TFunc extends Function>(
+ n: number,
+ func: TFunc
+ ): TFunc;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.before
+ **/
+ before<TFunc extends Function>(func: TFunc): LoDashImplicitObjectWrapper<TFunc>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.before
+ **/
+ before<TFunc extends Function>(func: TFunc): LoDashExplicitObjectWrapper<TFunc>;
+ }
+
+ //_.bind
+ interface FunctionBind {
+ placeholder: any;
+
+ <T extends Function, TResult extends Function>(
+ func: T,
+ thisArg: any,
+ ...partials: any[]
+ ): TResult;
+
+ <TResult extends Function>(
+ func: Function,
+ thisArg: any,
+ ...partials: any[]
+ ): TResult;
+ }
+
+ interface LoDashStatic {
+ /**
+ * Creates a function that invokes func with the this binding of thisArg and prepends any additional _.bind
+ * arguments to those provided to the bound function.
+ *
+ * The _.bind.placeholder value, which defaults to _ in monolithic builds, may be used as a placeholder for
+ * partially applied arguments.
+ *
+ * Note: Unlike native Function#bind this method does not set the "length" property of bound functions.
+ *
+ * @param func The function to bind.
+ * @param thisArg The this binding of func.
+ * @param partials The arguments to be partially applied.
+ * @return Returns the new bound function.
+ */
+ bind: FunctionBind;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.bind
+ */
+ bind<TResult extends Function>(
+ thisArg: any,
+ ...partials: any[]
+ ): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.bind
+ */
+ bind<TResult extends Function>(
+ thisArg: any,
+ ...partials: any[]
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.bindAll
+ interface LoDashStatic {
+ /**
+ * Binds methods of an object to the object itself, overwriting the existing method. Method names may be
+ * specified as individual arguments or as arrays of method names. If no method names are provided all
+ * enumerable function properties, own and inherited, of object are bound.
+ *
+ * Note: This method does not set the "length" property of bound functions.
+ *
+ * @param object The object to bind and assign the bound methods to.
+ * @param methodNames The object method names to bind, specified as individual method names or arrays of
+ * method names.
+ * @return Returns object.
+ */
+ bindAll<T>(
+ object: T,
+ ...methodNames: (string|string[])[]
+ ): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.bindAll
+ */
+ bindAll(...methodNames: (string|string[])[]): LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.bindAll
+ */
+ bindAll(...methodNames: (string|string[])[]): LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.bindKey
+ interface FunctionBindKey {
+ placeholder: any;
+
+ <T extends Object, TResult extends Function>(
+ object: T,
+ key: any,
+ ...partials: any[]
+ ): TResult;
+
+ <TResult extends Function>(
+ object: Object,
+ key: any,
+ ...partials: any[]
+ ): TResult;
+ }
+
+ interface LoDashStatic {
+ /**
+ * Creates a function that invokes the method at object[key] and prepends any additional _.bindKey arguments
+ * to those provided to the bound function.
+ *
+ * This method differs from _.bind by allowing bound functions to reference methods that may be redefined
+ * or don’t yet exist. See Peter Michaux’s article for more details.
+ *
+ * The _.bindKey.placeholder value, which defaults to _ in monolithic builds, may be used as a placeholder
+ * for partially applied arguments.
+ *
+ * @param object The object the method belongs to.
+ * @param key The key of the method.
+ * @param partials The arguments to be partially applied.
+ * @return Returns the new bound function.
+ */
+ bindKey: FunctionBindKey;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.bindKey
+ */
+ bindKey<TResult extends Function>(
+ key: any,
+ ...partials: any[]
+ ): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.bindKey
+ */
+ bindKey<TResult extends Function>(
+ key: any,
+ ...partials: any[]
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.createCallback
+ interface LoDashStatic {
+ /**
+ * Produces a callback bound to an optional thisArg. If func is a property name the created
+ * callback will return the property value for a given element. If func is an object the created
+ * callback will return true for elements that contain the equivalent object properties,
+ * otherwise it will return false.
+ * @param func The value to convert to a callback.
+ * @param thisArg The this binding of the created callback.
+ * @param argCount The number of arguments the callback accepts.
+ * @return A callback function.
+ **/
+ createCallback(
+ func: string,
+ argCount?: number): () => any;
+
+ /**
+ * @see _.createCallback
+ **/
+ createCallback(
+ func: Dictionary<any>,
+ argCount?: number): () => boolean;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.createCallback
+ **/
+ createCallback(
+ argCount?: number): LoDashImplicitObjectWrapper<() => any>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.createCallback
+ **/
+ createCallback(
+ argCount?: number): LoDashImplicitObjectWrapper<() => any>;
+ }
+
+ //_.curry
+ interface LoDashStatic {
+ /**
+ * Creates a function that accepts one or more arguments of func that when called either invokes func returning
+ * its result, if all func arguments have been provided, or returns a function that accepts one or more of the
+ * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
+ * @param func The function to curry.
+ * @return Returns the new curried function.
+ */
+ curry<T1, R>(func: (t1: T1) => R):
+ CurriedFunction1<T1, R>;
+ /**
+ * Creates a function that accepts one or more arguments of func that when called either invokes func returning
+ * its result, if all func arguments have been provided, or returns a function that accepts one or more of the
+ * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
+ * @param func The function to curry.
+ * @return Returns the new curried function.
+ */
+ curry<T1, T2, R>(func: (t1: T1, t2: T2) => R):
+ CurriedFunction2<T1, T2, R>;
+ /**
+ * Creates a function that accepts one or more arguments of func that when called either invokes func returning
+ * its result, if all func arguments have been provided, or returns a function that accepts one or more of the
+ * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
+ * @param func The function to curry.
+ * @return Returns the new curried function.
+ */
+ curry<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R):
+ CurriedFunction3<T1, T2, T3, R>;
+ /**
+ * Creates a function that accepts one or more arguments of func that when called either invokes func returning
+ * its result, if all func arguments have been provided, or returns a function that accepts one or more of the
+ * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
+ * @param func The function to curry.
+ * @return Returns the new curried function.
+ */
+ curry<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R):
+ CurriedFunction4<T1, T2, T3, T4, R>;
+ /**
+ * Creates a function that accepts one or more arguments of func that when called either invokes func returning
+ * its result, if all func arguments have been provided, or returns a function that accepts one or more of the
+ * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
+ * @param func The function to curry.
+ * @return Returns the new curried function.
+ */
+ curry<T1, T2, T3, T4, T5, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R):
+ CurriedFunction5<T1, T2, T3, T4, T5, R>;
+ /**
+ * Creates a function that accepts one or more arguments of func that when called either invokes func returning
+ * its result, if all func arguments have been provided, or returns a function that accepts one or more of the
+ * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
+ * @param func The function to curry.
+ * @param arity The arity of func.
+ * @return Returns the new curried function.
+ */
+ curry<TResult extends Function>(
+ func: Function,
+ arity?: number): TResult;
+ }
+
+ interface CurriedFunction1<T1, R> {
+ (): CurriedFunction1<T1, R>;
+ (t1: T1): R;
+ }
+
+ interface CurriedFunction2<T1, T2, R> {
+ (): CurriedFunction2<T1, T2, R>;
+ (t1: T1): CurriedFunction1<T2, R>;
+ (t1: T1, t2: T2): R;
+ }
+
+ interface CurriedFunction3<T1, T2, T3, R> {
+ (): CurriedFunction3<T1, T2, T3, R>;
+ (t1: T1): CurriedFunction2<T2, T3, R>;
+ (t1: T1, t2: T2): CurriedFunction1<T3, R>;
+ (t1: T1, t2: T2, t3: T3): R;
+ }
+
+ interface CurriedFunction4<T1, T2, T3, T4, R> {
+ (): CurriedFunction4<T1, T2, T3, T4, R>;
+ (t1: T1): CurriedFunction3<T2, T3, T4, R>;
+ (t1: T1, t2: T2): CurriedFunction2<T3, T4, R>;
+ (t1: T1, t2: T2, t3: T3): CurriedFunction1<T4, R>;
+ (t1: T1, t2: T2, t3: T3, t4: T4): R;
+ }
+
+ interface CurriedFunction5<T1, T2, T3, T4, T5, R> {
+ (): CurriedFunction5<T1, T2, T3, T4, T5, R>;
+ (t1: T1): CurriedFunction4<T2, T3, T4, T5, R>;
+ (t1: T1, t2: T2): CurriedFunction3<T3, T4, T5, R>;
+ (t1: T1, t2: T2, t3: T3): CurriedFunction2<T4, T5, R>;
+ (t1: T1, t2: T2, t3: T3, t4: T4): CurriedFunction1<T5, R>;
+ (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.curry
+ **/
+ curry<TResult extends Function>(arity?: number): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ //_.curryRight
+ interface LoDashStatic {
+ /**
+ * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight
+ * instead of _.partial.
+ * @param func The function to curry.
+ * @return Returns the new curried function.
+ */
+ curryRight<T1, R>(func: (t1: T1) => R):
+ CurriedFunction1<T1, R>;
+ /**
+ * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight
+ * instead of _.partial.
+ * @param func The function to curry.
+ * @return Returns the new curried function.
+ */
+ curryRight<T1, T2, R>(func: (t1: T1, t2: T2) => R):
+ CurriedFunction2<T2, T1, R>;
+ /**
+ * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight
+ * instead of _.partial.
+ * @param func The function to curry.
+ * @return Returns the new curried function.
+ */
+ curryRight<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R):
+ CurriedFunction3<T3, T2, T1, R>;
+ /**
+ * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight
+ * instead of _.partial.
+ * @param func The function to curry.
+ * @return Returns the new curried function.
+ */
+ curryRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R):
+ CurriedFunction4<T4, T3, T2, T1, R>;
+ /**
+ * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight
+ * instead of _.partial.
+ * @param func The function to curry.
+ * @return Returns the new curried function.
+ */
+ curryRight<T1, T2, T3, T4, T5, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R):
+ CurriedFunction5<T5, T4, T3, T2, T1, R>;
+ /**
+ * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight
+ * instead of _.partial.
+ * @param func The function to curry.
+ * @param arity The arity of func.
+ * @return Returns the new curried function.
+ */
+ curryRight<TResult extends Function>(
+ func: Function,
+ arity?: number): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.curryRight
+ **/
+ curryRight<TResult extends Function>(arity?: number): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ //_.debounce
+ interface DebounceSettings {
+ /**
+ * Specify invoking on the leading edge of the timeout.
+ */
+ leading?: boolean;
+
+ /**
+ * The maximum time func is allowed to be delayed before it’s invoked.
+ */
+ maxWait?: number;
+
+ /**
+ * Specify invoking on the trailing edge of the timeout.
+ */
+ trailing?: boolean;
+ }
+
+ interface LoDashStatic {
+ /**
+ * Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since
+ * the last time the debounced function was invoked. The debounced function comes with a cancel method to
+ * cancel delayed invocations and a flush method to immediately invoke them. Provide an options object to
+ * indicate that func should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent
+ * calls to the debounced function return the result of the last func invocation.
+ *
+ * Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only
+ * if the the debounced function is invoked more than once during the wait timeout.
+ *
+ * See David Corbacho’s article for details over the differences between _.debounce and _.throttle.
+ *
+ * @param func The function to debounce.
+ * @param wait The number of milliseconds to delay.
+ * @param options The options object.
+ * @param options.leading Specify invoking on the leading edge of the timeout.
+ * @param options.maxWait The maximum time func is allowed to be delayed before it’s invoked.
+ * @param options.trailing Specify invoking on the trailing edge of the timeout.
+ * @return Returns the new debounced function.
+ */
+ debounce<T extends Function>(
+ func: T,
+ wait?: number,
+ options?: DebounceSettings
+ ): T & Cancelable;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.debounce
+ */
+ debounce(
+ wait?: number,
+ options?: DebounceSettings
+ ): LoDashImplicitObjectWrapper<T & Cancelable>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.debounce
+ */
+ debounce(
+ wait?: number,
+ options?: DebounceSettings
+ ): LoDashExplicitObjectWrapper<T & Cancelable>;
+ }
+
+ //_.defer
+ interface LoDashStatic {
+ /**
+ * Defers invoking the func until the current call stack has cleared. Any additional arguments are provided to
+ * func when it’s invoked.
+ *
+ * @param func The function to defer.
+ * @param args The arguments to invoke the function with.
+ * @return Returns the timer id.
+ */
+ defer<T extends Function>(
+ func: T,
+ ...args: any[]
+ ): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.defer
+ */
+ defer(...args: any[]): LoDashImplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.defer
+ */
+ defer(...args: any[]): LoDashExplicitWrapper<number>;
+ }
+
+ //_.delay
+ interface LoDashStatic {
+ /**
+ * Invokes func after wait milliseconds. Any additional arguments are provided to func when it’s invoked.
+ *
+ * @param func The function to delay.
+ * @param wait The number of milliseconds to delay invocation.
+ * @param args The arguments to invoke the function with.
+ * @return Returns the timer id.
+ */
+ delay<T extends Function>(
+ func: T,
+ wait: number,
+ ...args: any[]
+ ): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.delay
+ */
+ delay(
+ wait: number,
+ ...args: any[]
+ ): LoDashImplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.delay
+ */
+ delay(
+ wait: number,
+ ...args: any[]
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashStatic {
+ /**
+ * Creates a function that invokes `func` with arguments reversed.
+ *
+ * @static
+ * @memberOf _
+ * @category Function
+ * @param {Function} func The function to flip arguments for.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var flipped = _.flip(function() {
+ * return _.toArray(arguments);
+ * });
+ *
+ * flipped('a', 'b', 'c', 'd');
+ * // => ['d', 'c', 'b', 'a']
+ */
+ flip<T extends Function>(func: T): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.flip
+ */
+ flip(): LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.flip
+ */
+ flip(): LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.flow
+ interface LoDashStatic {
+ /**
+ * Creates a function that returns the result of invoking the provided functions with the this binding of the
+ * created function, where each successive invocation is supplied the return value of the previous.
+ *
+ * @param funcs Functions to invoke.
+ * @return Returns the new function.
+ */
+ // 1-argument first function
+ flow<A1, R1, R2>(f1: (a1: A1) => R1, f2: (a: R1) => R2): (a1: A1) => R2;
+ flow<A1, R1, R2, R3>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1) => R3;
+ flow<A1, R1, R2, R3, R4>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (a1: A1) => R4;
+ flow<A1, R1, R2, R3, R4, R5>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (a1: A1) => R5;
+ flow<A1, R1, R2, R3, R4, R5, R6>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (a1: A1) => R6;
+ flow<A1, R1, R2, R3, R4, R5, R6, R7>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (a1: A1) => R7;
+ // 2-argument first function
+ flow<A1, A2, R1, R2>(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2): (a1: A1, a2: A2) => R2;
+ flow<A1, A2, R1, R2, R3>(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1, a2: A2) => R3;
+ flow<A1, A2, R1, R2, R3, R4>(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (a1: A1, a2: A2) => R4;
+ flow<A1, A2, R1, R2, R3, R4, R5>(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (a1: A1, a2: A2) => R5;
+ flow<A1, A2, R1, R2, R3, R4, R5, R6>(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (a1: A1, a2: A2) => R6;
+ flow<A1, A2, R1, R2, R3, R4, R5, R6, R7>(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (a1: A1, a2: A2) => R7;
+ // 3-argument first function
+ flow<A1, A2, A3, R1, R2>(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2): (a1: A1, a2: A2, a3: A3) => R2;
+ flow<A1, A2, A3, R1, R2, R3>(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1, a2: A2, a3: A3) => R3;
+ flow<A1, A2, A3, R1, R2, R3, R4>(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (a1: A1, a2: A2, a3: A3) => R4;
+ flow<A1, A2, A3, R1, R2, R3, R4, R5>(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (a1: A1, a2: A2, a3: A3) => R5;
+ flow<A1, A2, A3, R1, R2, R3, R4, R5, R6>(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (a1: A1, a2: A2, a3: A3) => R6;
+ flow<A1, A2, A3, R1, R2, R3, R4, R5, R6, R7>(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (a1: A1, a2: A2, a3: A3) => R7;
+ // 4-argument first function
+ flow<A1, A2, A3, A4, R1, R2>(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2): (a1: A1, a2: A2, a3: A3, a4: A4) => R2;
+ flow<A1, A2, A3, A4, R1, R2, R3>(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1, a2: A2, a3: A3, a4: A4) => R3;
+ flow<A1, A2, A3, A4, R1, R2, R3, R4>(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (a1: A1, a2: A2, a3: A3, a4: A4) => R4;
+ flow<A1, A2, A3, A4, R1, R2, R3, R4, R5>(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (a1: A1, a2: A2, a3: A3, a4: A4) => R5;
+ flow<A1, A2, A3, A4, R1, R2, R3, R4, R5, R6>(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (a1: A1, a2: A2, a3: A3, a4: A4) => R6;
+ flow<A1, A2, A3, A4, R1, R2, R3, R4, R5, R6, R7>(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (a1: A1, a2: A2, a3: A3, a4: A4) => R7;
+ // generic function
+ flow<TResult extends Function>(...funcs: Function[]): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.flow
+ */
+ flow<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.flow
+ */
+ flow<TResult extends Function>(...funcs: Function[]): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.flowRight
+ interface LoDashStatic {
+ /**
+ * This method is like _.flow except that it creates a function that invokes the provided functions from right
+ * to left.
+ *
+ * @param funcs Functions to invoke.
+ * @return Returns the new function.
+ */
+ flowRight<TResult extends Function>(...funcs: Function[]): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.flowRight
+ */
+ flowRight<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.flowRight
+ */
+ flowRight<TResult extends Function>(...funcs: Function[]): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+
+ //_.memoize
+ interface MemoizedFunction extends Function {
+ cache: MapCache;
+ }
+
+ interface LoDashStatic {
+ /**
+ * Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for
+ * storing the result based on the arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with
+ * the this binding of the memoized function.
+ *
+ * @param func The function to have its output memoized.
+ * @param resolver The function to resolve the cache key.
+ * @return Returns the new memoizing function.
+ */
+ memoize: {
+ <T extends Function>(func: T, resolver?: Function): T & MemoizedFunction;
+ Cache: MapCacheConstructor;
+ }
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.memoize
+ */
+ memoize(resolver?: Function): LoDashImplicitObjectWrapper<T & MemoizedFunction>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.memoize
+ */
+ memoize(resolver?: Function): LoDashExplicitObjectWrapper<T & MemoizedFunction>;
+ }
+
+ //_.overArgs (was _.modArgs)
+ interface LoDashStatic {
+ /**
+ * Creates a function that runs each argument through a corresponding transform function.
+ *
+ * @param func The function to wrap.
+ * @param transforms The functions to transform arguments, specified as individual functions or arrays
+ * of functions.
+ * @return Returns the new function.
+ */
+ overArgs<T extends Function, TResult extends Function>(
+ func: T,
+ ...transforms: Function[]
+ ): TResult;
+
+ /**
+ * @see _.overArgs
+ */
+ overArgs<T extends Function, TResult extends Function>(
+ func: T,
+ transforms: Function[]
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.overArgs
+ */
+ overArgs<TResult extends Function>(...transforms: Function[]): LoDashImplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.overArgs
+ */
+ overArgs<TResult extends Function>(transforms: Function[]): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.overArgs
+ */
+ overArgs<TResult extends Function>(...transforms: Function[]): LoDashExplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.overArgs
+ */
+ overArgs<TResult extends Function>(transforms: Function[]): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.negate
+ interface LoDashStatic {
+ /**
+ * Creates a function that negates the result of the predicate func. The func predicate is invoked with
+ * the this binding and arguments of the created function.
+ *
+ * @param predicate The predicate to negate.
+ * @return Returns the new function.
+ */
+ negate<T extends Function>(predicate: T): (...args: any[]) => boolean;
+
+ /**
+ * @see _.negate
+ */
+ negate<T extends Function, TResult extends Function>(predicate: T): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.negate
+ */
+ negate(): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>;
+
+ /**
+ * @see _.negate
+ */
+ negate<TResult extends Function>(): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.negate
+ */
+ negate(): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>;
+
+ /**
+ * @see _.negate
+ */
+ negate<TResult extends Function>(): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.once
+ interface LoDashStatic {
+ /**
+ * Creates a function that is restricted to invoking func once. Repeat calls to the function return the value
+ * of the first call. The func is invoked with the this binding and arguments of the created function.
+ *
+ * @param func The function to restrict.
+ * @return Returns the new restricted function.
+ */
+ once<T extends Function>(func: T): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.once
+ */
+ once(): LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.once
+ */
+ once(): LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.partial
+ interface LoDashStatic {
+ /**
+ * Creates a function that, when called, invokes func with any additional partial arguments
+ * prepended to those provided to the new function. This method is similar to _.bind except
+ * it does not alter the this binding.
+ * @param func The function to partially apply arguments to.
+ * @param args Arguments to be partially applied.
+ * @return The new partially applied function.
+ **/
+ partial: Partial;
+ }
+
+ type PH = LoDashStatic;
+
+ interface Function0<R> {
+ (): R;
+ }
+ interface Function1<T1, R> {
+ (t1: T1): R;
+ }
+ interface Function2<T1, T2, R> {
+ (t1: T1, t2: T2): R;
+ }
+ interface Function3<T1, T2, T3, R> {
+ (t1: T1, t2: T2, t3: T3): R;
+ }
+ interface Function4<T1, T2, T3, T4, R> {
+ (t1: T1, t2: T2, t3: T3, t4: T4): R;
+ }
+
+ interface Partial {
+ // arity 0
+ <R>(func: Function0<R>): Function0<R>;
+ // arity 1
+ <T1, R>(func: Function1<T1, R>): Function1<T1, R>;
+ <T1, R>(func: Function1<T1, R>, arg1: T1): Function0<R>;
+ // arity 2
+ <T1, T2, R>(func: Function2<T1, T2, R>): Function2<T1, T2, R>;
+ <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1): Function1< T2, R>;
+ <T1, T2, R>(func: Function2<T1, T2, R>, plc1: PH, arg2: T2): Function1<T1, R>;
+ <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, arg2: T2): Function0< R>;
+ // arity 3
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>): Function3<T1, T2, T3, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1): Function2< T2, T3, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: PH, arg2: T2): Function2<T1, T3, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2): Function1< T3, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: PH, plc2: PH, arg3: T3): Function2<T1, T2, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: PH, arg3: T3): Function1< T2, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: PH, arg2: T2, arg3: T3): Function1<T1, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): Function0< R>;
+ // arity 4
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>): Function4<T1, T2, T3, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1): Function3< T2, T3, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, arg2: T2): Function3<T1, T3, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2): Function2< T3, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, plc2: PH, arg3: T3): Function3<T1, T2, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3): Function2< T2, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, arg2: T2, arg3: T3): Function2<T1, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3): Function1< T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, plc2: PH, plc3: PH, arg4: T4): Function3<T1, T2, T3, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, plc3: PH, arg4: T4): Function2< T2, T3, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, arg2: T2, plc3: PH, arg4: T4): Function2<T1, T3, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: PH, arg4: T4): Function1< T3, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, plc2: PH, arg3: T3, arg4: T4): Function2<T1, T2, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3, arg4: T4): Function1< T2, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, arg2: T2, arg3: T3, arg4: T4): Function1<T1, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): Function0< R>;
+ // catch-all
+ (func: Function, ...args: any[]): Function;
+ }
+
+ //_.partialRight
+ interface LoDashStatic {
+ /**
+ * This method is like _.partial except that partial arguments are appended to those provided
+ * to the new function.
+ * @param func The function to partially apply arguments to.
+ * @param args Arguments to be partially applied.
+ * @return The new partially applied function.
+ **/
+ partialRight: PartialRight
+ }
+
+ interface PartialRight {
+ // arity 0
+ <R>(func: Function0<R>): Function0<R>;
+ // arity 1
+ <T1, R>(func: Function1<T1, R>): Function1<T1, R>;
+ <T1, R>(func: Function1<T1, R>, arg1: T1): Function0<R>;
+ // arity 2
+ <T1, T2, R>(func: Function2<T1, T2, R>): Function2<T1, T2, R>;
+ <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, plc2: PH): Function1< T2, R>;
+ <T1, T2, R>(func: Function2<T1, T2, R>, arg2: T2): Function1<T1, R>;
+ <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, arg2: T2): Function0< R>;
+ // arity 3
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>): Function3<T1, T2, T3, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: PH, plc3: PH): Function2< T2, T3, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg2: T2, plc3: PH): Function2<T1, T3, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, plc3: PH): Function1< T3, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg3: T3): Function2<T1, T2, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: PH, arg3: T3): Function1< T2, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg2: T2, arg3: T3): Function1<T1, R>;
+ <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): Function0< R>;
+ // arity 4
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>): Function4<T1, T2, T3, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, plc3: PH, plc4: PH): Function3< T2, T3, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg2: T2, plc3: PH, plc4: PH): Function3<T1, T3, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: PH, plc4: PH): Function2< T3, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg3: T3, plc4: PH): Function3<T1, T2, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3, plc4: PH): Function2< T2, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg2: T2, arg3: T3, plc4: PH): Function2<T1, T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, plc4: PH): Function1< T4, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg4: T4): Function3<T1, T2, T3, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, plc3: PH, arg4: T4): Function2< T2, T3, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg2: T2, plc3: PH, arg4: T4): Function2<T1, T3, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: PH, arg4: T4): Function1< T3, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg3: T3, arg4: T4): Function2<T1, T2, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3, arg4: T4): Function1< T2, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg2: T2, arg3: T3, arg4: T4): Function1<T1, R>;
+ <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): Function0< R>;
+ // catch-all
+ (func: Function, ...args: any[]): Function;
+ }
+
+ //_.rearg
+ interface LoDashStatic {
+ /**
+ * Creates a function that invokes func with arguments arranged according to the specified indexes where the
+ * argument value at the first index is provided as the first argument, the argument value at the second index
+ * is provided as the second argument, and so on.
+ * @param func The function to rearrange arguments for.
+ * @param indexes The arranged argument indexes, specified as individual indexes or arrays of indexes.
+ * @return Returns the new function.
+ */
+ rearg<TResult extends Function>(func: Function, indexes: number[]): TResult;
+
+ /**
+ * @see _.rearg
+ */
+ rearg<TResult extends Function>(func: Function, ...indexes: number[]): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.rearg
+ */
+ rearg<TResult extends Function>(indexes: number[]): LoDashImplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.rearg
+ */
+ rearg<TResult extends Function>(...indexes: number[]): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ //_.rest
+ interface LoDashStatic {
+ /**
+ * Creates a function that invokes func with the this binding of the created function and arguments from start
+ * and beyond provided as an array.
+ *
+ * Note: This method is based on the rest parameter.
+ *
+ * @param func The function to apply a rest parameter to.
+ * @param start The start position of the rest parameter.
+ * @return Returns the new function.
+ */
+ rest<TResult extends Function>(
+ func: Function,
+ start?: number
+ ): TResult;
+
+ /**
+ * @see _.rest
+ */
+ rest<TResult extends Function, TFunc extends Function>(
+ func: TFunc,
+ start?: number
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.rest
+ */
+ rest<TResult extends Function>(start?: number): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.rest
+ */
+ rest<TResult extends Function>(start?: number): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.spread
+ interface LoDashStatic {
+ /**
+ * Creates a function that invokes func with the this binding of the created function and an array of arguments
+ * much like Function#apply.
+ *
+ * Note: This method is based on the spread operator.
+ *
+ * @param func The function to spread arguments over.
+ * @return Returns the new function.
+ */
+ spread<F extends Function, T extends Function>(func: F): T;
+
+ /**
+ * @see _.spread
+ */
+ spread<T extends Function>(func: Function): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.spread
+ */
+ spread<T extends Function>(): LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.spread
+ */
+ spread<T extends Function>(): LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.throttle
+ interface ThrottleSettings {
+ /**
+ * If you'd like to disable the leading-edge call, pass this as false.
+ */
+ leading?: boolean;
+
+ /**
+ * If you'd like to disable the execution on the trailing-edge, pass false.
+ */
+ trailing?: boolean;
+ }
+
+ interface LoDashStatic {
+ /**
+ * Creates a throttled function that only invokes func at most once per every wait milliseconds. The throttled
+ * function comes with a cancel method to cancel delayed invocations and a flush method to immediately invoke
+ * them. Provide an options object to indicate that func should be invoked on the leading and/or trailing edge
+ * of the wait timeout. Subsequent calls to the throttled function return the result of the last func call.
+ *
+ * Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only if
+ * the the throttled function is invoked more than once during the wait timeout.
+ *
+ * @param func The function to throttle.
+ * @param wait The number of milliseconds to throttle invocations to.
+ * @param options The options object.
+ * @param options.leading Specify invoking on the leading edge of the timeout.
+ * @param options.trailing Specify invoking on the trailing edge of the timeout.
+ * @return Returns the new throttled function.
+ */
+ throttle<T extends Function>(
+ func: T,
+ wait?: number,
+ options?: ThrottleSettings
+ ): T & Cancelable;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.throttle
+ */
+ throttle(
+ wait?: number,
+ options?: ThrottleSettings
+ ): LoDashImplicitObjectWrapper<T & Cancelable>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.throttle
+ */
+ throttle(
+ wait?: number,
+ options?: ThrottleSettings
+ ): LoDashExplicitObjectWrapper<T & Cancelable>;
+ }
+
+ //_.unary
+ interface LoDashStatic {
+ /**
+ * Creates a function that accepts up to one argument, ignoring any
+ * additional arguments.
+ *
+ * @static
+ * @memberOf _
+ * @category Function
+ * @param {Function} func The function to cap arguments for.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * _.map(['6', '8', '10'], _.unary(parseInt));
+ * // => [6, 8, 10]
+ */
+ unary<T extends Function>(func: T): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.unary
+ */
+ unary(): LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.unary
+ */
+ unary(): LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.wrap
+ interface LoDashStatic {
+ /**
+ * Creates a function that provides value to the wrapper function as its first argument. Any additional
+ * arguments provided to the function are appended to those provided to the wrapper function. The wrapper is
+ * invoked with the this binding of the created function.
+ *
+ * @param value The value to wrap.
+ * @param wrapper The wrapper function.
+ * @return Returns the new function.
+ */
+ wrap<V, W extends Function, R extends Function>(
+ value: V,
+ wrapper: W
+ ): R;
+
+ /**
+ * @see _.wrap
+ */
+ wrap<V, R extends Function>(
+ value: V,
+ wrapper: Function
+ ): R;
+
+ /**
+ * @see _.wrap
+ */
+ wrap<R extends Function>(
+ value: any,
+ wrapper: Function
+ ): R;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.wrap
+ */
+ wrap<W extends Function, R extends Function>(wrapper: W): LoDashImplicitObjectWrapper<R>;
+
+ /**
+ * @see _.wrap
+ */
+ wrap<R extends Function>(wrapper: Function): LoDashImplicitObjectWrapper<R>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.wrap
+ */
+ wrap<W extends Function, R extends Function>(wrapper: W): LoDashImplicitObjectWrapper<R>;
+
+ /**
+ * @see _.wrap
+ */
+ wrap<R extends Function>(wrapper: Function): LoDashImplicitObjectWrapper<R>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.wrap
+ */
+ wrap<W extends Function, R extends Function>(wrapper: W): LoDashImplicitObjectWrapper<R>;
+
+ /**
+ * @see _.wrap
+ */
+ wrap<R extends Function>(wrapper: Function): LoDashImplicitObjectWrapper<R>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.wrap
+ */
+ wrap<W extends Function, R extends Function>(wrapper: W): LoDashExplicitObjectWrapper<R>;
+
+ /**
+ * @see _.wrap
+ */
+ wrap<R extends Function>(wrapper: Function): LoDashExplicitObjectWrapper<R>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.wrap
+ */
+ wrap<W extends Function, R extends Function>(wrapper: W): LoDashExplicitObjectWrapper<R>;
+
+ /**
+ * @see _.wrap
+ */
+ wrap<R extends Function>(wrapper: Function): LoDashExplicitObjectWrapper<R>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.wrap
+ */
+ wrap<W extends Function, R extends Function>(wrapper: W): LoDashExplicitObjectWrapper<R>;
+
+ /**
+ * @see _.wrap
+ */
+ wrap<R extends Function>(wrapper: Function): LoDashExplicitObjectWrapper<R>;
+ }
+
+ /********
+ * Lang *
+ ********/
+
+ //_.castArray
+ interface LoDashStatic {
+ /**
+ * Casts value as an array if it’s not one.
+ *
+ * @param value The value to inspect.
+ * @return Returns the cast array.
+ */
+ castArray<T>(value: T): T[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.castArray
+ */
+ castArray(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.castArray
+ */
+ castArray(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.castArray
+ */
+ castArray(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.castArray
+ */
+ castArray(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.castArray
+ */
+ castArray(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.castArray
+ */
+ castArray(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.clone
+ interface LoDashStatic {
+ /**
+ * Creates a shallow clone of value.
+ *
+ * Note: This method is loosely based on the structured clone algorithm and supports cloning arrays,
+ * array buffers, booleans, date objects, maps, numbers, Object objects, regexes, sets, strings, symbols,
+ * and typed arrays. The own enumerable properties of arguments objects are cloned as plain objects. An empty
+ * object is returned for uncloneable values such as error objects, functions, DOM nodes, and WeakMaps.
+ *
+ * @param value The value to clone.
+ * @return Returns the cloned value.
+ */
+ clone<T>(value: T): T;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.clone
+ */
+ clone(): T;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+
+ /**
+ * @see _.clone
+ */
+ clone(): T[];
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.clone
+ */
+ clone(): T;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.clone
+ */
+ clone(): LoDashExplicitWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+
+ /**
+ * @see _.clone
+ */
+ clone(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.clone
+ */
+ clone(): LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.cloneDeep
+ interface LoDashStatic {
+ /**
+ * This method is like _.clone except that it recursively clones value.
+ *
+ * @param value The value to recursively clone.
+ * @return Returns the deep cloned value.
+ */
+ cloneDeep<T>(value: T): T;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.cloneDeep
+ */
+ cloneDeep(): T;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.cloneDeep
+ */
+ cloneDeep(): T[];
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.cloneDeep
+ */
+ cloneDeep(): T;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.cloneDeep
+ */
+ cloneDeep(): LoDashExplicitWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.cloneDeep
+ */
+ cloneDeep(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.cloneDeep
+ */
+ cloneDeep(): LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.cloneDeepWith
+ interface CloneDeepWithCustomizer<TValue, TResult> {
+ (value: TValue): TResult;
+ }
+
+ interface LoDashStatic {
+ /**
+ * This method is like _.cloneWith except that it recursively clones value.
+ *
+ * @param value The value to recursively clone.
+ * @param customizer The function to customize cloning.
+ * @return Returns the deep cloned value.
+ */
+ cloneDeepWith<TResult>(
+ value: any,
+ customizer?: CloneDeepWithCustomizer<any, TResult>
+ ): TResult;
+
+ /**
+ * @see _.clonDeepeWith
+ */
+ cloneDeepWith<T, TResult>(
+ value: T,
+ customizer?: CloneDeepWithCustomizer<T, TResult>
+ ): TResult;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.cloneDeepWith
+ */
+ cloneDeepWith<TResult>(
+ customizer?: CloneDeepWithCustomizer<T, TResult>
+ ): TResult;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.cloneDeepWith
+ */
+ cloneDeepWith<TResult>(
+ customizer?: CloneDeepWithCustomizer<T[], TResult>
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.cloneDeepWith
+ */
+ cloneDeepWith<TResult>(
+ customizer?: CloneDeepWithCustomizer<T, TResult>
+ ): TResult;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.cloneDeepWith
+ */
+ cloneDeepWith<TResult extends (number|string|boolean)>(
+ customizer?: CloneDeepWithCustomizer<T, TResult>
+ ): LoDashExplicitWrapper<TResult>;
+
+ /**
+ * @see _.cloneDeepWith
+ */
+ cloneDeepWith<TResult>(
+ customizer?: CloneDeepWithCustomizer<T, TResult[]>
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.cloneDeepWith
+ */
+ cloneDeepWith<TResult extends Object>(
+ customizer?: CloneDeepWithCustomizer<T, TResult>
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.cloneDeepWith
+ */
+ cloneDeepWith<TResult extends (number|string|boolean)>(
+ customizer?: CloneDeepWithCustomizer<T[], TResult>
+ ): LoDashExplicitWrapper<TResult>;
+
+ /**
+ * @see _.cloneDeepWith
+ */
+ cloneDeepWith<TResult>(
+ customizer?: CloneDeepWithCustomizer<T[], TResult[]>
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.cloneDeepWith
+ */
+ cloneDeepWith<TResult extends Object>(
+ customizer?: CloneDeepWithCustomizer<T[], TResult>
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.cloneDeepWith
+ */
+ cloneDeepWith<TResult extends (number|string|boolean)>(
+ customizer?: CloneDeepWithCustomizer<T, TResult>
+ ): LoDashExplicitWrapper<TResult>;
+
+ /**
+ * @see _.cloneDeepWith
+ */
+ cloneDeepWith<TResult>(
+ customizer?: CloneDeepWithCustomizer<T, TResult[]>
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.cloneDeepWith
+ */
+ cloneDeepWith<TResult extends Object>(
+ customizer?: CloneDeepWithCustomizer<T, TResult>
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.cloneWith
+ interface CloneWithCustomizer<TValue, TResult> {
+ (value: TValue): TResult;
+ }
+
+ interface LoDashStatic {
+ /**
+ * This method is like _.clone except that it accepts customizer which is invoked to produce the cloned value.
+ * If customizer returns undefined cloning is handled by the method instead.
+ *
+ * @param value The value to clone.
+ * @param customizer The function to customize cloning.
+ * @return Returns the cloned value.
+ */
+ cloneWith<TResult>(
+ value: any,
+ customizer?: CloneWithCustomizer<any, TResult>
+ ): TResult;
+
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<T, TResult>(
+ value: T,
+ customizer?: CloneWithCustomizer<T, TResult>
+ ): TResult;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<TResult>(
+ customizer?: CloneWithCustomizer<T, TResult>
+ ): TResult;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<TResult>(
+ customizer?: CloneWithCustomizer<T[], TResult>
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<TResult>(
+ customizer?: CloneWithCustomizer<T, TResult>
+ ): TResult;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<TResult extends (number|string|boolean)>(
+ customizer?: CloneWithCustomizer<T, TResult>
+ ): LoDashExplicitWrapper<TResult>;
+
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<TResult>(
+ customizer?: CloneWithCustomizer<T, TResult[]>
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<TResult extends Object>(
+ customizer?: CloneWithCustomizer<T, TResult>
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<TResult extends (number|string|boolean)>(
+ customizer?: CloneWithCustomizer<T[], TResult>
+ ): LoDashExplicitWrapper<TResult>;
+
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<TResult>(
+ customizer?: CloneWithCustomizer<T[], TResult[]>
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<TResult extends Object>(
+ customizer?: CloneWithCustomizer<T[], TResult>
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<TResult extends (number|string|boolean)>(
+ customizer?: CloneWithCustomizer<T, TResult>
+ ): LoDashExplicitWrapper<TResult>;
+
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<TResult>(
+ customizer?: CloneWithCustomizer<T, TResult[]>
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.cloneWith
+ */
+ cloneWith<TResult extends Object>(
+ customizer?: CloneWithCustomizer<T, TResult>
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.eq
+ interface LoDashStatic {
+ /**
+ * Performs a [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'user': 'fred' };
+ * var other = { 'user': 'fred' };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+ eq(
+ value: any,
+ other: any
+ ): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isEqual
+ */
+ eq(
+ other: any
+ ): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isEqual
+ */
+ eq(
+ other: any
+ ): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.gt
+ interface LoDashStatic {
+ /**
+ * Checks if value is greater than other.
+ *
+ * @param value The value to compare.
+ * @param other The other value to compare.
+ * @return Returns true if value is greater than other, else false.
+ */
+ gt(
+ value: any,
+ other: any
+ ): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.gt
+ */
+ gt(other: any): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.gt
+ */
+ gt(other: any): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.gte
+ interface LoDashStatic {
+ /**
+ * Checks if value is greater than or equal to other.
+ *
+ * @param value The value to compare.
+ * @param other The other value to compare.
+ * @return Returns true if value is greater than or equal to other, else false.
+ */
+ gte(
+ value: any,
+ other: any
+ ): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.gte
+ */
+ gte(other: any): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.gte
+ */
+ gte(other: any): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isArguments
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as an arguments object.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is correctly classified, else false.
+ */
+ isArguments(value?: any): value is IArguments;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isArguments
+ */
+ isArguments(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isArguments
+ */
+ isArguments(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isArray
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as an Array object.
+ * @param value The value to check.
+ *
+ * @return Returns true if value is correctly classified, else false.
+ */
+ isArray<T>(value?: any): value is T[];
+ }
+
+ interface LoDashImplicitWrapperBase<T,TWrapper> {
+ /**
+ * @see _.isArray
+ */
+ isArray(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T,TWrapper> {
+ /**
+ * @see _.isArray
+ */
+ isArray(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isArrayBuffer
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as an ArrayBuffer object.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is correctly classified, else false.
+ */
+ isArrayBuffer(value?: any): value is ArrayBuffer;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isArrayBuffer
+ */
+ isArrayBuffer(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isArrayBuffer
+ */
+ isArrayBuffer(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isArrayLike
+ interface LoDashStatic {
+ /**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+ isArrayLike<T>(value?: any): value is T[];
+ }
+
+ interface LoDashImplicitWrapperBase<T,TWrapper> {
+ /**
+ * @see _.isArrayLike
+ */
+ isArrayLike(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T,TWrapper> {
+ /**
+ * @see _.isArrayLike
+ */
+ isArrayLike(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isArrayLikeObject
+ interface LoDashStatic {
+ /**
+ * This method is like `_.isArrayLike` except that it also checks if `value`
+ * is an object.
+ *
+ * @static
+ * @memberOf _
+ * @type Function
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array-like object, else `false`.
+ * @example
+ *
+ * _.isArrayLikeObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLikeObject(document.body.children);
+ * // => true
+ *
+ * _.isArrayLikeObject('abc');
+ * // => false
+ *
+ * _.isArrayLikeObject(_.noop);
+ * // => false
+ */
+ isArrayLikeObject<T>(value?: any): value is T[];
+ }
+
+ interface LoDashImplicitWrapperBase<T,TWrapper> {
+ /**
+ * @see _.isArrayLikeObject
+ */
+ isArrayLikeObject(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T,TWrapper> {
+ /**
+ * @see _.isArrayLikeObject
+ */
+ isArrayLikeObject(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isBoolean
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as a boolean primitive or object.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is correctly classified, else false.
+ */
+ isBoolean(value?: any): value is boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isBoolean
+ */
+ isBoolean(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isBoolean
+ */
+ isBoolean(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isBuffer
+ interface LoDashStatic {
+ /**
+ * Checks if value is a buffer.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is a buffer, else false.
+ */
+ isBuffer(value?: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isBuffer
+ */
+ isBuffer(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isBuffer
+ */
+ isBuffer(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isDate
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as a Date object.
+ * @param value The value to check.
+ *
+ * @return Returns true if value is correctly classified, else false.
+ */
+ isDate(value?: any): value is Date;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isDate
+ */
+ isDate(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isDate
+ */
+ isDate(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isElement
+ interface LoDashStatic {
+ /**
+ * Checks if value is a DOM element.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is a DOM element, else false.
+ */
+ isElement(value?: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isElement
+ */
+ isElement(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isElement
+ */
+ isElement(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isEmpty
+ interface LoDashStatic {
+ /**
+ * Checks if value is empty. A value is considered empty unless it’s an arguments object, array, string, or
+ * jQuery-like collection with a length greater than 0 or an object with own enumerable properties.
+ *
+ * @param value The value to inspect.
+ * @return Returns true if value is empty, else false.
+ */
+ isEmpty(value?: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isEmpty
+ */
+ isEmpty(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isEmpty
+ */
+ isEmpty(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isEqual
+ interface LoDashStatic {
+ /**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent.
+ *
+ * **Note:** This method supports comparing arrays, array buffers, booleans,
+ * date objects, error objects, maps, numbers, `Object` objects, regexes,
+ * sets, strings, symbols, and typed arrays. `Object` objects are compared
+ * by their own, not inherited, enumerable properties. Functions and DOM
+ * nodes are **not** supported.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'user': 'fred' };
+ * var other = { 'user': 'fred' };
+ *
+ * _.isEqual(object, other);
+ * // => true
+ *
+ * object === other;
+ * // => false
+ */
+ isEqual(
+ value: any,
+ other: any
+ ): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isEqual
+ */
+ isEqual(
+ other: any
+ ): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isEqual
+ */
+ isEqual(
+ other: any
+ ): LoDashExplicitWrapper<boolean>;
+ }
+
+ // _.isEqualWith
+ interface IsEqualCustomizer {
+ (value: any, other: any, indexOrKey?: number|string): boolean;
+ }
+
+ interface LoDashStatic {
+ /**
+ * This method is like `_.isEqual` except that it accepts `customizer` which is
+ * invoked to compare values. If `customizer` returns `undefined` comparisons are
+ * handled by the method instead. The `customizer` is invoked with up to seven arguments:
+ * (objValue, othValue [, index|key, object, other, stack]).
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * function isGreeting(value) {
+ * return /^h(?:i|ello)$/.test(value);
+ * }
+ *
+ * function customizer(objValue, othValue) {
+ * if (isGreeting(objValue) && isGreeting(othValue)) {
+ * return true;
+ * }
+ * }
+ *
+ * var array = ['hello', 'goodbye'];
+ * var other = ['hi', 'goodbye'];
+ *
+ * _.isEqualWith(array, other, customizer);
+ * // => true
+ */
+ isEqualWith(
+ value: any,
+ other: any,
+ customizer: IsEqualCustomizer
+ ): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isEqualWith
+ */
+ isEqualWith(
+ other: any,
+ customizer: IsEqualCustomizer
+ ): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isEqualWith
+ */
+ isEqualWith(
+ other: any,
+ customizer: IsEqualCustomizer
+ ): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isError
+ interface LoDashStatic {
+ /**
+ * Checks if value is an Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, or URIError
+ * object.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is an error object, else false.
+ */
+ isError(value: any): value is Error;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isError
+ */
+ isError(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isError
+ */
+ isError(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isFinite
+ interface LoDashStatic {
+ /**
+ * Checks if value is a finite primitive number.
+ *
+ * Note: This method is based on Number.isFinite.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is a finite number, else false.
+ */
+ isFinite(value?: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isFinite
+ */
+ isFinite(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isFinite
+ */
+ isFinite(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isFunction
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as a Function object.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is correctly classified, else false.
+ */
+ isFunction(value?: any): value is Function;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isFunction
+ */
+ isFunction(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isFunction
+ */
+ isFunction(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isInteger
+ interface LoDashStatic {
+ /**
+ * Checks if `value` is an integer.
+ *
+ * **Note:** This method is based on [`Number.isInteger`](https://mdn.io/Number/isInteger).
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an integer, else `false`.
+ * @example
+ *
+ * _.isInteger(3);
+ * // => true
+ *
+ * _.isInteger(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isInteger(Infinity);
+ * // => false
+ *
+ * _.isInteger('3');
+ * // => false
+ */
+ isInteger(value?: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isInteger
+ */
+ isInteger(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isInteger
+ */
+ isInteger(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isLength
+ interface LoDashStatic {
+ /**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This function is loosely based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+ isLength(value?: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isLength
+ */
+ isLength(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isLength
+ */
+ isLength(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isMap
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as a Map object.
+ *
+ * @param value The value to check.
+ * @returns Returns true if value is correctly classified, else false.
+ */
+ isMap<K, V>(value?: any): value is Map<K, V>;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isMap
+ */
+ isMap(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isMap
+ */
+ isMap(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isMatch
+ interface isMatchCustomizer {
+ (value: any, other: any, indexOrKey?: number|string): boolean;
+ }
+
+ interface LoDashStatic {
+ /**
+ * Performs a deep comparison between `object` and `source` to determine if
+ * `object` contains equivalent property values.
+ *
+ * **Note:** This method supports comparing the same values as `_.isEqual`.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ * @example
+ *
+ * var object = { 'user': 'fred', 'age': 40 };
+ *
+ * _.isMatch(object, { 'age': 40 });
+ * // => true
+ *
+ * _.isMatch(object, { 'age': 36 });
+ * // => false
+ */
+ isMatch(object: Object, source: Object): boolean;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.isMatch
+ */
+ isMatch(source: Object): boolean;
+ }
+
+ //_.isMatchWith
+ interface isMatchWithCustomizer {
+ (value: any, other: any, indexOrKey?: number|string): boolean;
+ }
+
+ interface LoDashStatic {
+ /**
+ * This method is like `_.isMatch` except that it accepts `customizer` which
+ * is invoked to compare values. If `customizer` returns `undefined` comparisons
+ * are handled by the method instead. The `customizer` is invoked with three
+ * arguments: (objValue, srcValue, index|key, object, source).
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ * @example
+ *
+ * function isGreeting(value) {
+ * return /^h(?:i|ello)$/.test(value);
+ * }
+ *
+ * function customizer(objValue, srcValue) {
+ * if (isGreeting(objValue) && isGreeting(srcValue)) {
+ * return true;
+ * }
+ * }
+ *
+ * var object = { 'greeting': 'hello' };
+ * var source = { 'greeting': 'hi' };
+ *
+ * _.isMatchWith(object, source, customizer);
+ * // => true
+ */
+ isMatchWith(object: Object, source: Object, customizer: isMatchWithCustomizer): boolean;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.isMatchWith
+ */
+ isMatchWith(source: Object, customizer: isMatchWithCustomizer): boolean;
+ }
+
+ //_.isNaN
+ interface LoDashStatic {
+ /**
+ * Checks if value is NaN.
+ *
+ * Note: This method is not the same as isNaN which returns true for undefined and other non-numeric values.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is NaN, else false.
+ */
+ isNaN(value?: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isNaN
+ */
+ isNaN(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isNaN
+ */
+ isNaN(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isNative
+ interface LoDashStatic {
+ /**
+ * Checks if value is a native function.
+ * @param value The value to check.
+ *
+ * @retrun Returns true if value is a native function, else false.
+ */
+ isNative(value: any): value is Function;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isNative
+ */
+ isNative(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isNative
+ */
+ isNative(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isNil
+ interface LoDashStatic {
+ /**
+ * Checks if `value` is `null` or `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
+ * @example
+ *
+ * _.isNil(null);
+ * // => true
+ *
+ * _.isNil(void 0);
+ * // => true
+ *
+ * _.isNil(NaN);
+ * // => false
+ */
+ isNil(value?: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isNil
+ */
+ isNil(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isNil
+ */
+ isNil(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isNull
+ interface LoDashStatic {
+ /**
+ * Checks if value is null.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is null, else false.
+ */
+ isNull(value?: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isNull
+ */
+ isNull(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isNull
+ */
+ isNull(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isNumber
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as a Number primitive or object.
+ *
+ * Note: To exclude Infinity, -Infinity, and NaN, which are classified as numbers, use the _.isFinite method.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is correctly classified, else false.
+ */
+ isNumber(value?: any): value is number;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isNumber
+ */
+ isNumber(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isNumber
+ */
+ isNumber(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isObject
+ interface LoDashStatic {
+ /**
+ * Checks if value is the language type of Object. (e.g. arrays, functions, objects, regexes, new Number(0),
+ * and new String(''))
+ *
+ * @param value The value to check.
+ * @return Returns true if value is an object, else false.
+ */
+ isObject(value?: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isObject
+ */
+ isObject(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isObject
+ */
+ isObject(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isObjectLike
+ interface LoDashStatic {
+ /**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+ isObjectLike(value?: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isObjectLike
+ */
+ isObjectLike(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isObjectLike
+ */
+ isObjectLike(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isPlainObject
+ interface LoDashStatic {
+ /**
+ * Checks if value is a plain object, that is, an object created by the Object constructor or one with a
+ * [[Prototype]] of null.
+ *
+ * Note: This method assumes objects created by the Object constructor have no inherited enumerable properties.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is a plain object, else false.
+ */
+ isPlainObject(value?: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isPlainObject
+ */
+ isPlainObject(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isPlainObject
+ */
+ isPlainObject(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isRegExp
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as a RegExp object.
+ * @param value The value to check.
+ *
+ * @return Returns true if value is correctly classified, else false.
+ */
+ isRegExp(value?: any): value is RegExp;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isRegExp
+ */
+ isRegExp(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isRegExp
+ */
+ isRegExp(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isSafeInteger
+ interface LoDashStatic {
+ /**
+ * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
+ * double precision number which isn't the result of a rounded unsafe integer.
+ *
+ * **Note:** This method is based on [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
+ * @example
+ *
+ * _.isSafeInteger(3);
+ * // => true
+ *
+ * _.isSafeInteger(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isSafeInteger(Infinity);
+ * // => false
+ *
+ * _.isSafeInteger('3');
+ * // => false
+ */
+ isSafeInteger(value: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isSafeInteger
+ */
+ isSafeInteger(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isSafeInteger
+ */
+ isSafeInteger(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isSet
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as a Set object.
+ *
+ * @param value The value to check.
+ * @returns Returns true if value is correctly classified, else false.
+ */
+ isSet<T>(value?: any): value is Set<T>;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isSet
+ */
+ isSet(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isSet
+ */
+ isSet(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isString
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as a String primitive or object.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is correctly classified, else false.
+ */
+ isString(value?: any): value is string;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isString
+ */
+ isString(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isString
+ */
+ isString(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isSymbol
+ interface LoDashStatic {
+ /**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+ isSymbol(value: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isSymbol
+ */
+ isSymbol(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isSymbol
+ */
+ isSymbol(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isTypedArray
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as a typed array.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is correctly classified, else false.
+ */
+ isTypedArray(value: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isTypedArray
+ */
+ isTypedArray(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isTypedArray
+ */
+ isTypedArray(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isUndefined
+ interface LoDashStatic {
+ /**
+ * Checks if value is undefined.
+ *
+ * @param value The value to check.
+ * @return Returns true if value is undefined, else false.
+ */
+ isUndefined(value: any): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isUndefined
+ */
+ isUndefined(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * see _.isUndefined
+ */
+ isUndefined(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isWeakMap
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as a WeakMap object.
+ *
+ * @param value The value to check.
+ * @returns Returns true if value is correctly classified, else false.
+ */
+ isWeakMap<K, V>(value?: any): value is WeakMap<K, V>;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isSet
+ */
+ isWeakMap(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isSet
+ */
+ isWeakMap(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.isWeakSet
+ interface LoDashStatic {
+ /**
+ * Checks if value is classified as a WeakSet object.
+ *
+ * @param value The value to check.
+ * @returns Returns true if value is correctly classified, else false.
+ */
+ isWeakSet<T>(value?: any): value is WeakSet<T>;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isWeakSet
+ */
+ isWeakSet(): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.isWeakSet
+ */
+ isWeakSet(): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.lt
+ interface LoDashStatic {
+ /**
+ * Checks if value is less than other.
+ *
+ * @param value The value to compare.
+ * @param other The other value to compare.
+ * @return Returns true if value is less than other, else false.
+ */
+ lt(
+ value: any,
+ other: any
+ ): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.lt
+ */
+ lt(other: any): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.lt
+ */
+ lt(other: any): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.lte
+ interface LoDashStatic {
+ /**
+ * Checks if value is less than or equal to other.
+ *
+ * @param value The value to compare.
+ * @param other The other value to compare.
+ * @return Returns true if value is less than or equal to other, else false.
+ */
+ lte(
+ value: any,
+ other: any
+ ): boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.lte
+ */
+ lte(other: any): boolean;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.lte
+ */
+ lte(other: any): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.toArray
+ interface LoDashStatic {
+ /**
+ * Converts value to an array.
+ *
+ * @param value The value to convert.
+ * @return Returns the converted array.
+ */
+ toArray<T>(value: List<T>|Dictionary<T>|NumericDictionary<T>): T[];
+
+ /**
+ * @see _.toArray
+ */
+ toArray<TValue, TResult>(value: TValue): TResult[];
+
+ /**
+ * @see _.toArray
+ */
+ toArray<TResult>(value?: any): TResult[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.toArray
+ */
+ toArray<TResult>(): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.toArray
+ */
+ toArray(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.toArray
+ */
+ toArray<TResult>(): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.toArray
+ */
+ toArray<TResult>(): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.toArray
+ */
+ toArray(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.toArray
+ */
+ toArray<TResult>(): LoDashExplicitArrayWrapper<TResult>;
+ }
+
+ //_.toPlainObject
+ interface LoDashStatic {
+ /**
+ * Converts value to a plain object flattening inherited enumerable properties of value to own properties
+ * of the plain object.
+ *
+ * @param value The value to convert.
+ * @return Returns the converted plain object.
+ */
+ toPlainObject<TResult extends {}>(value?: any): TResult;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.toPlainObject
+ */
+ toPlainObject<TResult extends {}>(): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ //_.toInteger
+ interface LoDashStatic {
+ /**
+ * Converts `value` to an integer.
+ *
+ * **Note:** This function is loosely based on [`ToInteger`](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger).
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.toInteger(3);
+ * // => 3
+ *
+ * _.toInteger(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toInteger(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toInteger('3');
+ * // => 3
+ */
+ toInteger(value: any): number;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.toInteger
+ */
+ toInteger(): LoDashImplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.toInteger
+ */
+ toInteger(): LoDashExplicitWrapper<number>;
+ }
+
+ //_.toLength
+ interface LoDashStatic {
+ /**
+ * Converts `value` to an integer suitable for use as the length of an
+ * array-like object.
+ *
+ * **Note:** This method is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @return {number} Returns the converted integer.
+ * @example
+ *
+ * _.toLength(3);
+ * // => 3
+ *
+ * _.toLength(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toLength(Infinity);
+ * // => 4294967295
+ *
+ * _.toLength('3');
+ * // => 3
+ */
+ toLength(value: any): number;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.toLength
+ */
+ toLength(): LoDashImplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.toLength
+ */
+ toLength(): LoDashExplicitWrapper<number>;
+ }
+
+ //_.toNumber
+ interface LoDashStatic {
+ /**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3);
+ * // => 3
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3');
+ * // => 3
+ */
+ toNumber(value: any): number;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.toNumber
+ */
+ toNumber(): LoDashImplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.toNumber
+ */
+ toNumber(): LoDashExplicitWrapper<number>;
+ }
+
+ //_.toSafeInteger
+ interface LoDashStatic {
+ /**
+ * Converts `value` to a safe integer. A safe integer can be compared and
+ * represented correctly.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.toSafeInteger(3);
+ * // => 3
+ *
+ * _.toSafeInteger(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toSafeInteger(Infinity);
+ * // => 9007199254740991
+ *
+ * _.toSafeInteger('3');
+ * // => 3
+ */
+ toSafeInteger(value: any): number;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.toSafeInteger
+ */
+ toSafeInteger(): LoDashImplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.toSafeInteger
+ */
+ toSafeInteger(): LoDashExplicitWrapper<number>;
+ }
+
+ //_.toString DUMMY
+ interface LoDashStatic {
+ /**
+ * Converts `value` to a string if it's not one. An empty string is returned
+ * for `null` and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+ toString(value: any): string;
+ }
+
+ /********
+ * Math *
+ ********/
+
+ //_.add
+ interface LoDashStatic {
+ /**
+ * Adds two numbers.
+ *
+ * @param augend The first number to add.
+ * @param addend The second number to add.
+ * @return Returns the sum.
+ */
+ add(
+ augend: number,
+ addend: number
+ ): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.add
+ */
+ add(addend: number): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.add
+ */
+ add(addend: number): LoDashExplicitWrapper<number>;
+ }
+
+ //_.ceil
+ interface LoDashStatic {
+ /**
+ * Calculates n rounded up to precision.
+ *
+ * @param n The number to round up.
+ * @param precision The precision to round up to.
+ * @return Returns the rounded up number.
+ */
+ ceil(
+ n: number,
+ precision?: number
+ ): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.ceil
+ */
+ ceil(precision?: number): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.ceil
+ */
+ ceil(precision?: number): LoDashExplicitWrapper<number>;
+ }
+
+ //_.floor
+ interface LoDashStatic {
+ /**
+ * Calculates n rounded down to precision.
+ *
+ * @param n The number to round down.
+ * @param precision The precision to round down to.
+ * @return Returns the rounded down number.
+ */
+ floor(
+ n: number,
+ precision?: number
+ ): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.floor
+ */
+ floor(precision?: number): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.floor
+ */
+ floor(precision?: number): LoDashExplicitWrapper<number>;
+ }
+
+ //_.max
+ interface LoDashStatic {
+ /**
+ * Computes the maximum value of `array`. If `array` is empty or falsey
+ * `undefined` is returned.
+ *
+ * @static
+ * @memberOf _
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @returns {*} Returns the maximum value.
+ */
+ max<T>(
+ collection: List<T>
+ ): T;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.max
+ */
+ max(): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.max
+ */
+ max<T>(): T;
+ }
+
+ //_.maxBy
+ interface LoDashStatic {
+ /**
+ * This method is like `_.max` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the criterion by which
+ * the value is ranked. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {*} Returns the maximum value.
+ * @example
+ *
+ * var objects = [{ 'n': 1 }, { 'n': 2 }];
+ *
+ * _.maxBy(objects, function(o) { return o.a; });
+ * // => { 'n': 2 }
+ *
+ * // using the `_.property` iteratee shorthand
+ * _.maxBy(objects, 'n');
+ * // => { 'n': 2 }
+ */
+ maxBy<T>(
+ collection: List<T>,
+ iteratee?: ListIterator<T, any>
+ ): T;
+
+ /**
+ * @see _.maxBy
+ */
+ maxBy<T>(
+ collection: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, any>
+ ): T;
+
+ /**
+ * @see _.maxBy
+ */
+ maxBy<T>(
+ collection: List<T>|Dictionary<T>,
+ iteratee?: string
+ ): T;
+
+ /**
+ * @see _.maxBy
+ */
+ maxBy<TObject extends {}, T>(
+ collection: List<T>|Dictionary<T>,
+ whereValue?: TObject
+ ): T;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.maxBy
+ */
+ maxBy(
+ iteratee?: ListIterator<T, any>
+ ): T;
+
+ /**
+ * @see _.maxBy
+ */
+ maxBy(
+ iteratee?: string
+ ): T;
+
+ /**
+ * @see _.maxBy
+ */
+ maxBy<TObject extends {}>(
+ whereValue?: TObject
+ ): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.maxBy
+ */
+ maxBy<T>(
+ iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>
+ ): T;
+
+ /**
+ * @see _.maxBy
+ */
+ maxBy<T>(
+ iteratee?: string
+ ): T;
+
+ /**
+ * @see _.maxBy
+ */
+ maxBy<TObject extends {}, T>(
+ whereValue?: TObject
+ ): T;
+ }
+
+ //_.mean
+ interface LoDashStatic {
+ /**
+ * Computes the mean of the values in `array`.
+ *
+ * @static
+ * @memberOf _
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @returns {number} Returns the mean.
+ * @example
+ *
+ * _.mean([4, 2, 8, 6]);
+ * // => 5
+ */
+ mean<T>(
+ collection: List<T>
+ ): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.mean
+ */
+ mean<T>(): number;
+
+ /**
+ * @see _.mean
+ */
+ mean(): number;
+ }
+
+ //_.min
+ interface LoDashStatic {
+ /**
+ * Computes the minimum value of `array`. If `array` is empty or falsey
+ * `undefined` is returned.
+ *
+ * @static
+ * @memberOf _
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @returns {*} Returns the minimum value.
+ */
+ min<T>(
+ collection: List<T>
+ ): T;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.min
+ */
+ min(): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.min
+ */
+ min<T>(): T;
+ }
+
+ //_.minBy
+ interface LoDashStatic {
+ /**
+ * This method is like `_.min` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the criterion by which
+ * the value is ranked. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {*} Returns the minimum value.
+ * @example
+ *
+ * var objects = [{ 'n': 1 }, { 'n': 2 }];
+ *
+ * _.minBy(objects, function(o) { return o.a; });
+ * // => { 'n': 1 }
+ *
+ * // using the `_.property` iteratee shorthand
+ * _.minBy(objects, 'n');
+ * // => { 'n': 1 }
+ */
+ minBy<T>(
+ collection: List<T>,
+ iteratee?: ListIterator<T, any>
+ ): T;
+
+ /**
+ * @see _.minBy
+ */
+ minBy<T>(
+ collection: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, any>
+ ): T;
+
+ /**
+ * @see _.minBy
+ */
+ minBy<T>(
+ collection: List<T>|Dictionary<T>,
+ iteratee?: string
+ ): T;
+
+ /**
+ * @see _.minBy
+ */
+ minBy<TObject extends {}, T>(
+ collection: List<T>|Dictionary<T>,
+ whereValue?: TObject
+ ): T;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.minBy
+ */
+ minBy(
+ iteratee?: ListIterator<T, any>
+ ): T;
+
+ /**
+ * @see _.minBy
+ */
+ minBy(
+ iteratee?: string
+ ): T;
+
+ /**
+ * @see _.minBy
+ */
+ minBy<TObject extends {}>(
+ whereValue?: TObject
+ ): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.minBy
+ */
+ minBy<T>(
+ iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>
+ ): T;
+
+ /**
+ * @see _.minBy
+ */
+ minBy<T>(
+ iteratee?: string
+ ): T;
+
+ /**
+ * @see _.minBy
+ */
+ minBy<TObject extends {}, T>(
+ whereValue?: TObject
+ ): T;
+ }
+
+ //_.round
+ interface LoDashStatic {
+ /**
+ * Calculates n rounded to precision.
+ *
+ * @param n The number to round.
+ * @param precision The precision to round to.
+ * @return Returns the rounded number.
+ */
+ round(
+ n: number,
+ precision?: number
+ ): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.round
+ */
+ round(precision?: number): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.round
+ */
+ round(precision?: number): LoDashExplicitWrapper<number>;
+ }
+
+ //_.sum
+ interface LoDashStatic {
+ /**
+ * Computes the sum of the values in `array`.
+ *
+ * @static
+ * @memberOf _
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @returns {number} Returns the sum.
+ * @example
+ *
+ * _.sum([4, 2, 8, 6]);
+ * // => 20
+ */
+ sum<T>(collection: List<T>): number;
+
+ /**
+ * @see _.sum
+ */
+ sum(collection: List<number>|Dictionary<number>): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.sum
+ */
+ sum(): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.sum
+ **/
+ sum<TValue>(): number;
+
+ /**
+ * @see _.sum
+ */
+ sum(): number;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.sum
+ */
+ sum(): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.sum
+ */
+ sum<TValue>(): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sum
+ */
+ sum(): LoDashExplicitWrapper<number>;
+ }
+
+ //_.sumBy
+ interface LoDashStatic {
+ /**
+ * This method is like `_.sum` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the value to be summed.
+ * The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {number} Returns the sum.
+ * @example
+ *
+ * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
+ *
+ * _.sumBy(objects, function(o) { return o.n; });
+ * // => 20
+ *
+ * // using the `_.property` iteratee shorthand
+ * _.sumBy(objects, 'n');
+ * // => 20
+ */
+ sumBy<T>(
+ collection: List<T>,
+ iteratee: ListIterator<T, number>
+ ): number;
+
+ /**
+ * @see _.sumBy
+ */
+ sumBy(
+ collection: List<{}>,
+ iteratee: string
+ ): number;
+
+ /**
+ * @see _.sumBy
+ */
+ sumBy(
+ collection: List<number>
+ ): number;
+
+ /**
+ * @see _.sumBy
+ */
+ sumBy(
+ collection: List<{}>,
+ iteratee: Dictionary<{}>
+ ): number;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.sumBy
+ */
+ sumBy(
+ iteratee: ListIterator<T, number>
+ ): number;
+
+ /**
+ * @see _.sumBy
+ */
+ sumBy(iteratee: string): number;
+
+ /**
+ * @see _.sumBy
+ */
+ sumBy(iteratee: Dictionary<{}>): number;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.sumBy
+ */
+ sumBy(
+ iteratee: ListIterator<{}, number>
+ ): number;
+
+ /**
+ * @see _.sumBy
+ */
+ sumBy(iteratee: string): number;
+
+ /**
+ * @see _.sumBy
+ */
+ sumBy(iteratee: Dictionary<{}>): number;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.sumBy
+ */
+ sumBy(
+ iteratee: ListIterator<T, number>
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sumBy
+ */
+ sumBy(iteratee: string): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sumBy
+ */
+ sumBy(): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sumBy
+ */
+ sumBy(iteratee: Dictionary<{}>): LoDashExplicitWrapper<number>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.sumBy
+ */
+ sumBy(
+ iteratee: ListIterator<{}, number>
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sumBy
+ */
+ sumBy(iteratee: string): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.sumBy
+ */
+ sumBy(iteratee: Dictionary<{}>): LoDashExplicitWrapper<number>;
+ }
+
+ /**********
+ * Number *
+ **********/
+
+ //_.subtract
+ interface LoDashStatic {
+ /**
+ * Subtract two numbers.
+ *
+ * @static
+ * @memberOf _
+ * @category Math
+ * @param {number} minuend The first number in a subtraction.
+ * @param {number} subtrahend The second number in a subtraction.
+ * @returns {number} Returns the difference.
+ * @example
+ *
+ * _.subtract(6, 4);
+ * // => 2
+ */
+ subtract(
+ minuend: number,
+ subtrahend: number
+ ): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.subtract
+ */
+ subtract(
+ subtrahend: number
+ ): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.subtract
+ */
+ subtract(
+ subtrahend: number
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ //_.clamp
+ interface LoDashStatic {
+ /**
+ * Clamps `number` within the inclusive `lower` and `upper` bounds.
+ *
+ * @static
+ * @memberOf _
+ * @category Number
+ * @param {number} number The number to clamp.
+ * @param {number} [lower] The lower bound.
+ * @param {number} upper The upper bound.
+ * @returns {number} Returns the clamped number.
+ * @example
+ *
+ * _.clamp(-10, -5, 5);
+ * // => -5
+ *
+ * _.clamp(10, -5, 5);
+ * // => 5
+ */
+ clamp(
+ number: number,
+ lower: number,
+ upper: number
+ ): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.clamp
+ */
+ clamp(
+ lower: number,
+ upper: number
+ ): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.clamp
+ */
+ clamp(
+ lower: number,
+ upper: number
+ ): LoDashExplicitWrapper<number>;
+ }
+
+ //_.inRange
+ interface LoDashStatic {
+ /**
+ * Checks if n is between start and up to but not including, end. If end is not specified it’s set to start
+ * with start then set to 0.
+ *
+ * @param n The number to check.
+ * @param start The start of the range.
+ * @param end The end of the range.
+ * @return Returns true if n is in the range, else false.
+ */
+ inRange(
+ n: number,
+ start: number,
+ end: number
+ ): boolean;
+
+
+ /**
+ * @see _.inRange
+ */
+ inRange(
+ n: number,
+ end: number
+ ): boolean;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.inRange
+ */
+ inRange(
+ start: number,
+ end: number
+ ): boolean;
+
+ /**
+ * @see _.inRange
+ */
+ inRange(end: number): boolean;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.inRange
+ */
+ inRange(
+ start: number,
+ end: number
+ ): LoDashExplicitWrapper<boolean>;
+
+ /**
+ * @see _.inRange
+ */
+ inRange(end: number): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.random
+ interface LoDashStatic {
+ /**
+ * Produces a random number between min and max (inclusive). If only one argument is provided a number between
+ * 0 and the given number is returned. If floating is true, or either min or max are floats, a floating-point
+ * number is returned instead of an integer.
+ *
+ * @param min The minimum possible value.
+ * @param max The maximum possible value.
+ * @param floating Specify returning a floating-point number.
+ * @return Returns the random number.
+ */
+ random(
+ min?: number,
+ max?: number,
+ floating?: boolean
+ ): number;
+
+ /**
+ * @see _.random
+ */
+ random(
+ min?: number,
+ floating?: boolean
+ ): number;
+
+ /**
+ * @see _.random
+ */
+ random(floating?: boolean): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.random
+ */
+ random(
+ max?: number,
+ floating?: boolean
+ ): number;
+
+ /**
+ * @see _.random
+ */
+ random(floating?: boolean): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.random
+ */
+ random(
+ max?: number,
+ floating?: boolean
+ ): LoDashExplicitWrapper<number>;
+
+ /**
+ * @see _.random
+ */
+ random(floating?: boolean): LoDashExplicitWrapper<number>;
+ }
+
+ /**********
+ * Object *
+ **********/
+
+ //_.assign
+ interface LoDashStatic {
+ /**
+ * Assigns own enumerable properties of source objects to the destination
+ * object. Source objects are applied from left to right. Subsequent sources
+ * overwrite property assignments of previous sources.
+ *
+ * **Note:** This method mutates `object` and is loosely based on
+ * [`Object.assign`](https://mdn.io/Object/assign).
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function Foo() {
+ * this.c = 3;
+ * }
+ *
+ * function Bar() {
+ * this.e = 5;
+ * }
+ *
+ * Foo.prototype.d = 4;
+ * Bar.prototype.f = 6;
+ *
+ * _.assign({ 'a': 1 }, new Foo, new Bar);
+ * // => { 'a': 1, 'c': 3, 'e': 5 }
+ */
+ assign<TObject, TSource>(
+ object: TObject,
+ source: TSource
+ ): TObject & TSource;
+
+ /**
+ * @see assign
+ */
+ assign<TObject, TSource1, TSource2>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2
+ ): TObject & TSource1 & TSource2;
+
+ /**
+ * @see assign
+ */
+ assign<TObject, TSource1, TSource2, TSource3>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): TObject & TSource1 & TSource2 & TSource3;
+
+ /**
+ * @see assign
+ */
+ assign<TObject, TSource1, TSource2, TSource3, TSource4>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): TObject & TSource1 & TSource2 & TSource3 & TSource4;
+
+ /**
+ * @see _.assign
+ */
+ assign<TObject>(object: TObject): TObject;
+
+ /**
+ * @see _.assign
+ */
+ assign<TResult>(
+ object: any,
+ ...otherArgs: any[]
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.assign
+ */
+ assign<TSource>(
+ source: TSource
+ ): LoDashImplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see assign
+ */
+ assign<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see assign
+ */
+ assign<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see assign
+ */
+ assign<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.assign
+ */
+ assign(): LoDashImplicitObjectWrapper<T>;
+
+ /**
+ * @see _.assign
+ */
+ assign<TResult>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.assign
+ */
+ assign<TSource>(
+ source: TSource
+ ): LoDashExplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see assign
+ */
+ assign<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see assign
+ */
+ assign<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see assign
+ */
+ assign<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.assign
+ */
+ assign(): LoDashExplicitObjectWrapper<T>;
+
+ /**
+ * @see _.assign
+ */
+ assign<TResult>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.assignWith
+ interface AssignCustomizer {
+ (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}): any;
+ }
+
+ interface LoDashStatic {
+ /**
+ * This method is like `_.assign` except that it accepts `customizer` which
+ * is invoked to produce the assigned values. If `customizer` returns `undefined`
+ * assignment is handled by the method instead. The `customizer` is invoked
+ * with five arguments: (objValue, srcValue, key, object, source).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} sources The source objects.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function customizer(objValue, srcValue) {
+ * return _.isUndefined(objValue) ? srcValue : objValue;
+ * }
+ *
+ * var defaults = _.partialRight(_.assignWith, customizer);
+ *
+ * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
+ * // => { 'a': 1, 'b': 2 }
+ */
+ assignWith<TObject, TSource>(
+ object: TObject,
+ source: TSource,
+ customizer: AssignCustomizer
+ ): TObject & TSource;
+
+ /**
+ * @see assignWith
+ */
+ assignWith<TObject, TSource1, TSource2>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ customizer: AssignCustomizer
+ ): TObject & TSource1 & TSource2;
+
+ /**
+ * @see assignWith
+ */
+ assignWith<TObject, TSource1, TSource2, TSource3>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ customizer: AssignCustomizer
+ ): TObject & TSource1 & TSource2 & TSource3;
+
+ /**
+ * @see assignWith
+ */
+ assignWith<TObject, TSource1, TSource2, TSource3, TSource4>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4,
+ customizer: AssignCustomizer
+ ): TObject & TSource1 & TSource2 & TSource3 & TSource4;
+
+ /**
+ * @see _.assignWith
+ */
+ assignWith<TObject>(object: TObject): TObject;
+
+ /**
+ * @see _.assignWith
+ */
+ assignWith<TResult>(
+ object: any,
+ ...otherArgs: any[]
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.assignWith
+ */
+ assignWith<TSource>(
+ source: TSource,
+ customizer: AssignCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see assignWith
+ */
+ assignWith<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2,
+ customizer: AssignCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see assignWith
+ */
+ assignWith<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ customizer: AssignCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see assignWith
+ */
+ assignWith<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4,
+ customizer: AssignCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.assignWith
+ */
+ assignWith(): LoDashImplicitObjectWrapper<T>;
+
+ /**
+ * @see _.assignWith
+ */
+ assignWith<TResult>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.assignWith
+ */
+ assignWith<TSource>(
+ source: TSource,
+ customizer: AssignCustomizer
+ ): LoDashExplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see assignWith
+ */
+ assignWith<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2,
+ customizer: AssignCustomizer
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see assignWith
+ */
+ assignWith<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ customizer: AssignCustomizer
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see assignWith
+ */
+ assignWith<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4,
+ customizer: AssignCustomizer
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.assignWith
+ */
+ assignWith(): LoDashExplicitObjectWrapper<T>;
+
+ /**
+ * @see _.assignWith
+ */
+ assignWith<TResult>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.assignIn
+ interface LoDashStatic {
+ /**
+ * This method is like `_.assign` except that it iterates over own and
+ * inherited source properties.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @alias extend
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function Foo() {
+ * this.b = 2;
+ * }
+ *
+ * function Bar() {
+ * this.d = 4;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ * Bar.prototype.e = 5;
+ *
+ * _.assignIn({ 'a': 1 }, new Foo, new Bar);
+ * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5 }
+ */
+ assignIn<TObject, TSource>(
+ object: TObject,
+ source: TSource
+ ): TObject & TSource;
+
+ /**
+ * @see assignIn
+ */
+ assignIn<TObject, TSource1, TSource2>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2
+ ): TObject & TSource1 & TSource2;
+
+ /**
+ * @see assignIn
+ */
+ assignIn<TObject, TSource1, TSource2, TSource3>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): TObject & TSource1 & TSource2 & TSource3;
+
+ /**
+ * @see assignIn
+ */
+ assignIn<TObject, TSource1, TSource2, TSource3, TSource4>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): TObject & TSource1 & TSource2 & TSource3 & TSource4;
+
+ /**
+ * @see _.assignIn
+ */
+ assignIn<TObject>(object: TObject): TObject;
+
+ /**
+ * @see _.assignIn
+ */
+ assignIn<TResult>(
+ object: any,
+ ...otherArgs: any[]
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.assignIn
+ */
+ assignIn<TSource>(
+ source: TSource
+ ): LoDashImplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see assignIn
+ */
+ assignIn<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see assignIn
+ */
+ assignIn<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see assignIn
+ */
+ assignIn<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.assignIn
+ */
+ assignIn(): LoDashImplicitObjectWrapper<T>;
+
+ /**
+ * @see _.assignIn
+ */
+ assignIn<TResult>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.assignIn
+ */
+ assignIn<TSource>(
+ source: TSource
+ ): LoDashExplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see assignIn
+ */
+ assignIn<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see assignIn
+ */
+ assignIn<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see assignIn
+ */
+ assignIn<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.assignIn
+ */
+ assignIn(): LoDashExplicitObjectWrapper<T>;
+
+ /**
+ * @see _.assignIn
+ */
+ assignIn<TResult>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.assignInWith
+ interface AssignCustomizer {
+ (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}): any;
+ }
+
+ interface LoDashStatic {
+ /**
+ * This method is like `_.assignIn` except that it accepts `customizer` which
+ * is invoked to produce the assigned values. If `customizer` returns `undefined`
+ * assignment is handled by the method instead. The `customizer` is invoked
+ * with five arguments: (objValue, srcValue, key, object, source).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @alias extendWith
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} sources The source objects.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function customizer(objValue, srcValue) {
+ * return _.isUndefined(objValue) ? srcValue : objValue;
+ * }
+ *
+ * var defaults = _.partialRight(_.assignInWith, customizer);
+ *
+ * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
+ * // => { 'a': 1, 'b': 2 }
+ */
+ assignInWith<TObject, TSource>(
+ object: TObject,
+ source: TSource,
+ customizer: AssignCustomizer
+ ): TObject & TSource;
+
+ /**
+ * @see assignInWith
+ */
+ assignInWith<TObject, TSource1, TSource2>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ customizer: AssignCustomizer
+ ): TObject & TSource1 & TSource2;
+
+ /**
+ * @see assignInWith
+ */
+ assignInWith<TObject, TSource1, TSource2, TSource3>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ customizer: AssignCustomizer
+ ): TObject & TSource1 & TSource2 & TSource3;
+
+ /**
+ * @see assignInWith
+ */
+ assignInWith<TObject, TSource1, TSource2, TSource3, TSource4>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4,
+ customizer: AssignCustomizer
+ ): TObject & TSource1 & TSource2 & TSource3 & TSource4;
+
+ /**
+ * @see _.assignInWith
+ */
+ assignInWith<TObject>(object: TObject): TObject;
+
+ /**
+ * @see _.assignInWith
+ */
+ assignInWith<TResult>(
+ object: any,
+ ...otherArgs: any[]
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.assignInWith
+ */
+ assignInWith<TSource>(
+ source: TSource,
+ customizer: AssignCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see assignInWith
+ */
+ assignInWith<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2,
+ customizer: AssignCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see assignInWith
+ */
+ assignInWith<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ customizer: AssignCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see assignInWith
+ */
+ assignInWith<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4,
+ customizer: AssignCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.assignInWith
+ */
+ assignInWith(): LoDashImplicitObjectWrapper<T>;
+
+ /**
+ * @see _.assignInWith
+ */
+ assignInWith<TResult>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.assignInWith
+ */
+ assignInWith<TSource>(
+ source: TSource,
+ customizer: AssignCustomizer
+ ): LoDashExplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see assignInWith
+ */
+ assignInWith<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2,
+ customizer: AssignCustomizer
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see assignInWith
+ */
+ assignInWith<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ customizer: AssignCustomizer
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see assignInWith
+ */
+ assignInWith<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4,
+ customizer: AssignCustomizer
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.assignInWith
+ */
+ assignInWith(): LoDashExplicitObjectWrapper<T>;
+
+ /**
+ * @see _.assignInWith
+ */
+ assignInWith<TResult>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.create
+ interface LoDashStatic {
+ /**
+ * Creates an object that inherits from the given prototype object. If a properties object is provided its own
+ * enumerable properties are assigned to the created object.
+ *
+ * @param prototype The object to inherit from.
+ * @param properties The properties to assign to the object.
+ * @return Returns the new object.
+ */
+ create<T extends Object, U extends Object>(
+ prototype: T,
+ properties?: U
+ ): T & U;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.create
+ */
+ create<U extends Object>(properties?: U): LoDashImplicitObjectWrapper<T & U>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.create
+ */
+ create<U extends Object>(properties?: U): LoDashExplicitObjectWrapper<T & U>;
+ }
+
+
+ //_.defaults
+ interface LoDashStatic {
+ /**
+ * Assigns own enumerable properties of source object(s) to the destination object for all destination
+ * properties that resolve to undefined. Once a property is set, additional values of the same property are
+ * ignored.
+ *
+ * Note: This method mutates object.
+ *
+ * @param object The destination object.
+ * @param sources The source objects.
+ * @return The destination object.
+ */
+ defaults<TObject, TSource>(
+ object: TObject,
+ source: TSource
+ ): TSource & TObject;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TObject, TSource1, TSource2>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2
+ ): TSource2 & TSource1 & TObject;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TObject, TSource1, TSource2, TSource3>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): TSource3 & TSource2 & TSource1 & TObject;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TObject, TSource1, TSource2, TSource3, TSource4>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): TSource4 & TSource3 & TSource2 & TSource1 & TObject;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TObject>(object: TObject): TObject;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TResult>(
+ object: any,
+ ...sources: any[]
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.defaults
+ */
+ defaults<TSource>(
+ source: TSource
+ ): LoDashImplicitObjectWrapper<TSource & T>;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2
+ ): LoDashImplicitObjectWrapper<TSource2 & TSource1 & T>;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): LoDashImplicitObjectWrapper<TSource3 & TSource2 & TSource1 & T>;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): LoDashImplicitObjectWrapper<TSource4 & TSource3 & TSource2 & TSource1 & T>;
+
+ /**
+ * @see _.defaults
+ */
+ defaults(): LoDashImplicitObjectWrapper<T>;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TResult>(...sources: any[]): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.defaults
+ */
+ defaults<TSource>(
+ source: TSource
+ ): LoDashExplicitObjectWrapper<TSource & T>;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2
+ ): LoDashExplicitObjectWrapper<TSource2 & TSource1 & T>;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): LoDashExplicitObjectWrapper<TSource3 & TSource2 & TSource1 & T>;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): LoDashExplicitObjectWrapper<TSource4 & TSource3 & TSource2 & TSource1 & T>;
+
+ /**
+ * @see _.defaults
+ */
+ defaults(): LoDashExplicitObjectWrapper<T>;
+
+ /**
+ * @see _.defaults
+ */
+ defaults<TResult>(...sources: any[]): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.defaultsDeep
+ interface LoDashStatic {
+ /**
+ * This method is like _.defaults except that it recursively assigns default properties.
+ * @param object The destination object.
+ * @param sources The source objects.
+ * @return Returns object.
+ **/
+ defaultsDeep<T, TResult>(
+ object: T,
+ ...sources: any[]): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.defaultsDeep
+ **/
+ defaultsDeep<TResult>(...sources: any[]): LoDashImplicitObjectWrapper<TResult>
+ }
+
+ // _.extend
+ interface LoDashStatic {
+ /**
+ * @see _.assignIn
+ */
+ extend<TObject, TSource>(
+ object: TObject,
+ source: TSource
+ ): TObject & TSource;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TObject, TSource1, TSource2>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2
+ ): TObject & TSource1 & TSource2;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TObject, TSource1, TSource2, TSource3>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): TObject & TSource1 & TSource2 & TSource3;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TObject, TSource1, TSource2, TSource3, TSource4>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): TObject & TSource1 & TSource2 & TSource3 & TSource4;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TObject>(object: TObject): TObject;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TResult>(
+ object: any,
+ ...otherArgs: any[]
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.assignIn
+ */
+ extend<TSource>(
+ source: TSource
+ ): LoDashImplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.assignIn
+ */
+ extend(): LoDashImplicitObjectWrapper<T>;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TResult>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.assignIn
+ */
+ extend<TSource>(
+ source: TSource
+ ): LoDashExplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.assignIn
+ */
+ extend(): LoDashExplicitObjectWrapper<T>;
+
+ /**
+ * @see _.assignIn
+ */
+ extend<TResult>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashStatic {
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TObject, TSource>(
+ object: TObject,
+ source: TSource,
+ customizer: AssignCustomizer
+ ): TObject & TSource;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TObject, TSource1, TSource2>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ customizer: AssignCustomizer
+ ): TObject & TSource1 & TSource2;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TObject, TSource1, TSource2, TSource3>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ customizer: AssignCustomizer
+ ): TObject & TSource1 & TSource2 & TSource3;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TObject, TSource1, TSource2, TSource3, TSource4>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4,
+ customizer: AssignCustomizer
+ ): TObject & TSource1 & TSource2 & TSource3 & TSource4;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TObject>(object: TObject): TObject;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TResult>(
+ object: any,
+ ...otherArgs: any[]
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TSource>(
+ source: TSource,
+ customizer: AssignCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2,
+ customizer: AssignCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ customizer: AssignCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4,
+ customizer: AssignCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith(): LoDashImplicitObjectWrapper<T>;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TResult>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TSource>(
+ source: TSource,
+ customizer: AssignCustomizer
+ ): LoDashExplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2,
+ customizer: AssignCustomizer
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ customizer: AssignCustomizer
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4,
+ customizer: AssignCustomizer
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith(): LoDashExplicitObjectWrapper<T>;
+
+ /**
+ * @see _.assignInWith
+ */
+ extendWith<TResult>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.findKey
+ interface LoDashStatic {
+ /**
+ * This method is like _.find except that it returns the key of the first element predicate returns truthy for
+ * instead of the element itself.
+ *
+ * If a property name is provided for predicate the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for predicate the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * @param object The object to search.
+ * @param predicate The function invoked per iteration.
+ * @param thisArg The this binding of predicate.
+ * @return Returns the key of the matched element, else undefined.
+ */
+ findKey<TValues, TObject>(
+ object: TObject,
+ predicate?: DictionaryIterator<TValues, boolean>
+ ): string;
+
+ /**
+ * @see _.findKey
+ */
+ findKey<TObject>(
+ object: TObject,
+ predicate?: ObjectIterator<any, boolean>
+ ): string;
+
+ /**
+ * @see _.findKey
+ */
+ findKey<TObject>(
+ object: TObject,
+ predicate?: string
+ ): string;
+
+ /**
+ * @see _.findKey
+ */
+ findKey<TWhere extends Dictionary<any>, TObject>(
+ object: TObject,
+ predicate?: TWhere
+ ): string;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.findKey
+ */
+ findKey<TValues>(
+ predicate?: DictionaryIterator<TValues, boolean>
+ ): string;
+
+ /**
+ * @see _.findKey
+ */
+ findKey(
+ predicate?: ObjectIterator<any, boolean>
+ ): string;
+
+ /**
+ * @see _.findKey
+ */
+ findKey(
+ predicate?: string
+ ): string;
+
+ /**
+ * @see _.findKey
+ */
+ findKey<TWhere extends Dictionary<any>>(
+ predicate?: TWhere
+ ): string;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.findKey
+ */
+ findKey<TValues>(
+ predicate?: DictionaryIterator<TValues, boolean>
+ ): LoDashExplicitWrapper<string>;
+
+ /**
+ * @see _.findKey
+ */
+ findKey(
+ predicate?: ObjectIterator<any, boolean>
+ ): LoDashExplicitWrapper<string>;
+
+ /**
+ * @see _.findKey
+ */
+ findKey(
+ predicate?: string
+ ): LoDashExplicitWrapper<string>;
+
+ /**
+ * @see _.findKey
+ */
+ findKey<TWhere extends Dictionary<any>>(
+ predicate?: TWhere
+ ): LoDashExplicitWrapper<string>;
+ }
+
+ //_.findLastKey
+ interface LoDashStatic {
+ /**
+ * This method is like _.findKey except that it iterates over elements of a collection in the opposite order.
+ *
+ * If a property name is provided for predicate the created _.property style callback returns the property
+ * value of the given element.
+ *
+ * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
+ * elements that have a matching property value, else false.
+ *
+ * If an object is provided for predicate the created _.matches style callback returns true for elements that
+ * have the properties of the given object, else false.
+ *
+ * @param object The object to search.
+ * @param predicate The function invoked per iteration.
+ * @param thisArg The this binding of predicate.
+ * @return Returns the key of the matched element, else undefined.
+ */
+ findLastKey<TValues, TObject>(
+ object: TObject,
+ predicate?: DictionaryIterator<TValues, boolean>
+ ): string;
+
+ /**
+ * @see _.findLastKey
+ */
+ findLastKey<TObject>(
+ object: TObject,
+ predicate?: ObjectIterator<any, boolean>
+ ): string;
+
+ /**
+ * @see _.findLastKey
+ */
+ findLastKey<TObject>(
+ object: TObject,
+ predicate?: string
+ ): string;
+
+ /**
+ * @see _.findLastKey
+ */
+ findLastKey<TWhere extends Dictionary<any>, TObject>(
+ object: TObject,
+ predicate?: TWhere
+ ): string;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.findLastKey
+ */
+ findLastKey<TValues>(
+ predicate?: DictionaryIterator<TValues, boolean>
+ ): string;
+
+ /**
+ * @see _.findLastKey
+ */
+ findLastKey(
+ predicate?: ObjectIterator<any, boolean>
+ ): string;
+
+ /**
+ * @see _.findLastKey
+ */
+ findLastKey(
+ predicate?: string
+ ): string;
+
+ /**
+ * @see _.findLastKey
+ */
+ findLastKey<TWhere extends Dictionary<any>>(
+ predicate?: TWhere
+ ): string;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.findLastKey
+ */
+ findLastKey<TValues>(
+ predicate?: DictionaryIterator<TValues, boolean>
+ ): LoDashExplicitWrapper<string>;
+
+ /**
+ * @see _.findLastKey
+ */
+ findLastKey(
+ predicate?: ObjectIterator<any, boolean>
+ ): LoDashExplicitWrapper<string>;
+
+ /**
+ * @see _.findLastKey
+ */
+ findLastKey(
+ predicate?: string
+ ): LoDashExplicitWrapper<string>;
+
+ /**
+ * @see _.findLastKey
+ */
+ findLastKey<TWhere extends Dictionary<any>>(
+ predicate?: TWhere
+ ): LoDashExplicitWrapper<string>;
+ }
+
+ //_.forIn
+ interface LoDashStatic {
+ /**
+ * Iterates over own and inherited enumerable properties of an object invoking iteratee for each property. The
+ * iteratee is bound to thisArg and invoked with three arguments: (value, key, object). Iteratee functions may
+ * exit iteration early by explicitly returning false.
+ *
+ * @param object The object to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @param thisArg The this binding of iteratee.
+ * @return Returns object.
+ */
+ forIn<T>(
+ object: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, any>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.forIn
+ */
+ forIn<T extends {}>(
+ object: T,
+ iteratee?: ObjectIterator<any, any>
+ ): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.forIn
+ */
+ forIn<TValue>(
+ iteratee?: DictionaryIterator<TValue, any>
+ ): _.LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.forIn
+ */
+ forIn<TValue>(
+ iteratee?: DictionaryIterator<TValue, any>
+ ): _.LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.forInRight
+ interface LoDashStatic {
+ /**
+ * This method is like _.forIn except that it iterates over properties of object in the opposite order.
+ *
+ * @param object The object to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @param thisArg The this binding of iteratee.
+ * @return Returns object.
+ */
+ forInRight<T>(
+ object: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, any>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.forInRight
+ */
+ forInRight<T extends {}>(
+ object: T,
+ iteratee?: ObjectIterator<any, any>
+ ): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.forInRight
+ */
+ forInRight<TValue>(
+ iteratee?: DictionaryIterator<TValue, any>
+ ): _.LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.forInRight
+ */
+ forInRight<TValue>(
+ iteratee?: DictionaryIterator<TValue, any>
+ ): _.LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.forOwn
+ interface LoDashStatic {
+ /**
+ * Iterates over own enumerable properties of an object invoking iteratee for each property. The iteratee is
+ * bound to thisArg and invoked with three arguments: (value, key, object). Iteratee functions may exit
+ * iteration early by explicitly returning false.
+ *
+ * @param object The object to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @param thisArg The this binding of iteratee.
+ * @return Returns object.
+ */
+ forOwn<T>(
+ object: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, any>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.forOwn
+ */
+ forOwn<T extends {}>(
+ object: T,
+ iteratee?: ObjectIterator<any, any>
+ ): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.forOwn
+ */
+ forOwn<TValue>(
+ iteratee?: DictionaryIterator<TValue, any>
+ ): _.LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.forOwn
+ */
+ forOwn<TValue>(
+ iteratee?: DictionaryIterator<TValue, any>
+ ): _.LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.forOwnRight
+ interface LoDashStatic {
+ /**
+ * This method is like _.forOwn except that it iterates over properties of object in the opposite order.
+ *
+ * @param object The object to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @param thisArg The this binding of iteratee.
+ * @return Returns object.
+ */
+ forOwnRight<T>(
+ object: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, any>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.forOwnRight
+ */
+ forOwnRight<T extends {}>(
+ object: T,
+ iteratee?: ObjectIterator<any, any>
+ ): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.forOwnRight
+ */
+ forOwnRight<TValue>(
+ iteratee?: DictionaryIterator<TValue, any>
+ ): _.LoDashImplicitObjectWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.forOwnRight
+ */
+ forOwnRight<TValue>(
+ iteratee?: DictionaryIterator<TValue, any>
+ ): _.LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.functions
+ interface LoDashStatic {
+ /**
+ * Creates an array of function property names from own enumerable properties
+ * of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns the new array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = _.constant('a');
+ * this.b = _.constant('b');
+ * }
+ *
+ * Foo.prototype.c = _.constant('c');
+ *
+ * _.functions(new Foo);
+ * // => ['a', 'b']
+ */
+ functions<T extends {}>(object: any): string[];
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.functions
+ */
+ functions(): _.LoDashImplicitArrayWrapper<string>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.functions
+ */
+ functions(): _.LoDashExplicitArrayWrapper<string>;
+ }
+
+ //_.functionsIn
+ interface LoDashStatic {
+ /**
+ * Creates an array of function property names from own and inherited
+ * enumerable properties of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns the new array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = _.constant('a');
+ * this.b = _.constant('b');
+ * }
+ *
+ * Foo.prototype.c = _.constant('c');
+ *
+ * _.functionsIn(new Foo);
+ * // => ['a', 'b', 'c']
+ */
+ functionsIn<T extends {}>(object: any): string[];
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.functionsIn
+ */
+ functionsIn(): _.LoDashImplicitArrayWrapper<string>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.functionsIn
+ */
+ functionsIn(): _.LoDashExplicitArrayWrapper<string>;
+ }
+
+ //_.get
+ interface LoDashStatic {
+ /**
+ * Gets the property value at path of object. If the resolved value is undefined the defaultValue is used
+ * in its place.
+ *
+ * @param object The object to query.
+ * @param path The path of the property to get.
+ * @param defaultValue The value returned if the resolved value is undefined.
+ * @return Returns the resolved value.
+ */
+ get<TObject, TResult>(
+ object: TObject,
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: TResult
+ ): TResult;
+
+ /**
+ * @see _.get
+ */
+ get<TResult>(
+ object: any,
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: TResult
+ ): TResult;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.get
+ */
+ get<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: TResult
+ ): TResult;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.get
+ */
+ get<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: TResult
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.get
+ */
+ get<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: TResult
+ ): TResult;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.get
+ */
+ get<TResultWrapper>(
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: any
+ ): TResultWrapper;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.get
+ */
+ get<TResultWrapper>(
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: any
+ ): TResultWrapper;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.get
+ */
+ get<TResultWrapper>(
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: any
+ ): TResultWrapper;
+ }
+
+ //_.has
+ interface LoDashStatic {
+ /**
+ * Checks if `path` is a direct property of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = { 'a': { 'b': { 'c': 3 } } };
+ * var other = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) });
+ *
+ * _.has(object, 'a');
+ * // => true
+ *
+ * _.has(object, 'a.b.c');
+ * // => true
+ *
+ * _.has(object, ['a', 'b', 'c']);
+ * // => true
+ *
+ * _.has(other, 'a');
+ * // => false
+ */
+ has<T extends {}>(
+ object: T,
+ path: StringRepresentable|StringRepresentable[]
+ ): boolean;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.has
+ */
+ has(path: StringRepresentable|StringRepresentable[]): boolean;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.has
+ */
+ has(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.hasIn
+ interface LoDashStatic {
+ /**
+ * Checks if `path` is a direct or inherited property of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) });
+ *
+ * _.hasIn(object, 'a');
+ * // => true
+ *
+ * _.hasIn(object, 'a.b.c');
+ * // => true
+ *
+ * _.hasIn(object, ['a', 'b', 'c']);
+ * // => true
+ *
+ * _.hasIn(object, 'b');
+ * // => false
+ */
+ hasIn<T extends {}>(
+ object: T,
+ path: StringRepresentable|StringRepresentable[]
+ ): boolean;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.hasIn
+ */
+ hasIn(path: StringRepresentable|StringRepresentable[]): boolean;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.hasIn
+ */
+ hasIn(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.invert
+ interface LoDashStatic {
+ /**
+ * Creates an object composed of the inverted keys and values of object. If object contains duplicate values,
+ * subsequent values overwrite property assignments of previous values unless multiValue is true.
+ *
+ * @param object The object to invert.
+ * @param multiValue Allow multiple values per key.
+ * @return Returns the new inverted object.
+ */
+ invert<T extends {}, TResult extends {}>(
+ object: T,
+ multiValue?: boolean
+ ): TResult;
+
+ /**
+ * @see _.invert
+ */
+ invert<TResult extends {}>(
+ object: Object,
+ multiValue?: boolean
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.invert
+ */
+ invert<TResult extends {}>(multiValue?: boolean): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.invert
+ */
+ invert<TResult extends {}>(multiValue?: boolean): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.inverBy
+ interface InvertByIterator<T> {
+ (value: T): any;
+ }
+
+ interface LoDashStatic {
+ /**
+ * This method is like _.invert except that the inverted object is generated from the results of running each
+ * element of object through iteratee. The corresponding inverted value of each inverted key is an array of
+ * keys responsible for generating the inverted value. The iteratee is invoked with one argument: (value).
+ *
+ * @param object The object to invert.
+ * @param interatee The iteratee invoked per element.
+ * @return Returns the new inverted object.
+ */
+ invertBy(
+ object: Object,
+ interatee?: InvertByIterator<any>|string
+ ): Dictionary<string[]>;
+
+ /**
+ * @see _.invertBy
+ */
+ invertBy<T>(
+ object: _.Dictionary<T>|_.NumericDictionary<T>,
+ interatee?: InvertByIterator<T>|string
+ ): Dictionary<string[]>;
+
+ /**
+ * @see _.invertBy
+ */
+ invertBy<W>(
+ object: Object,
+ interatee?: W
+ ): Dictionary<string[]>;
+
+ /**
+ * @see _.invertBy
+ */
+ invertBy<T, W>(
+ object: _.Dictionary<T>,
+ interatee?: W
+ ): Dictionary<string[]>;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.invertBy
+ */
+ invertBy(
+ interatee?: InvertByIterator<any>
+ ): LoDashImplicitObjectWrapper<Dictionary<string[]>>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.invertBy
+ */
+ invertBy(
+ interatee?: InvertByIterator<T>|string
+ ): LoDashImplicitObjectWrapper<Dictionary<string[]>>;
+
+ /**
+ * @see _.invertBy
+ */
+ invertBy<W>(
+ interatee?: W
+ ): LoDashImplicitObjectWrapper<Dictionary<string[]>>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.invertBy
+ */
+ invertBy(
+ interatee?: InvertByIterator<any>|string
+ ): LoDashImplicitObjectWrapper<Dictionary<string[]>>;
+
+ /**
+ * @see _.invertBy
+ */
+ invertBy<W>(
+ interatee?: W
+ ): LoDashImplicitObjectWrapper<Dictionary<string[]>>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.invertBy
+ */
+ invertBy(
+ interatee?: InvertByIterator<any>
+ ): LoDashExplicitObjectWrapper<Dictionary<string[]>>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.invertBy
+ */
+ invertBy(
+ interatee?: InvertByIterator<T>|string
+ ): LoDashExplicitObjectWrapper<Dictionary<string[]>>;
+
+ /**
+ * @see _.invertBy
+ */
+ invertBy<W>(
+ interatee?: W
+ ): LoDashExplicitObjectWrapper<Dictionary<string[]>>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.invertBy
+ */
+ invertBy(
+ interatee?: InvertByIterator<any>|string
+ ): LoDashExplicitObjectWrapper<Dictionary<string[]>>;
+
+ /**
+ * @see _.invertBy
+ */
+ invertBy<W>(
+ interatee?: W
+ ): LoDashExplicitObjectWrapper<Dictionary<string[]>>;
+ }
+
+ //_.keys
+ interface LoDashStatic {
+ /**
+ * Creates an array of the own enumerable property names of object.
+ *
+ * Note: Non-object values are coerced to objects. See the ES spec for more details.
+ *
+ * @param object The object to query.
+ * @return Returns the array of property names.
+ */
+ keys(object?: any): string[];
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.keys
+ */
+ keys(): LoDashImplicitArrayWrapper<string>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.keys
+ */
+ keys(): LoDashExplicitArrayWrapper<string>;
+ }
+
+ //_.keysIn
+ interface LoDashStatic {
+ /**
+ * Creates an array of the own and inherited enumerable property names of object.
+ *
+ * Note: Non-object values are coerced to objects.
+ *
+ * @param object The object to query.
+ * @return An array of property names.
+ */
+ keysIn(object?: any): string[];
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.keysIn
+ */
+ keysIn(): LoDashImplicitArrayWrapper<string>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.keysIn
+ */
+ keysIn(): LoDashExplicitArrayWrapper<string>;
+ }
+
+ //_.mapKeys
+ interface LoDashStatic {
+ /**
+ * The opposite of _.mapValues; this method creates an object with the same values as object and keys generated
+ * by running each own enumerable property of object through iteratee.
+ *
+ * @param object The object to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @param thisArg The this binding of iteratee.
+ * @return Returns the new mapped object.
+ */
+ mapKeys<T, TKey>(
+ object: List<T>,
+ iteratee?: ListIterator<T, TKey>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<T, TKey>(
+ object: Dictionary<T>,
+ iteratee?: DictionaryIterator<T, TKey>
+ ): Dictionary<T>;
+
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<T, TObject extends {}>(
+ object: List<T>|Dictionary<T>,
+ iteratee?: TObject
+ ): Dictionary<T>;
+
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<T>(
+ object: List<T>|Dictionary<T>,
+ iteratee?: string
+ ): Dictionary<T>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<TKey>(
+ iteratee?: ListIterator<T, TKey>
+ ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<TObject extends {}>(
+ iteratee?: TObject
+ ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys(
+ iteratee?: string
+ ): LoDashImplicitObjectWrapper<Dictionary<T>>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<TResult, TKey>(
+ iteratee?: ListIterator<TResult, TKey>|DictionaryIterator<TResult, TKey>
+ ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
+
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<TResult, TObject extends {}>(
+ iteratee?: TObject
+ ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
+
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<TResult>(
+ iteratee?: string
+ ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<TKey>(
+ iteratee?: ListIterator<T, TKey>
+ ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<TObject extends {}>(
+ iteratee?: TObject
+ ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys(
+ iteratee?: string
+ ): LoDashExplicitObjectWrapper<Dictionary<T>>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<TResult, TKey>(
+ iteratee?: ListIterator<TResult, TKey>|DictionaryIterator<TResult, TKey>
+ ): LoDashExplicitObjectWrapper<Dictionary<TResult>>;
+
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<TResult, TObject extends {}>(
+ iteratee?: TObject
+ ): LoDashExplicitObjectWrapper<Dictionary<TResult>>;
+
+ /**
+ * @see _.mapKeys
+ */
+ mapKeys<TResult>(
+ iteratee?: string
+ ): LoDashExplicitObjectWrapper<Dictionary<TResult>>;
+ }
+
+ //_.mapValues
+ interface LoDashStatic {
+ /**
+ * Creates an object with the same keys as object and values generated by running each own
+ * enumerable property of object through iteratee. The iteratee function is bound to thisArg
+ * and invoked with three arguments: (value, key, object).
+ *
+ * If a property name is provided iteratee the created "_.property" style callback returns
+ * the property value of the given element.
+ *
+ * If a value is also provided for thisArg the creted "_.matchesProperty" style callback returns
+ * true for elements that have a matching property value, else false;.
+ *
+ * If an object is provided for iteratee the created "_.matches" style callback returns true
+ * for elements that have the properties of the given object, else false.
+ *
+ * @param {Object} object The object to iterate over.
+ * @param {Function|Object|string} [iteratee=_.identity] The function invoked per iteration.
+ * @param {Object} [thisArg] The `this` binding of `iteratee`.
+ * @return {Object} Returns the new mapped object.
+ */
+ mapValues<T, TResult>(obj: Dictionary<T>, callback: ObjectIterator<T, TResult>): Dictionary<TResult>;
+ mapValues<T>(obj: Dictionary<T>, where: Dictionary<T>): Dictionary<boolean>;
+ mapValues<T, TMapped>(obj: T, pluck: string): TMapped;
+ mapValues<T>(obj: T, callback: ObjectIterator<any, any>): T;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.mapValues
+ * TValue is the type of the property values of T.
+ * TResult is the type output by the ObjectIterator function
+ */
+ mapValues<TValue, TResult>(callback: ObjectIterator<TValue, TResult>): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
+
+ /**
+ * @see _.mapValues
+ * TResult is the type of the property specified by pluck.
+ * T should be a Dictionary<Dictionary<TResult>>
+ */
+ mapValues<TResult>(pluck: string): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
+
+ /**
+ * @see _.mapValues
+ * TResult is the type of the properties of each object in the values of T
+ * T should be a Dictionary<Dictionary<TResult>>
+ */
+ mapValues<TResult>(where: Dictionary<TResult>): LoDashImplicitArrayWrapper<boolean>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.mapValues
+ * TValue is the type of the property values of T.
+ * TResult is the type output by the ObjectIterator function
+ */
+ mapValues<TValue, TResult>(callback: ObjectIterator<TValue, TResult>): LoDashExplicitObjectWrapper<Dictionary<TResult>>;
+
+ /**
+ * @see _.mapValues
+ * TResult is the type of the property specified by pluck.
+ * T should be a Dictionary<Dictionary<TResult>>
+ */
+ mapValues<TResult>(pluck: string): LoDashExplicitObjectWrapper<Dictionary<TResult>>;
+
+ /**
+ * @see _.mapValues
+ * TResult is the type of the properties of each object in the values of T
+ * T should be a Dictionary<Dictionary<TResult>>
+ */
+ mapValues<TResult>(where: Dictionary<TResult>): LoDashExplicitObjectWrapper<boolean>;
+ }
+
+ //_.merge
+ interface LoDashStatic {
+ /**
+ * Recursively merges own and inherited enumerable properties of source
+ * objects into the destination object, skipping source properties that resolve
+ * to `undefined`. Array and plain object properties are merged recursively.
+ * Other objects and value types are overridden by assignment. Source objects
+ * are applied from left to right. Subsequent sources overwrite property
+ * assignments of previous sources.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var users = {
+ * 'data': [{ 'user': 'barney' }, { 'user': 'fred' }]
+ * };
+ *
+ * var ages = {
+ * 'data': [{ 'age': 36 }, { 'age': 40 }]
+ * };
+ *
+ * _.merge(users, ages);
+ * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }
+ */
+ merge<TObject, TSource>(
+ object: TObject,
+ source: TSource
+ ): TObject & TSource;
+
+ /**
+ * @see _.merge
+ */
+ merge<TObject, TSource1, TSource2>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2
+ ): TObject & TSource1 & TSource2;
+
+ /**
+ * @see _.merge
+ */
+ merge<TObject, TSource1, TSource2, TSource3>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): TObject & TSource1 & TSource2 & TSource3;
+
+ /**
+ * @see _.merge
+ */
+ merge<TObject, TSource1, TSource2, TSource3, TSource4>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): TObject & TSource1 & TSource2 & TSource3 & TSource4;
+
+ /**
+ * @see _.merge
+ */
+ merge<TResult>(
+ object: any,
+ ...otherArgs: any[]
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.merge
+ */
+ merge<TSource>(
+ source: TSource
+ ): LoDashImplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see _.merge
+ */
+ merge<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see _.merge
+ */
+ merge<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see _.merge
+ */
+ merge<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.merge
+ */
+ merge<TResult>(
+ ...otherArgs: any[]
+ ): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.merge
+ */
+ merge<TSource>(
+ source: TSource
+ ): LoDashExplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see _.merge
+ */
+ merge<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see _.merge
+ */
+ merge<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see _.merge
+ */
+ merge<TSource1, TSource2, TSource3, TSource4>(
+ ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.merge
+ */
+ merge<TResult>(
+ ...otherArgs: any[]
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.mergeWith
+ interface MergeWithCustomizer {
+ (value: any, srcValue: any, key?: string, object?: Object, source?: Object): any;
+ }
+
+ interface LoDashStatic {
+ /**
+ * This method is like `_.merge` except that it accepts `customizer` which
+ * is invoked to produce the merged values of the destination and source
+ * properties. If `customizer` returns `undefined` merging is handled by the
+ * method instead. The `customizer` is invoked with seven arguments:
+ * (objValue, srcValue, key, object, source, stack).
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} sources The source objects.
+ * @param {Function} customizer The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function customizer(objValue, srcValue) {
+ * if (_.isArray(objValue)) {
+ * return objValue.concat(srcValue);
+ * }
+ * }
+ *
+ * var object = {
+ * 'fruits': ['apple'],
+ * 'vegetables': ['beet']
+ * };
+ *
+ * var other = {
+ * 'fruits': ['banana'],
+ * 'vegetables': ['carrot']
+ * };
+ *
+ * _.merge(object, other, customizer);
+ * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] }
+ */
+ mergeWith<TObject, TSource>(
+ object: TObject,
+ source: TSource,
+ customizer: MergeWithCustomizer
+ ): TObject & TSource;
+
+ /**
+ * @see _.mergeWith
+ */
+ mergeWith<TObject, TSource1, TSource2>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ customizer: MergeWithCustomizer
+ ): TObject & TSource1 & TSource2;
+
+ /**
+ * @see _.mergeWith
+ */
+ mergeWith<TObject, TSource1, TSource2, TSource3>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ customizer: MergeWithCustomizer
+ ): TObject & TSource1 & TSource2 & TSource3;
+
+ /**
+ * @see _.mergeWith
+ */
+ mergeWith<TObject, TSource1, TSource2, TSource3, TSource4>(
+ object: TObject,
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4,
+ customizer: MergeWithCustomizer
+ ): TObject & TSource1 & TSource2 & TSource3 & TSource4;
+
+ /**
+ * @see _.mergeWith
+ */
+ mergeWith<TResult>(
+ object: any,
+ ...otherArgs: any[]
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.mergeWith
+ */
+ mergeWith<TSource>(
+ source: TSource,
+ customizer: MergeWithCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource>;
+
+ /**
+ * @see _.mergeWith
+ */
+ mergeWith<TSource1, TSource2>(
+ source1: TSource1,
+ source2: TSource2,
+ customizer: MergeWithCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;
+
+ /**
+ * @see _.mergeWith
+ */
+ mergeWith<TSource1, TSource2, TSource3>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ customizer: MergeWithCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;
+
+ /**
+ * @see _.mergeWith
+ */
+ mergeWith<TSource1, TSource2, TSource3, TSource4>(
+ source1: TSource1,
+ source2: TSource2,
+ source3: TSource3,
+ source4: TSource4,
+ customizer: MergeWithCustomizer
+ ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;
+
+ /**
+ * @see _.mergeWith
+ */
+ mergeWith<TResult>(
+ ...otherArgs: any[]
+ ): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ //_.omit
+ interface LoDashStatic {
+ /**
+ * The opposite of `_.pick`; this method creates an object composed of the
+ * own and inherited enumerable properties of `object` that are not omitted.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {...(string|string[])} [props] The property names to omit, specified
+ * individually or in arrays..
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.omit(object, ['a', 'c']);
+ * // => { 'b': '2' }
+ */
+
+ omit<TResult extends {}, T extends {}>(
+ object: T,
+ ...predicate: (StringRepresentable|StringRepresentable[])[]
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+
+ /**
+ * @see _.omit
+ */
+ omit<TResult extends {}>(
+ ...predicate: (StringRepresentable|StringRepresentable[])[]
+ ): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+
+ /**
+ * @see _.omit
+ */
+ omit<TResult extends {}>(
+ ...predicate: (StringRepresentable|StringRepresentable[])[]
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.omitBy
+ interface LoDashStatic {
+ /**
+ * The opposite of `_.pickBy`; this method creates an object composed of the
+ * own and inherited enumerable properties of `object` that `predicate`
+ * doesn't return truthy for.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {Function|Object|string} [predicate=_.identity] The function invoked per property.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.omitBy(object, _.isNumber);
+ * // => { 'b': '2' }
+ */
+ omitBy<TResult extends {}, T extends {}>(
+ object: T,
+ predicate: ObjectIterator<any, boolean>
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.omitBy
+ */
+ omitBy<TResult extends {}>(
+ predicate: ObjectIterator<any, boolean>
+ ): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.omitBy
+ */
+ omitBy<TResult extends {}>(
+ predicate: ObjectIterator<any, boolean>
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.pick
+ interface LoDashStatic {
+ /**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {...(string|string[])} [props] The property names to pick, specified
+ * individually or in arrays.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.pick(object, ['a', 'c']);
+ * // => { 'a': 1, 'c': 3 }
+ */
+ pick<TResult extends {}, T extends {}>(
+ object: T,
+ ...predicate: (StringRepresentable|StringRepresentable[])[]
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.pick
+ */
+ pick<TResult extends {}>(
+ ...predicate: (StringRepresentable|StringRepresentable[])[]
+ ): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.pick
+ */
+ pick<TResult extends {}>(
+ ...predicate: (StringRepresentable|StringRepresentable[])[]
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.pickBy
+ interface LoDashStatic {
+ /**
+ * Creates an object composed of the `object` properties `predicate` returns
+ * truthy for. The predicate is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {Function|Object|string} [predicate=_.identity] The function invoked per property.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.pickBy(object, _.isNumber);
+ * // => { 'a': 1, 'c': 3 }
+ */
+ pickBy<TResult extends {}, T extends {}>(
+ object: T,
+ predicate?: ObjectIterator<any, boolean>
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.pickBy
+ */
+ pickBy<TResult extends {}>(
+ predicate?: ObjectIterator<any, boolean>
+ ): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.pickBy
+ */
+ pickBy<TResult extends {}>(
+ predicate?: ObjectIterator<any, boolean>
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.result
+ interface LoDashStatic {
+ /**
+ * This method is like _.get except that if the resolved value is a function it’s invoked with the this binding
+ * of its parent object and its result is returned.
+ *
+ * @param object The object to query.
+ * @param path The path of the property to resolve.
+ * @param defaultValue The value returned if the resolved value is undefined.
+ * @return Returns the resolved value.
+ */
+ result<TObject, TResult>(
+ object: TObject,
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: TResult|((...args: any[]) => TResult)
+ ): TResult;
+
+ /**
+ * @see _.result
+ */
+ result<TResult>(
+ object: any,
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: TResult|((...args: any[]) => TResult)
+ ): TResult;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.result
+ */
+ result<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: TResult|((...args: any[]) => TResult)
+ ): TResult;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.result
+ */
+ result<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: TResult|((...args: any[]) => TResult)
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.result
+ */
+ result<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: TResult|((...args: any[]) => TResult)
+ ): TResult;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.result
+ */
+ result<TResultWrapper>(
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: any
+ ): TResultWrapper;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.result
+ */
+ result<TResultWrapper>(
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: any
+ ): TResultWrapper;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.result
+ */
+ result<TResultWrapper>(
+ path: StringRepresentable|StringRepresentable[],
+ defaultValue?: any
+ ): TResultWrapper;
+ }
+
+ //_.set
+ interface LoDashStatic {
+ /**
+ * Sets the value at path of object. If a portion of path doesn’t exist it’s created. Arrays are created for
+ * missing index properties while objects are created for all other missing properties. Use _.setWith to
+ * customize path creation.
+ *
+ * @param object The object to modify.
+ * @param path The path of the property to set.
+ * @param value The value to set.
+ * @return Returns object.
+ */
+ set<TResult>(
+ object: Object,
+ path: StringRepresentable|StringRepresentable[],
+ value: any
+ ): TResult;
+
+ /**
+ * @see _.set
+ */
+ set<V, TResult>(
+ object: Object,
+ path: StringRepresentable|StringRepresentable[],
+ value: V
+ ): TResult;
+
+ /**
+ * @see _.set
+ */
+ set<O, V, TResult>(
+ object: O,
+ path: StringRepresentable|StringRepresentable[],
+ value: V
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.set
+ */
+ set<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ value: any
+ ): LoDashImplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.set
+ */
+ set<V, TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ value: V
+ ): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.set
+ */
+ set<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ value: any
+ ): LoDashExplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.set
+ */
+ set<V, TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ value: V
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.setWith
+ interface SetWithCustomizer<T> {
+ (nsValue: any, key: string, nsObject: T): any;
+ }
+
+ interface LoDashStatic {
+ /**
+ * This method is like _.set except that it accepts customizer which is invoked to produce the objects of
+ * path. If customizer returns undefined path creation is handled by the method instead. The customizer is
+ * invoked with three arguments: (nsValue, key, nsObject).
+ *
+ * @param object The object to modify.
+ * @param path The path of the property to set.
+ * @param value The value to set.
+ * @parem customizer The function to customize assigned values.
+ * @return Returns object.
+ */
+ setWith<TResult>(
+ object: Object,
+ path: StringRepresentable|StringRepresentable[],
+ value: any,
+ customizer?: SetWithCustomizer<Object>
+ ): TResult;
+
+ /**
+ * @see _.setWith
+ */
+ setWith<V, TResult>(
+ object: Object,
+ path: StringRepresentable|StringRepresentable[],
+ value: V,
+ customizer?: SetWithCustomizer<Object>
+ ): TResult;
+
+ /**
+ * @see _.setWith
+ */
+ setWith<O, V, TResult>(
+ object: O,
+ path: StringRepresentable|StringRepresentable[],
+ value: V,
+ customizer?: SetWithCustomizer<O>
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.setWith
+ */
+ setWith<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ value: any,
+ customizer?: SetWithCustomizer<T>
+ ): LoDashImplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.setWith
+ */
+ setWith<V, TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ value: V,
+ customizer?: SetWithCustomizer<T>
+ ): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.setWith
+ */
+ setWith<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ value: any,
+ customizer?: SetWithCustomizer<T>
+ ): LoDashExplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.setWith
+ */
+ setWith<V, TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ value: V,
+ customizer?: SetWithCustomizer<T>
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.toPairs
+ interface LoDashStatic {
+ /**
+ * Creates an array of own enumerable key-value pairs for object.
+ *
+ * @param object The object to query.
+ * @return Returns the new array of key-value pairs.
+ */
+ toPairs<T extends {}>(object?: T): any[][];
+
+ toPairs<T extends {}, TResult>(object?: T): TResult[][];
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.toPairs
+ */
+ toPairs<TResult>(): LoDashImplicitArrayWrapper<TResult[]>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.toPairs
+ */
+ toPairs<TResult>(): LoDashExplicitArrayWrapper<TResult[]>;
+ }
+
+ //_.toPairsIn
+ interface LoDashStatic {
+ /**
+ * Creates an array of own and inherited enumerable key-value pairs for object.
+ *
+ * @param object The object to query.
+ * @return Returns the new array of key-value pairs.
+ */
+ toPairsIn<T extends {}>(object?: T): any[][];
+
+ toPairsIn<T extends {}, TResult>(object?: T): TResult[][];
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.toPairsIn
+ */
+ toPairsIn<TResult>(): LoDashImplicitArrayWrapper<TResult[]>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.toPairsIn
+ */
+ toPairsIn<TResult>(): LoDashExplicitArrayWrapper<TResult[]>;
+ }
+
+ //_.transform
+ interface LoDashStatic {
+ /**
+ * An alternative to _.reduce; this method transforms object to a new accumulator object which is the result of
+ * running each of its own enumerable properties through iteratee, with each invocation potentially mutating
+ * the accumulator object. The iteratee is bound to thisArg and invoked with four arguments: (accumulator,
+ * value, key, object). Iteratee functions may exit iteration early by explicitly returning false.
+ *
+ * @param object The object to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @param accumulator The custom accumulator value.
+ * @param thisArg The this binding of iteratee.
+ * @return Returns the accumulated value.
+ */
+ transform<T, TResult>(
+ object: T[],
+ iteratee?: MemoVoidArrayIterator<T, TResult[]>,
+ accumulator?: TResult[]
+ ): TResult[];
+
+ /**
+ * @see _.transform
+ */
+ transform<T, TResult>(
+ object: T[],
+ iteratee?: MemoVoidArrayIterator<T, Dictionary<TResult>>,
+ accumulator?: Dictionary<TResult>
+ ): Dictionary<TResult>;
+
+ /**
+ * @see _.transform
+ */
+ transform<T, TResult>(
+ object: Dictionary<T>,
+ iteratee?: MemoVoidDictionaryIterator<T, Dictionary<TResult>>,
+ accumulator?: Dictionary<TResult>
+ ): Dictionary<TResult>;
+
+ /**
+ * @see _.transform
+ */
+ transform<T, TResult>(
+ object: Dictionary<T>,
+ iteratee?: MemoVoidDictionaryIterator<T, TResult[]>,
+ accumulator?: TResult[]
+ ): TResult[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.transform
+ */
+ transform<TResult>(
+ iteratee?: MemoVoidArrayIterator<T, TResult[]>,
+ accumulator?: TResult[]
+ ): LoDashImplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.transform
+ */
+ transform<TResult>(
+ iteratee?: MemoVoidArrayIterator<T, Dictionary<TResult>>,
+ accumulator?: Dictionary<TResult>
+ ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.transform
+ */
+ transform<T, TResult>(
+ iteratee?: MemoVoidDictionaryIterator<T, Dictionary<TResult>>,
+ accumulator?: Dictionary<TResult>
+ ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
+
+ /**
+ * @see _.transform
+ */
+ transform<T, TResult>(
+ iteratee?: MemoVoidDictionaryIterator<T, TResult[]>,
+ accumulator?: TResult[]
+ ): LoDashImplicitArrayWrapper<TResult>;
+ }
+
+ //_.unset
+ interface LoDashStatic {
+ /**
+ * Removes the property at path of object.
+ *
+ * Note: This method mutates object.
+ *
+ * @param object The object to modify.
+ * @param path The path of the property to unset.
+ * @return Returns true if the property is deleted, else false.
+ */
+ unset<T>(
+ object: T,
+ path: StringRepresentable|StringRepresentable[]
+ ): boolean;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.unset
+ */
+ unset(path: StringRepresentable|StringRepresentable[]): LoDashImplicitWrapper<boolean>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.unset
+ */
+ unset(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.update
+ interface LoDashStatic {
+ /**
+ * This method is like _.set except that accepts updater to produce the value to set. Use _.updateWith to
+ * customize path creation. The updater is invoked with one argument: (value).
+ *
+ * @param object The object to modify.
+ * @param path The path of the property to set.
+ * @param updater The function to produce the updated value.
+ * @return Returns object.
+ */
+ update<TResult>(
+ object: Object,
+ path: StringRepresentable|StringRepresentable[],
+ updater: Function
+ ): TResult;
+
+ /**
+ * @see _.update
+ */
+ update<U extends Function, TResult>(
+ object: Object,
+ path: StringRepresentable|StringRepresentable[],
+ updater: U
+ ): TResult;
+
+ /**
+ * @see _.update
+ */
+ update<O extends {}, TResult>(
+ object: O,
+ path: StringRepresentable|StringRepresentable[],
+ updater: Function
+ ): TResult;
+
+ /**
+ * @see _.update
+ */
+ update<O, U extends Function, TResult>(
+ object: O,
+ path: StringRepresentable|StringRepresentable[],
+ updater: U
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.update
+ */
+ update<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ updater: any
+ ): LoDashImplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.update
+ */
+ update<U extends Function, TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ updater: U
+ ): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.update
+ */
+ update<TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ updater: any
+ ): LoDashExplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.update
+ */
+ update<U extends Function, TResult>(
+ path: StringRepresentable|StringRepresentable[],
+ updater: U
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.values
+ interface LoDashStatic {
+ /**
+ * Creates an array of the own enumerable property values of object.
+ *
+ * @param object The object to query.
+ * @return Returns an array of property values.
+ */
+ values<T>(object?: Dictionary<T>): T[];
+
+ /**
+ * @see _.values
+ */
+ values<T>(object?: any): T[];
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.values
+ */
+ values<T>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.values
+ */
+ values<T>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ //_.valuesIn
+ interface LoDashStatic {
+ /**
+ * Creates an array of the own and inherited enumerable property values of object.
+ *
+ * @param object The object to query.
+ * @return Returns the array of property values.
+ */
+ valuesIn<T>(object?: Dictionary<T>): T[];
+
+ /**
+ * @see _.valuesIn
+ */
+ valuesIn<T>(object?: any): T[];
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.valuesIn
+ */
+ valuesIn<T>(): LoDashImplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.valuesIn
+ */
+ valuesIn<T>(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ /**********
+ * String *
+ **********/
+
+ //_.camelCase
+ interface LoDashStatic {
+ /**
+ * Converts string to camel case.
+ *
+ * @param string The string to convert.
+ * @return Returns the camel cased string.
+ */
+ camelCase(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.camelCase
+ */
+ camelCase(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.camelCase
+ */
+ camelCase(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.capitalize
+ interface LoDashStatic {
+ /**
+ * Converts the first character of string to upper case and the remaining to lower case.
+ *
+ * @param string The string to capitalize.
+ * @return Returns the capitalized string.
+ */
+ capitalize(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.capitalize
+ */
+ capitalize(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.capitalize
+ */
+ capitalize(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.deburr
+ interface LoDashStatic {
+ /**
+ * Deburrs string by converting latin-1 supplementary letters to basic latin letters and removing combining
+ * diacritical marks.
+ *
+ * @param string The string to deburr.
+ * @return Returns the deburred string.
+ */
+ deburr(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.deburr
+ */
+ deburr(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.deburr
+ */
+ deburr(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.endsWith
+ interface LoDashStatic {
+ /**
+ * Checks if string ends with the given target string.
+ *
+ * @param string The string to search.
+ * @param target The string to search for.
+ * @param position The position to search from.
+ * @return Returns true if string ends with target, else false.
+ */
+ endsWith(
+ string?: string,
+ target?: string,
+ position?: number
+ ): boolean;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.endsWith
+ */
+ endsWith(
+ target?: string,
+ position?: number
+ ): boolean;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.endsWith
+ */
+ endsWith(
+ target?: string,
+ position?: number
+ ): LoDashExplicitWrapper<boolean>;
+ }
+
+ // _.escape
+ interface LoDashStatic {
+ /**
+ * Converts the characters "&", "<", ">", '"', "'", and "`" in string to their corresponding HTML entities.
+ *
+ * Note: No other characters are escaped. To escape additional characters use a third-party library like he.
+ *
+ * hough the ">" character is escaped for symmetry, characters like ">" and "/" don’t need escaping in HTML
+ * and have no special meaning unless they're part of a tag or unquoted attribute value. See Mathias Bynens’s
+ * article (under "semi-related fun fact") for more details.
+ *
+ * Backticks are escaped because in IE < 9, they can break out of attribute values or HTML comments. See #59,
+ * #102, #108, and #133 of the HTML5 Security Cheatsheet for more details.
+ *
+ * When working with HTML you should always quote attribute values to reduce XSS vectors.
+ *
+ * @param string The string to escape.
+ * @return Returns the escaped string.
+ */
+ escape(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.escape
+ */
+ escape(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.escape
+ */
+ escape(): LoDashExplicitWrapper<string>;
+ }
+
+ // _.escapeRegExp
+ interface LoDashStatic {
+ /**
+ * Escapes the RegExp special characters "^", "$", "\", ".", "*", "+", "?", "(", ")", "[", "]",
+ * "{", "}", and "|" in string.
+ *
+ * @param string The string to escape.
+ * @return Returns the escaped string.
+ */
+ escapeRegExp(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.escapeRegExp
+ */
+ escapeRegExp(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.escapeRegExp
+ */
+ escapeRegExp(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.kebabCase
+ interface LoDashStatic {
+ /**
+ * Converts string to kebab case.
+ *
+ * @param string The string to convert.
+ * @return Returns the kebab cased string.
+ */
+ kebabCase(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.kebabCase
+ */
+ kebabCase(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.kebabCase
+ */
+ kebabCase(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.lowerCase
+ interface LoDashStatic {
+ /**
+ * Converts `string`, as space separated words, to lower case.
+ *
+ * @param string The string to convert.
+ * @return Returns the lower cased string.
+ */
+ lowerCase(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.lowerCase
+ */
+ lowerCase(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.lowerCase
+ */
+ lowerCase(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.lowerFirst
+ interface LoDashStatic {
+ /**
+ * Converts the first character of `string` to lower case.
+ *
+ * @param string The string to convert.
+ * @return Returns the converted string.
+ */
+ lowerFirst(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.lowerFirst
+ */
+ lowerFirst(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.lowerFirst
+ */
+ lowerFirst(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.pad
+ interface LoDashStatic {
+ /**
+ * Pads string on the left and right sides if it’s shorter than length. Padding characters are truncated if
+ * they can’t be evenly divided by length.
+ *
+ * @param string The string to pad.
+ * @param length The padding length.
+ * @param chars The string used as padding.
+ * @return Returns the padded string.
+ */
+ pad(
+ string?: string,
+ length?: number,
+ chars?: string
+ ): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.pad
+ */
+ pad(
+ length?: number,
+ chars?: string
+ ): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.pad
+ */
+ pad(
+ length?: number,
+ chars?: string
+ ): LoDashExplicitWrapper<string>;
+ }
+
+ //_.padEnd
+ interface LoDashStatic {
+ /**
+ * Pads string on the right side if it’s shorter than length. Padding characters are truncated if they exceed
+ * length.
+ *
+ * @param string The string to pad.
+ * @param length The padding length.
+ * @param chars The string used as padding.
+ * @return Returns the padded string.
+ */
+ padEnd(
+ string?: string,
+ length?: number,
+ chars?: string
+ ): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.padEnd
+ */
+ padEnd(
+ length?: number,
+ chars?: string
+ ): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.padEnd
+ */
+ padEnd(
+ length?: number,
+ chars?: string
+ ): LoDashExplicitWrapper<string>;
+ }
+
+ //_.padStart
+ interface LoDashStatic {
+ /**
+ * Pads string on the left side if it’s shorter than length. Padding characters are truncated if they exceed
+ * length.
+ *
+ * @param string The string to pad.
+ * @param length The padding length.
+ * @param chars The string used as padding.
+ * @return Returns the padded string.
+ */
+ padStart(
+ string?: string,
+ length?: number,
+ chars?: string
+ ): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.padStart
+ */
+ padStart(
+ length?: number,
+ chars?: string
+ ): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.padStart
+ */
+ padStart(
+ length?: number,
+ chars?: string
+ ): LoDashExplicitWrapper<string>;
+ }
+
+ //_.parseInt
+ interface LoDashStatic {
+ /**
+ * Converts string to an integer of the specified radix. If radix is undefined or 0, a radix of 10 is used
+ * unless value is a hexadecimal, in which case a radix of 16 is used.
+ *
+ * Note: This method aligns with the ES5 implementation of parseInt.
+ *
+ * @param string The string to convert.
+ * @param radix The radix to interpret value by.
+ * @return Returns the converted integer.
+ */
+ parseInt(
+ string: string,
+ radix?: number
+ ): number;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.parseInt
+ */
+ parseInt(radix?: number): number;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.parseInt
+ */
+ parseInt(radix?: number): LoDashExplicitWrapper<number>;
+ }
+
+ //_.repeat
+ interface LoDashStatic {
+ /**
+ * Repeats the given string n times.
+ *
+ * @param string The string to repeat.
+ * @param n The number of times to repeat the string.
+ * @return Returns the repeated string.
+ */
+ repeat(
+ string?: string,
+ n?: number
+ ): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.repeat
+ */
+ repeat(n?: number): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.repeat
+ */
+ repeat(n?: number): LoDashExplicitWrapper<string>;
+ }
+
+ //_.replace
+ interface LoDashStatic {
+ /**
+ * Replaces matches for pattern in string with replacement.
+ *
+ * Note: This method is based on String#replace.
+ *
+ * @param string
+ * @param pattern
+ * @param replacement
+ * @return Returns the modified string.
+ */
+ replace(
+ string: string,
+ pattern: RegExp|string,
+ replacement: Function|string
+ ): string;
+
+ /**
+ * @see _.replace
+ */
+ replace(
+ pattern?: RegExp|string,
+ replacement?: Function|string
+ ): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.replace
+ */
+ replace(
+ pattern?: RegExp|string,
+ replacement?: Function|string
+ ): string;
+
+ /**
+ * @see _.replace
+ */
+ replace(
+ replacement?: Function|string
+ ): string;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.replace
+ */
+ replace(
+ pattern?: RegExp|string,
+ replacement?: Function|string
+ ): string;
+
+ /**
+ * @see _.replace
+ */
+ replace(
+ replacement?: Function|string
+ ): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.replace
+ */
+ replace(
+ pattern?: RegExp|string,
+ replacement?: Function|string
+ ): LoDashExplicitWrapper<string>;
+
+ /**
+ * @see _.replace
+ */
+ replace(
+ replacement?: Function|string
+ ): LoDashExplicitWrapper<string>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.replace
+ */
+ replace(
+ pattern?: RegExp|string,
+ replacement?: Function|string
+ ): LoDashExplicitWrapper<string>;
+
+ /**
+ * @see _.replace
+ */
+ replace(
+ replacement?: Function|string
+ ): LoDashExplicitWrapper<string>;
+ }
+
+ //_.snakeCase
+ interface LoDashStatic {
+ /**
+ * Converts string to snake case.
+ *
+ * @param string The string to convert.
+ * @return Returns the snake cased string.
+ */
+ snakeCase(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.snakeCase
+ */
+ snakeCase(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.snakeCase
+ */
+ snakeCase(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.split
+ interface LoDashStatic {
+ /**
+ * Splits string by separator.
+ *
+ * Note: This method is based on String#split.
+ *
+ * @param string
+ * @param separator
+ * @param limit
+ * @return Returns the new array of string segments.
+ */
+ split(
+ string: string,
+ separator?: RegExp|string,
+ limit?: number
+ ): string[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.split
+ */
+ split(
+ separator?: RegExp|string,
+ limit?: number
+ ): LoDashImplicitArrayWrapper<string>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.split
+ */
+ split(
+ separator?: RegExp|string,
+ limit?: number
+ ): LoDashExplicitArrayWrapper<string>;
+ }
+
+ //_.startCase
+ interface LoDashStatic {
+ /**
+ * Converts string to start case.
+ *
+ * @param string The string to convert.
+ * @return Returns the start cased string.
+ */
+ startCase(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.startCase
+ */
+ startCase(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.startCase
+ */
+ startCase(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.startsWith
+ interface LoDashStatic {
+ /**
+ * Checks if string starts with the given target string.
+ *
+ * @param string The string to search.
+ * @param target The string to search for.
+ * @param position The position to search from.
+ * @return Returns true if string starts with target, else false.
+ */
+ startsWith(
+ string?: string,
+ target?: string,
+ position?: number
+ ): boolean;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.startsWith
+ */
+ startsWith(
+ target?: string,
+ position?: number
+ ): boolean;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.startsWith
+ */
+ startsWith(
+ target?: string,
+ position?: number
+ ): LoDashExplicitWrapper<boolean>;
+ }
+
+ //_.template
+ interface TemplateOptions extends TemplateSettings {
+ /**
+ * The sourceURL of the template's compiled source.
+ */
+ sourceURL?: string;
+ }
+
+ interface TemplateExecutor {
+ (data?: Object): string;
+ source: string;
+ }
+
+ interface LoDashStatic {
+ /**
+ * Creates a compiled template function that can interpolate data properties in "interpolate" delimiters,
+ * HTML-escape interpolated data properties in "escape" delimiters, and execute JavaScript in "evaluate"
+ * delimiters. Data properties may be accessed as free variables in the template. If a setting object is
+ * provided it takes precedence over _.templateSettings values.
+ *
+ * Note: In the development build _.template utilizes
+ * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) for easier
+ * debugging.
+ *
+ * For more information on precompiling templates see
+ * [lodash's custom builds documentation](https://lodash.com/custom-builds).
+ *
+ * For more information on Chrome extension sandboxes see
+ * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
+ *
+ * @param string The template string.
+ * @param options The options object.
+ * @param options.escape The HTML "escape" delimiter.
+ * @param options.evaluate The "evaluate" delimiter.
+ * @param options.imports An object to import into the template as free variables.
+ * @param options.interpolate The "interpolate" delimiter.
+ * @param options.sourceURL The sourceURL of the template's compiled source.
+ * @param options.variable The data object variable name.
+ * @return Returns the compiled template function.
+ */
+ template(
+ string: string,
+ options?: TemplateOptions
+ ): TemplateExecutor;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.template
+ */
+ template(options?: TemplateOptions): TemplateExecutor;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.template
+ */
+ template(options?: TemplateOptions): LoDashExplicitObjectWrapper<TemplateExecutor>;
+ }
+
+ //_.toLower
+ interface LoDashStatic {
+ /**
+ * Converts `string`, as a whole, to lower case.
+ *
+ * @param string The string to convert.
+ * @return Returns the lower cased string.
+ */
+ toLower(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.toLower
+ */
+ toLower(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.toLower
+ */
+ toLower(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.toUpper
+ interface LoDashStatic {
+ /**
+ * Converts `string`, as a whole, to upper case.
+ *
+ * @param string The string to convert.
+ * @return Returns the upper cased string.
+ */
+ toUpper(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.toUpper
+ */
+ toUpper(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.toUpper
+ */
+ toUpper(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.trim
+ interface LoDashStatic {
+ /**
+ * Removes leading and trailing whitespace or specified characters from string.
+ *
+ * @param string The string to trim.
+ * @param chars The characters to trim.
+ * @return Returns the trimmed string.
+ */
+ trim(
+ string?: string,
+ chars?: string
+ ): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.trim
+ */
+ trim(chars?: string): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.trim
+ */
+ trim(chars?: string): LoDashExplicitWrapper<string>;
+ }
+
+ //_.trimEnd
+ interface LoDashStatic {
+ /**
+ * Removes trailing whitespace or specified characters from string.
+ *
+ * @param string The string to trim.
+ * @param chars The characters to trim.
+ * @return Returns the trimmed string.
+ */
+ trimEnd(
+ string?: string,
+ chars?: string
+ ): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.trimEnd
+ */
+ trimEnd(chars?: string): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.trimEnd
+ */
+ trimEnd(chars?: string): LoDashExplicitWrapper<string>;
+ }
+
+ //_.trimStart
+ interface LoDashStatic {
+ /**
+ * Removes leading whitespace or specified characters from string.
+ *
+ * @param string The string to trim.
+ * @param chars The characters to trim.
+ * @return Returns the trimmed string.
+ */
+ trimStart(
+ string?: string,
+ chars?: string
+ ): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.trimStart
+ */
+ trimStart(chars?: string): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.trimStart
+ */
+ trimStart(chars?: string): LoDashExplicitWrapper<string>;
+ }
+
+ //_.truncate
+ interface TruncateOptions {
+ /** The maximum string length. */
+ length?: number;
+ /** The string to indicate text is omitted. */
+ omission?: string;
+ /** The separator pattern to truncate to. */
+ separator?: string|RegExp;
+ }
+
+ interface LoDashStatic {
+ /**
+ * Truncates string if it’s longer than the given maximum string length. The last characters of the truncated
+ * string are replaced with the omission string which defaults to "…".
+ *
+ * @param string The string to truncate.
+ * @param options The options object or maximum string length.
+ * @return Returns the truncated string.
+ */
+ truncate(
+ string?: string,
+ options?: TruncateOptions
+ ): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.truncate
+ */
+ truncate(options?: TruncateOptions): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.truncate
+ */
+ truncate(options?: TruncateOptions): LoDashExplicitWrapper<string>;
+ }
+
+ //_.unescape
+ interface LoDashStatic {
+ /**
+ * The inverse of _.escape; this method converts the HTML entities &amp;, &lt;, &gt;, &quot;, &#39;, and &#96;
+ * in string to their corresponding characters.
+ *
+ * Note: No other HTML entities are unescaped. To unescape additional HTML entities use a third-party library
+ * like he.
+ *
+ * @param string The string to unescape.
+ * @return Returns the unescaped string.
+ */
+ unescape(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.unescape
+ */
+ unescape(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.unescape
+ */
+ unescape(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.upperCase
+ interface LoDashStatic {
+ /**
+ * Converts `string`, as space separated words, to upper case.
+ *
+ * @param string The string to convert.
+ * @return Returns the upper cased string.
+ */
+ upperCase(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.upperCase
+ */
+ upperCase(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.upperCase
+ */
+ upperCase(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.upperFirst
+ interface LoDashStatic {
+ /**
+ * Converts the first character of `string` to upper case.
+ *
+ * @param string The string to convert.
+ * @return Returns the converted string.
+ */
+ upperFirst(string?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.upperFirst
+ */
+ upperFirst(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.upperFirst
+ */
+ upperFirst(): LoDashExplicitWrapper<string>;
+ }
+
+ //_.words
+ interface LoDashStatic {
+ /**
+ * Splits `string` into an array of its words.
+ *
+ * @param string The string to inspect.
+ * @param pattern The pattern to match words.
+ * @return Returns the words of `string`.
+ */
+ words(
+ string?: string,
+ pattern?: string|RegExp
+ ): string[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.words
+ */
+ words(pattern?: string|RegExp): string[];
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.words
+ */
+ words(pattern?: string|RegExp): LoDashExplicitArrayWrapper<string>;
+ }
+
+ /***********
+ * Utility *
+ ***********/
+
+ //_.attempt
+ interface LoDashStatic {
+ /**
+ * Attempts to invoke func, returning either the result or the caught error object. Any additional arguments
+ * are provided to func when it’s invoked.
+ *
+ * @param func The function to attempt.
+ * @return Returns the func result or error object.
+ */
+ attempt<TResult>(func: (...args: any[]) => TResult, ...args: any[]): TResult|Error;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.attempt
+ */
+ attempt<TResult>(...args: any[]): TResult|Error;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.attempt
+ */
+ attempt<TResult>(...args: any[]): LoDashExplicitObjectWrapper<TResult|Error>;
+ }
+
+ //_.constant
+ interface LoDashStatic {
+ /**
+ * Creates a function that returns value.
+ *
+ * @param value The value to return from the new function.
+ * @return Returns the new function.
+ */
+ constant<T>(value: T): () => T;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.constant
+ */
+ constant<TResult>(): LoDashImplicitObjectWrapper<() => TResult>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.constant
+ */
+ constant<TResult>(): LoDashExplicitObjectWrapper<() => TResult>;
+ }
+
+ //_.defaultTo
+ interface LoDashStatic {
+ /**
+ * Checks `value` to determine whether a default value should be returned in
+ * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
+ * or `undefined`.
+ *
+ * @param value The value to check.
+ * @param defaultValue The default value.
+ * @returns Returns the resolved value.
+ */
+ defaultTo<T>(value: T, defaultValue: T): T;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.defaultTo
+ */
+ defaultTo<TResult>(value: TResult): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.defaultTo
+ */
+ defaultTo<TResult>(value: TResult): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.identity
+ interface LoDashStatic {
+ /**
+ * This method returns the first argument provided to it.
+ *
+ * @param value Any value.
+ * @return Returns value.
+ */
+ identity<T>(value?: T): T;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.identity
+ */
+ identity(): T;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.identity
+ */
+ identity(): T[];
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.identity
+ */
+ identity(): T;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.identity
+ */
+ identity(): LoDashExplicitWrapper<T>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.identity
+ */
+ identity(): LoDashExplicitArrayWrapper<T>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.identity
+ */
+ identity(): LoDashExplicitObjectWrapper<T>;
+ }
+
+ //_.iteratee
+ interface LoDashStatic {
+ /**
+ * Creates a function that invokes `func` with the arguments of the created
+ * function. If `func` is a property name the created callback returns the
+ * property value for a given element. If `func` is an object the created
+ * callback returns `true` for elements that contain the equivalent object properties, otherwise it returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Util
+ * @param {*} [func=_.identity] The value to convert to a callback.
+ * @returns {Function} Returns the callback.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36 },
+ * { 'user': 'fred', 'age': 40 }
+ * ];
+ *
+ * // create custom iteratee shorthands
+ * _.iteratee = _.wrap(_.iteratee, function(callback, func) {
+ * var p = /^(\S+)\s*([<>])\s*(\S+)$/.exec(func);
+ * return !p ? callback(func) : function(object) {
+ * return (p[2] == '>' ? object[p[1]] > p[3] : object[p[1]] < p[3]);
+ * };
+ * });
+ *
+ * _.filter(users, 'age > 36');
+ * // => [{ 'user': 'fred', 'age': 40 }]
+ */
+ iteratee<TResult>(
+ func: Function
+ ): (...args: any[]) => TResult;
+
+ /**
+ * @see _.iteratee
+ */
+ iteratee<TResult>(
+ func: string
+ ): (object: any) => TResult;
+
+ /**
+ * @see _.iteratee
+ */
+ iteratee(
+ func: Object
+ ): (object: any) => boolean;
+
+ /**
+ * @see _.iteratee
+ */
+ iteratee<TResult>(): (value: TResult) => TResult;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.iteratee
+ */
+ iteratee<TResult>(): LoDashImplicitObjectWrapper<(object: any) => TResult>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.iteratee
+ */
+ iteratee(): LoDashImplicitObjectWrapper<(object: any) => boolean>;
+
+ /**
+ * @see _.iteratee
+ */
+ iteratee<TResult>(): LoDashImplicitObjectWrapper<(...args: any[]) => TResult>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.iteratee
+ */
+ iteratee<TResult>(): LoDashExplicitObjectWrapper<(object: any) => TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.iteratee
+ */
+ iteratee(): LoDashExplicitObjectWrapper<(object: any) => boolean>;
+
+ /**
+ * @see _.iteratee
+ */
+ iteratee<TResult>(): LoDashExplicitObjectWrapper<(...args: any[]) => TResult>;
+ }
+
+ //_.matches
+ interface LoDashStatic {
+ /**
+ * Creates a function that performs a deep comparison between a given object and source, returning true if the
+ * given object has equivalent property values, else false.
+ *
+ * Note: This method supports comparing arrays, booleans, Date objects, numbers, Object objects, regexes, and
+ * strings. Objects are compared by their own, not inherited, enumerable properties. For comparing a single own
+ * or inherited property value see _.matchesProperty.
+ *
+ * @param source The object of property values to match.
+ * @return Returns the new function.
+ */
+ matches<T>(source: T): (value: any) => boolean;
+
+ /**
+ * @see _.matches
+ */
+ matches<T, V>(source: T): (value: V) => boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.matches
+ */
+ matches<V>(): LoDashImplicitObjectWrapper<(value: V) => boolean>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.matches
+ */
+ matches<V>(): LoDashExplicitObjectWrapper<(value: V) => boolean>;
+ }
+
+ //_.matchesProperty
+ interface LoDashStatic {
+ /**
+ * Creates a function that compares the property value of path on a given object to value.
+ *
+ * Note: This method supports comparing arrays, booleans, Date objects, numbers, Object objects, regexes, and
+ * strings. Objects are compared by their own, not inherited, enumerable properties.
+ *
+ * @param path The path of the property to get.
+ * @param srcValue The value to match.
+ * @return Returns the new function.
+ */
+ matchesProperty<T>(
+ path: StringRepresentable|StringRepresentable[],
+ srcValue: T
+ ): (value: any) => boolean;
+
+ /**
+ * @see _.matchesProperty
+ */
+ matchesProperty<T, V>(
+ path: StringRepresentable|StringRepresentable[],
+ srcValue: T
+ ): (value: V) => boolean;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.matchesProperty
+ */
+ matchesProperty<SrcValue>(
+ srcValue: SrcValue
+ ): LoDashImplicitObjectWrapper<(value: any) => boolean>;
+
+ /**
+ * @see _.matchesProperty
+ */
+ matchesProperty<SrcValue, Value>(
+ srcValue: SrcValue
+ ): LoDashImplicitObjectWrapper<(value: Value) => boolean>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.matchesProperty
+ */
+ matchesProperty<SrcValue>(
+ srcValue: SrcValue
+ ): LoDashExplicitObjectWrapper<(value: any) => boolean>;
+
+ /**
+ * @see _.matchesProperty
+ */
+ matchesProperty<SrcValue, Value>(
+ srcValue: SrcValue
+ ): LoDashExplicitObjectWrapper<(value: Value) => boolean>;
+ }
+
+ //_.method
+ interface LoDashStatic {
+ /**
+ * Creates a function that invokes the method at path on a given object. Any additional arguments are provided
+ * to the invoked method.
+ *
+ * @param path The path of the method to invoke.
+ * @param args The arguments to invoke the method with.
+ * @return Returns the new function.
+ */
+ method<TObject, TResult>(
+ path: string|StringRepresentable[],
+ ...args: any[]
+ ): (object: TObject) => TResult;
+
+ /**
+ * @see _.method
+ */
+ method<TResult>(
+ path: string|StringRepresentable[],
+ ...args: any[]
+ ): (object: any) => TResult;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.method
+ */
+ method<TObject, TResult>(...args: any[]): LoDashImplicitObjectWrapper<(object: TObject) => TResult>;
+
+ /**
+ * @see _.method
+ */
+ method<TResult>(...args: any[]): LoDashImplicitObjectWrapper<(object: any) => TResult>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.method
+ */
+ method<TObject, TResult>(...args: any[]): LoDashImplicitObjectWrapper<(object: TObject) => TResult>;
+
+ /**
+ * @see _.method
+ */
+ method<TResult>(...args: any[]): LoDashImplicitObjectWrapper<(object: any) => TResult>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.method
+ */
+ method<TObject, TResult>(...args: any[]): LoDashExplicitObjectWrapper<(object: TObject) => TResult>;
+
+ /**
+ * @see _.method
+ */
+ method<TResult>(...args: any[]): LoDashExplicitObjectWrapper<(object: any) => TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.method
+ */
+ method<TObject, TResult>(...args: any[]): LoDashExplicitObjectWrapper<(object: TObject) => TResult>;
+
+ /**
+ * @see _.method
+ */
+ method<TResult>(...args: any[]): LoDashExplicitObjectWrapper<(object: any) => TResult>;
+ }
+
+ //_.methodOf
+ interface LoDashStatic {
+ /**
+ * The opposite of _.method; this method creates a function that invokes the method at a given path on object.
+ * Any additional arguments are provided to the invoked method.
+ *
+ * @param object The object to query.
+ * @param args The arguments to invoke the method with.
+ * @return Returns the new function.
+ */
+ methodOf<TObject extends {}, TResult>(
+ object: TObject,
+ ...args: any[]
+ ): (path: StringRepresentable|StringRepresentable[]) => TResult;
+
+ /**
+ * @see _.methodOf
+ */
+ methodOf<TResult>(
+ object: {},
+ ...args: any[]
+ ): (path: StringRepresentable|StringRepresentable[]) => TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.methodOf
+ */
+ methodOf<TResult>(
+ ...args: any[]
+ ): LoDashImplicitObjectWrapper<(path: StringRepresentable|StringRepresentable[]) => TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.methodOf
+ */
+ methodOf<TResult>(
+ ...args: any[]
+ ): LoDashExplicitObjectWrapper<(path: StringRepresentable|StringRepresentable[]) => TResult>;
+ }
+
+ //_.mixin
+ interface MixinOptions {
+ chain?: boolean;
+ }
+
+ interface LoDashStatic {
+ /**
+ * Adds all own enumerable function properties of a source object to the destination object. If object is a
+ * function then methods are added to its prototype as well.
+ *
+ * Note: Use _.runInContext to create a pristine lodash function to avoid conflicts caused by modifying
+ * the original.
+ *
+ * @param object The destination object.
+ * @param source The object of functions to add.
+ * @param options The options object.
+ * @param options.chain Specify whether the functions added are chainable.
+ * @return Returns object.
+ */
+ mixin<TResult, TObject>(
+ object: TObject,
+ source: Dictionary<Function>,
+ options?: MixinOptions
+ ): TResult;
+
+ /**
+ * @see _.mixin
+ */
+ mixin<TResult>(
+ source: Dictionary<Function>,
+ options?: MixinOptions
+ ): TResult;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.mixin
+ */
+ mixin<TResult>(
+ source: Dictionary<Function>,
+ options?: MixinOptions
+ ): LoDashImplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.mixin
+ */
+ mixin<TResult>(
+ options?: MixinOptions
+ ): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.mixin
+ */
+ mixin<TResult>(
+ source: Dictionary<Function>,
+ options?: MixinOptions
+ ): LoDashExplicitObjectWrapper<TResult>;
+
+ /**
+ * @see _.mixin
+ */
+ mixin<TResult>(
+ options?: MixinOptions
+ ): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.noConflict
+ interface LoDashStatic {
+ /**
+ * Reverts the _ variable to its previous value and returns a reference to the lodash function.
+ *
+ * @return Returns the lodash function.
+ */
+ noConflict(): typeof _;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.noConflict
+ */
+ noConflict(): typeof _;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.noConflict
+ */
+ noConflict(): LoDashExplicitObjectWrapper<typeof _>;
+ }
+
+ //_.noop
+ interface LoDashStatic {
+ /**
+ * A no-operation function that returns undefined regardless of the arguments it receives.
+ *
+ * @return undefined
+ */
+ noop(...args: any[]): void;
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.noop
+ */
+ noop(...args: any[]): void;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.noop
+ */
+ noop(...args: any[]): _.LoDashExplicitWrapper<void>;
+ }
+
+ //_.nthArg
+ interface LoDashStatic {
+ /**
+ * Creates a function that returns its nth argument.
+ *
+ * @param n The index of the argument to return.
+ * @return Returns the new function.
+ */
+ nthArg<TResult extends Function>(n?: number): TResult;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.nthArg
+ */
+ nthArg<TResult extends Function>(): LoDashImplicitObjectWrapper<TResult>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.nthArg
+ */
+ nthArg<TResult extends Function>(): LoDashExplicitObjectWrapper<TResult>;
+ }
+
+ //_.over
+ interface LoDashStatic {
+ /**
+ * Creates a function that invokes iteratees with the arguments provided to the created function and returns
+ * their results.
+ *
+ * @param iteratees The iteratees to invoke.
+ * @return Returns the new function.
+ */
+ over<TResult>(...iteratees: (Function|Function[])[]): (...args: any[]) => TResult[];
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.over
+ */
+ over<TResult>(...iteratees: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => TResult[]>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.over
+ */
+ over<TResult>(...iteratees: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => TResult[]>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.over
+ */
+ over<TResult>(...iteratees: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => TResult[]>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.over
+ */
+ over<TResult>(...iteratees: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => TResult[]>;
+ }
+
+ //_.overEvery
+ interface LoDashStatic {
+ /**
+ * Creates a function that checks if all of the predicates return truthy when invoked with the arguments
+ * provided to the created function.
+ *
+ * @param predicates The predicates to check.
+ * @return Returns the new function.
+ */
+ overEvery(...predicates: (Function|Function[])[]): (...args: any[]) => boolean;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.overEvery
+ */
+ overEvery(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.overEvery
+ */
+ overEvery(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.overEvery
+ */
+ overEvery(...predicates: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.overEvery
+ */
+ overEvery(...predicates: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>;
+ }
+
+ //_.overSome
+ interface LoDashStatic {
+ /**
+ * Creates a function that checks if any of the predicates return truthy when invoked with the arguments
+ * provided to the created function.
+ *
+ * @param predicates The predicates to check.
+ * @return Returns the new function.
+ */
+ overSome(...predicates: (Function|Function[])[]): (...args: any[]) => boolean;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.overSome
+ */
+ overSome(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.overSome
+ */
+ overSome(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.overSome
+ */
+ overSome(...predicates: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.overSome
+ */
+ overSome(...predicates: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>;
+ }
+
+ //_.property
+ interface LoDashStatic {
+ /**
+ * Creates a function that returns the property value at path on a given object.
+ *
+ * @param path The path of the property to get.
+ * @return Returns the new function.
+ */
+ property<TObj, TResult>(path: StringRepresentable|StringRepresentable[]): (obj: TObj) => TResult;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.property
+ */
+ property<TObj, TResult>(): LoDashImplicitObjectWrapper<(obj: TObj) => TResult>;
+ }
+
+ interface LoDashImplicitArrayWrapper<T> {
+ /**
+ * @see _.property
+ */
+ property<TObj, TResult>(): LoDashImplicitObjectWrapper<(obj: TObj) => TResult>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.property
+ */
+ property<TObj, TResult>(): LoDashExplicitObjectWrapper<(obj: TObj) => TResult>;
+ }
+
+ interface LoDashExplicitArrayWrapper<T> {
+ /**
+ * @see _.property
+ */
+ property<TObj, TResult>(): LoDashExplicitObjectWrapper<(obj: TObj) => TResult>;
+ }
+
+ //_.propertyOf
+ interface LoDashStatic {
+ /**
+ * The opposite of _.property; this method creates a function that returns the property value at a given path
+ * on object.
+ *
+ * @param object The object to query.
+ * @return Returns the new function.
+ */
+ propertyOf<T extends {}>(object: T): (path: string|string[]) => any;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.propertyOf
+ */
+ propertyOf(): LoDashImplicitObjectWrapper<(path: string|string[]) => any>;
+ }
+
+ interface LoDashExplicitObjectWrapper<T> {
+ /**
+ * @see _.propertyOf
+ */
+ propertyOf(): LoDashExplicitObjectWrapper<(path: string|string[]) => any>;
+ }
+
+ //_.range
+ interface LoDashStatic {
+ /**
+ * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end.
+ * If end is not specified it’s set to start with start then set to 0. If end is less than start a zero-length
+ * range is created unless a negative step is specified.
+ *
+ * @param start The start of the range.
+ * @param end The end of the range.
+ * @param step The value to increment or decrement by.
+ * @return Returns a new range array.
+ */
+ range(
+ start: number,
+ end: number,
+ step?: number
+ ): number[];
+
+ /**
+ * @see _.range
+ */
+ range(
+ end: number,
+ step?: number
+ ): number[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.range
+ */
+ range(
+ end?: number,
+ step?: number
+ ): LoDashImplicitArrayWrapper<number>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.range
+ */
+ range(
+ end?: number,
+ step?: number
+ ): LoDashExplicitArrayWrapper<number>;
+ }
+
+ //_.rangeRight
+ interface LoDashStatic {
+ /**
+ * This method is like `_.range` except that it populates values in
+ * descending order.
+ *
+ * @static
+ * @memberOf _
+ * @category Util
+ * @param {number} [start=0] The start of the range.
+ * @param {number} end The end of the range.
+ * @param {number} [step=1] The value to increment or decrement by.
+ * @returns {Array} Returns the new array of numbers.
+ * @example
+ *
+ * _.rangeRight(4);
+ * // => [3, 2, 1, 0]
+ *
+ * _.rangeRight(-4);
+ * // => [-3, -2, -1, 0]
+ *
+ * _.rangeRight(1, 5);
+ * // => [4, 3, 2, 1]
+ *
+ * _.rangeRight(0, 20, 5);
+ * // => [15, 10, 5, 0]
+ *
+ * _.rangeRight(0, -4, -1);
+ * // => [-3, -2, -1, 0]
+ *
+ * _.rangeRight(1, 4, 0);
+ * // => [1, 1, 1]
+ *
+ * _.rangeRight(0);
+ * // => []
+ */
+ rangeRight(
+ start: number,
+ end: number,
+ step?: number
+ ): number[];
+
+ /**
+ * @see _.rangeRight
+ */
+ rangeRight(
+ end: number,
+ step?: number
+ ): number[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.rangeRight
+ */
+ rangeRight(
+ end?: number,
+ step?: number
+ ): LoDashImplicitArrayWrapper<number>;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.rangeRight
+ */
+ rangeRight(
+ end?: number,
+ step?: number
+ ): LoDashExplicitArrayWrapper<number>;
+ }
+
+ //_.runInContext
+ interface LoDashStatic {
+ /**
+ * Create a new pristine lodash function using the given context object.
+ *
+ * @param context The context object.
+ * @return Returns a new lodash function.
+ */
+ runInContext(context?: Object): typeof _;
+ }
+
+ interface LoDashImplicitObjectWrapper<T> {
+ /**
+ * @see _.runInContext
+ */
+ runInContext(): typeof _;
+ }
+
+ //_.times
+ interface LoDashStatic {
+ /**
+ * Invokes the iteratee function n times, returning an array of the results of each invocation. The iteratee
+ * is invoked with one argument; (index).
+ *
+ * @param n The number of times to invoke iteratee.
+ * @param iteratee The function invoked per iteration.
+ * @return Returns the array of results.
+ */
+ times<TResult>(
+ n: number,
+ iteratee: (num: number) => TResult
+ ): TResult[];
+
+ /**
+ * @see _.times
+ */
+ times(n: number): number[];
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.times
+ */
+ times<TResult>(
+ iteratee: (num: number) => TResult
+ ): TResult[];
+
+ /**
+ * @see _.times
+ */
+ times(): number[];
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.times
+ */
+ times<TResult>(
+ iteratee: (num: number) => TResult
+ ): LoDashExplicitArrayWrapper<TResult>;
+
+ /**
+ * @see _.times
+ */
+ times(): LoDashExplicitArrayWrapper<number>;
+ }
+
+ //_.toPath
+ interface LoDashStatic {
+ /**
+ * Converts `value` to a property path array.
+ *
+ * @static
+ * @memberOf _
+ * @category Util
+ * @param {*} value The value to convert.
+ * @returns {Array} Returns the new property path array.
+ * @example
+ *
+ * _.toPath('a.b.c');
+ * // => ['a', 'b', 'c']
+ *
+ * _.toPath('a[0].b.c');
+ * // => ['a', '0', 'b', 'c']
+ *
+ * var path = ['a', 'b', 'c'],
+ * newPath = _.toPath(path);
+ *
+ * console.log(newPath);
+ * // => ['a', 'b', 'c']
+ *
+ * console.log(path === newPath);
+ * // => false
+ */
+ toPath(value: any): string[];
+ }
+
+ interface LoDashImplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.toPath
+ */
+ toPath(): LoDashImplicitWrapper<string[]>;
+ }
+
+ interface LoDashExplicitWrapperBase<T, TWrapper> {
+ /**
+ * @see _.toPath
+ */
+ toPath(): LoDashExplicitWrapper<string[]>;
+ }
+
+ //_.uniqueId
+ interface LoDashStatic {
+ /**
+ * Generates a unique ID. If prefix is provided the ID is appended to it.
+ *
+ * @param prefix The value to prefix the ID with.
+ * @return Returns the unique ID.
+ */
+ uniqueId(prefix?: string): string;
+ }
+
+ interface LoDashImplicitWrapper<T> {
+ /**
+ * @see _.uniqueId
+ */
+ uniqueId(): string;
+ }
+
+ interface LoDashExplicitWrapper<T> {
+ /**
+ * @see _.uniqueId
+ */
+ uniqueId(): LoDashExplicitWrapper<string>;
+ }
+
+ interface ListIterator<T, TResult> {
+ (value: T, index: number, collection: List<T>): TResult;
+ }
+
+ interface DictionaryIterator<T, TResult> {
+ (value: T, key?: string, collection?: Dictionary<T>): TResult;
+ }
+
+ interface NumericDictionaryIterator<T, TResult> {
+ (value: T, key?: number, collection?: Dictionary<T>): TResult;
+ }
+
+ interface ObjectIterator<T, TResult> {
+ (element: T, key?: string, collection?: any): TResult;
+ }
+
+ interface StringIterator<TResult> {
+ (char: string, index?: number, string?: string): TResult;
+ }
+
+ interface MemoVoidIterator<T, TResult> {
+ (prev: TResult, curr: T, indexOrKey?: any, list?: T[]): void;
+ }
+ interface MemoIterator<T, TResult> {
+ (prev: TResult, curr: T, indexOrKey?: any, list?: T[]): TResult;
+ }
+
+ interface MemoVoidArrayIterator<T, TResult> {
+ (acc: TResult, curr: T, index?: number, arr?: T[]): void;
+ }
+ interface MemoVoidDictionaryIterator<T, TResult> {
+ (acc: TResult, curr: T, key?: string, dict?: Dictionary<T>): void;
+ }
+
+ //interface Collection<T> {}
+
+ // Common interface between Arrays and jQuery objects
+ interface List<T> {
+ [index: number]: T;
+ length: number;
+ }
+
+ interface Dictionary<T> {
+ [index: string]: T;
+ }
+
+ interface NumericDictionary<T> {
+ [index: number]: T;
+ }
+
+ interface StringRepresentable {
+ toString(): string;
+ }
+
+ interface Cancelable {
+ cancel(): void;
+ flush(): void;
+ }
+}
+
+// Named exports
+
+declare module "lodash/after" {
+ const after: typeof _.after;
+ export = after;
+}
+
+
+declare module "lodash/ary" {
+ const ary: typeof _.ary;
+ export = ary;
+}
+
+
+declare module "lodash/assign" {
+ const assign: typeof _.assign;
+ export = assign;
+}
+
+
+declare module "lodash/assignIn" {
+ const assignIn: typeof _.assignIn;
+ export = assignIn;
+}
+
+
+declare module "lodash/assignInWith" {
+ const assignInWith: typeof _.assignInWith;
+ export = assignInWith;
+}
+
+
+declare module "lodash/assignWith" {
+ const assignWith: typeof _.assignWith;
+ export = assignWith;
+}
+
+
+declare module "lodash/at" {
+ const at: typeof _.at;
+ export = at;
+}
+
+
+declare module "lodash/before" {
+ const before: typeof _.before;
+ export = before;
+}
+
+
+declare module "lodash/bind" {
+ const bind: typeof _.bind;
+ export = bind;
+}
+
+
+declare module "lodash/bindAll" {
+ const bindAll: typeof _.bindAll;
+ export = bindAll;
+}
+
+
+declare module "lodash/bindKey" {
+ const bindKey: typeof _.bindKey;
+ export = bindKey;
+}
+
+
+declare module "lodash/castArray" {
+ const castArray: typeof _.castArray;
+ export = castArray;
+}
+
+
+declare module "lodash/chain" {
+ const chain: typeof _.chain;
+ export = chain;
+}
+
+
+declare module "lodash/chunk" {
+ const chunk: typeof _.chunk;
+ export = chunk;
+}
+
+
+declare module "lodash/compact" {
+ const compact: typeof _.compact;
+ export = compact;
+}
+
+
+declare module "lodash/concat" {
+ const concat: typeof _.concat;
+ export = concat;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/cond" {
+ const cond: typeof _.cond;
+ export = cond;
+ }
+ */
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/conforms" {
+ const conforms: typeof _.conforms;
+ export = conforms;
+ }
+ */
+
+declare module "lodash/constant" {
+ const constant: typeof _.constant;
+ export = constant;
+}
+
+
+declare module "lodash/countBy" {
+ const countBy: typeof _.countBy;
+ export = countBy;
+}
+
+
+declare module "lodash/create" {
+ const create: typeof _.create;
+ export = create;
+}
+
+
+declare module "lodash/curry" {
+ const curry: typeof _.curry;
+ export = curry;
+}
+
+
+declare module "lodash/curryRight" {
+ const curryRight: typeof _.curryRight;
+ export = curryRight;
+}
+
+
+declare module "lodash/debounce" {
+ const debounce: typeof _.debounce;
+ export = debounce;
+}
+
+
+declare module "lodash/defaults" {
+ const defaults: typeof _.defaults;
+ export = defaults;
+}
+
+
+declare module "lodash/defaultsDeep" {
+ const defaultsDeep: typeof _.defaultsDeep;
+ export = defaultsDeep;
+}
+
+
+declare module "lodash/defer" {
+ const defer: typeof _.defer;
+ export = defer;
+}
+
+
+declare module "lodash/delay" {
+ const delay: typeof _.delay;
+ export = delay;
+}
+
+
+declare module "lodash/difference" {
+ const difference: typeof _.difference;
+ export = difference;
+}
+
+
+declare module "lodash/differenceBy" {
+ const differenceBy: typeof _.differenceBy;
+ export = differenceBy;
+}
+
+
+declare module "lodash/differenceWith" {
+ const differenceWith: typeof _.differenceWith;
+ export = differenceWith;
+}
+
+
+declare module "lodash/drop" {
+ const drop: typeof _.drop;
+ export = drop;
+}
+
+
+declare module "lodash/dropRight" {
+ const dropRight: typeof _.dropRight;
+ export = dropRight;
+}
+
+
+declare module "lodash/dropRightWhile" {
+ const dropRightWhile: typeof _.dropRightWhile;
+ export = dropRightWhile;
+}
+
+
+declare module "lodash/dropWhile" {
+ const dropWhile: typeof _.dropWhile;
+ export = dropWhile;
+}
+
+
+declare module "lodash/fill" {
+ const fill: typeof _.fill;
+ export = fill;
+}
+
+
+declare module "lodash/filter" {
+ const filter: typeof _.filter;
+ export = filter;
+}
+
+
+declare module "lodash/flatMap" {
+ const flatMap: typeof _.flatMap;
+ export = flatMap;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/flatMapDeep" {
+ const flatMapDeep: typeof _.flatMapDeep;
+ export = flatMapDeep;
+ }
+ */
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/flatMapDepth" {
+ const flatMapDepth: typeof _.flatMapDepth;
+ export = flatMapDepth;
+ }
+ */
+
+declare module "lodash/flatten" {
+ const flatten: typeof _.flatten;
+ export = flatten;
+}
+
+
+declare module "lodash/flattenDeep" {
+ const flattenDeep: typeof _.flattenDeep;
+ export = flattenDeep;
+}
+
+declare module "lodash/flattenDepth" {
+ const flattenDepth: typeof _.flattenDepth;
+ export = flattenDepth;
+}
+
+declare module "lodash/flip" {
+ const flip: typeof _.flip;
+ export = flip;
+}
+
+
+declare module "lodash/flow" {
+ const flow: typeof _.flow;
+ export = flow;
+}
+
+
+declare module "lodash/flowRight" {
+ const flowRight: typeof _.flowRight;
+ export = flowRight;
+}
+
+
+declare module "lodash/fromPairs" {
+ const fromPairs: typeof _.fromPairs;
+ export = fromPairs;
+}
+
+
+declare module "lodash/functions" {
+ const functions: typeof _.functions;
+ export = functions;
+}
+
+
+declare module "lodash/functionsIn" {
+ const functionsIn: typeof _.functionsIn;
+ export = functionsIn;
+}
+
+
+declare module "lodash/groupBy" {
+ const groupBy: typeof _.groupBy;
+ export = groupBy;
+}
+
+
+declare module "lodash/initial" {
+ const initial: typeof _.initial;
+ export = initial;
+}
+
+
+declare module "lodash/intersection" {
+ const intersection: typeof _.intersection;
+ export = intersection;
+}
+
+
+declare module "lodash/intersectionBy" {
+ const intersectionBy: typeof _.intersectionBy;
+ export = intersectionBy;
+}
+
+
+declare module "lodash/intersectionWith" {
+ const intersectionWith: typeof _.intersectionWith;
+ export = intersectionWith;
+}
+
+
+declare module "lodash/invert" {
+ const invert: typeof _.invert;
+ export = invert;
+}
+
+
+declare module "lodash/invertBy" {
+ const invertBy: typeof _.invertBy;
+ export = invertBy;
+}
+
+
+declare module "lodash/invokeMap" {
+ const invokeMap: typeof _.invokeMap;
+ export = invokeMap;
+}
+
+
+declare module "lodash/iteratee" {
+ const iteratee: typeof _.iteratee;
+ export = iteratee;
+}
+
+
+declare module "lodash/keyBy" {
+ const keyBy: typeof _.keyBy;
+ export = keyBy;
+}
+
+
+declare module "lodash/keys" {
+ const keys: typeof _.keys;
+ export = keys;
+}
+
+
+declare module "lodash/keysIn" {
+ const keysIn: typeof _.keysIn;
+ export = keysIn;
+}
+
+
+declare module "lodash/map" {
+ const map: typeof _.map;
+ export = map;
+}
+
+
+declare module "lodash/mapKeys" {
+ const mapKeys: typeof _.mapKeys;
+ export = mapKeys;
+}
+
+
+declare module "lodash/mapValues" {
+ const mapValues: typeof _.mapValues;
+ export = mapValues;
+}
+
+
+declare module "lodash/matches" {
+ const matches: typeof _.matches;
+ export = matches;
+}
+
+
+declare module "lodash/matchesProperty" {
+ const matchesProperty: typeof _.matchesProperty;
+ export = matchesProperty;
+}
+
+
+declare module "lodash/memoize" {
+ const memoize: typeof _.memoize;
+ export = memoize;
+}
+
+
+declare module "lodash/merge" {
+ const merge: typeof _.merge;
+ export = merge;
+}
+
+
+declare module "lodash/mergeWith" {
+ const mergeWith: typeof _.mergeWith;
+ export = mergeWith;
+}
+
+
+declare module "lodash/method" {
+ const method: typeof _.method;
+ export = method;
+}
+
+
+declare module "lodash/methodOf" {
+ const methodOf: typeof _.methodOf;
+ export = methodOf;
+}
+
+
+declare module "lodash/mixin" {
+ const mixin: typeof _.mixin;
+ export = mixin;
+}
+
+
+declare module "lodash/negate" {
+ const negate: typeof _.negate;
+ export = negate;
+}
+
+
+declare module "lodash/nthArg" {
+ const nthArg: typeof _.nthArg;
+ export = nthArg;
+}
+
+
+declare module "lodash/omit" {
+ const omit: typeof _.omit;
+ export = omit;
+}
+
+
+declare module "lodash/omitBy" {
+ const omitBy: typeof _.omitBy;
+ export = omitBy;
+}
+
+
+declare module "lodash/once" {
+ const once: typeof _.once;
+ export = once;
+}
+
+
+declare module "lodash/orderBy" {
+ const orderBy: typeof _.orderBy;
+ export = orderBy;
+}
+
+
+declare module "lodash/over" {
+ const over: typeof _.over;
+ export = over;
+}
+
+
+declare module "lodash/overArgs" {
+ const overArgs: typeof _.overArgs;
+ export = overArgs;
+}
+
+
+declare module "lodash/overEvery" {
+ const overEvery: typeof _.overEvery;
+ export = overEvery;
+}
+
+
+declare module "lodash/overSome" {
+ const overSome: typeof _.overSome;
+ export = overSome;
+}
+
+
+declare module "lodash/partial" {
+ const partial: typeof _.partial;
+ export = partial;
+}
+
+
+declare module "lodash/partialRight" {
+ const partialRight: typeof _.partialRight;
+ export = partialRight;
+}
+
+
+declare module "lodash/partition" {
+ const partition: typeof _.partition;
+ export = partition;
+}
+
+
+declare module "lodash/pick" {
+ const pick: typeof _.pick;
+ export = pick;
+}
+
+
+declare module "lodash/pickBy" {
+ const pickBy: typeof _.pickBy;
+ export = pickBy;
+}
+
+
+declare module "lodash/property" {
+ const property: typeof _.property;
+ export = property;
+}
+
+
+declare module "lodash/propertyOf" {
+ const propertyOf: typeof _.propertyOf;
+ export = propertyOf;
+}
+
+
+declare module "lodash/pull" {
+ const pull: typeof _.pull;
+ export = pull;
+}
+
+
+declare module "lodash/pullAll" {
+ const pullAll: typeof _.pullAll;
+ export = pullAll;
+}
+
+
+declare module "lodash/pullAllBy" {
+ const pullAllBy: typeof _.pullAllBy;
+ export = pullAllBy;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/pullAllWith" {
+ const pullAllWith: typeof _.pullAllWith;
+ export = pullAllWith;
+ }
+ */
+
+declare module "lodash/pullAt" {
+ const pullAt: typeof _.pullAt;
+ export = pullAt;
+}
+
+
+declare module "lodash/range" {
+ const range: typeof _.range;
+ export = range;
+}
+
+
+declare module "lodash/rangeRight" {
+ const rangeRight: typeof _.rangeRight;
+ export = rangeRight;
+}
+
+
+declare module "lodash/rearg" {
+ const rearg: typeof _.rearg;
+ export = rearg;
+}
+
+
+declare module "lodash/reject" {
+ const reject: typeof _.reject;
+ export = reject;
+}
+
+
+declare module "lodash/remove" {
+ const remove: typeof _.remove;
+ export = remove;
+}
+
+
+declare module "lodash/rest" {
+ const rest: typeof _.rest;
+ export = rest;
+}
+
+
+declare module "lodash/reverse" {
+ const reverse: typeof _.reverse;
+ export = reverse;
+}
+
+
+declare module "lodash/sampleSize" {
+ const sampleSize: typeof _.sampleSize;
+ export = sampleSize;
+}
+
+
+declare module "lodash/set" {
+ const set: typeof _.set;
+ export = set;
+}
+
+
+declare module "lodash/setWith" {
+ const setWith: typeof _.setWith;
+ export = setWith;
+}
+
+
+declare module "lodash/shuffle" {
+ const shuffle: typeof _.shuffle;
+ export = shuffle;
+}
+
+
+declare module "lodash/slice" {
+ const slice: typeof _.slice;
+ export = slice;
+}
+
+
+declare module "lodash/sortBy" {
+ const sortBy: typeof _.sortBy;
+ export = sortBy;
+}
+
+
+declare module "lodash/sortedUniq" {
+ const sortedUniq: typeof _.sortedUniq;
+ export = sortedUniq;
+}
+
+
+declare module "lodash/sortedUniqBy" {
+ const sortedUniqBy: typeof _.sortedUniqBy;
+ export = sortedUniqBy;
+}
+
+
+declare module "lodash/split" {
+ const split: typeof _.split;
+ export = split;
+}
+
+
+declare module "lodash/spread" {
+ const spread: typeof _.spread;
+ export = spread;
+}
+
+
+declare module "lodash/tail" {
+ const tail: typeof _.tail;
+ export = tail;
+}
+
+
+declare module "lodash/take" {
+ const take: typeof _.take;
+ export = take;
+}
+
+
+declare module "lodash/takeRight" {
+ const takeRight: typeof _.takeRight;
+ export = takeRight;
+}
+
+
+declare module "lodash/takeRightWhile" {
+ const takeRightWhile: typeof _.takeRightWhile;
+ export = takeRightWhile;
+}
+
+
+declare module "lodash/takeWhile" {
+ const takeWhile: typeof _.takeWhile;
+ export = takeWhile;
+}
+
+
+declare module "lodash/tap" {
+ const tap: typeof _.tap;
+ export = tap;
+}
+
+
+declare module "lodash/throttle" {
+ const throttle: typeof _.throttle;
+ export = throttle;
+}
+
+
+declare module "lodash/thru" {
+ const thru: typeof _.thru;
+ export = thru;
+}
+
+
+declare module "lodash/toArray" {
+ const toArray: typeof _.toArray;
+ export = toArray;
+}
+
+
+declare module "lodash/toPairs" {
+ const toPairs: typeof _.toPairs;
+ export = toPairs;
+}
+
+
+declare module "lodash/toPairsIn" {
+ const toPairsIn: typeof _.toPairsIn;
+ export = toPairsIn;
+}
+
+
+declare module "lodash/toPath" {
+ const toPath: typeof _.toPath;
+ export = toPath;
+}
+
+
+declare module "lodash/toPlainObject" {
+ const toPlainObject: typeof _.toPlainObject;
+ export = toPlainObject;
+}
+
+
+declare module "lodash/transform" {
+ const transform: typeof _.transform;
+ export = transform;
+}
+
+
+declare module "lodash/unary" {
+ const unary: typeof _.unary;
+ export = unary;
+}
+
+
+declare module "lodash/union" {
+ const union: typeof _.union;
+ export = union;
+}
+
+
+declare module "lodash/unionBy" {
+ const unionBy: typeof _.unionBy;
+ export = unionBy;
+}
+
+
+declare module "lodash/unionWith" {
+ const unionWith: typeof _.unionWith;
+ export = unionWith;
+}
+
+
+declare module "lodash/uniq" {
+ const uniq: typeof _.uniq;
+ export = uniq;
+}
+
+
+declare module "lodash/uniqBy" {
+ const uniqBy: typeof _.uniqBy;
+ export = uniqBy;
+}
+
+
+declare module "lodash/uniqWith" {
+ const uniqWith: typeof _.uniqWith;
+ export = uniqWith;
+}
+
+
+declare module "lodash/unset" {
+ const unset: typeof _.unset;
+ export = unset;
+}
+
+
+declare module "lodash/unzip" {
+ const unzip: typeof _.unzip;
+ export = unzip;
+}
+
+
+declare module "lodash/unzipWith" {
+ const unzipWith: typeof _.unzipWith;
+ export = unzipWith;
+}
+
+
+declare module "lodash/update" {
+ const update: typeof _.update;
+ export = update;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/updateWith" {
+ const updateWith: typeof _.updateWith;
+ export = updateWith;
+ }
+ */
+
+declare module "lodash/values" {
+ const values: typeof _.values;
+ export = values;
+}
+
+
+declare module "lodash/valuesIn" {
+ const valuesIn: typeof _.valuesIn;
+ export = valuesIn;
+}
+
+
+declare module "lodash/without" {
+ const without: typeof _.without;
+ export = without;
+}
+
+
+declare module "lodash/words" {
+ const words: typeof _.words;
+ export = words;
+}
+
+
+declare module "lodash/wrap" {
+ const wrap: typeof _.wrap;
+ export = wrap;
+}
+
+
+declare module "lodash/xor" {
+ const xor: typeof _.xor;
+ export = xor;
+}
+
+
+declare module "lodash/xorBy" {
+ const xorBy: typeof _.xorBy;
+ export = xorBy;
+}
+
+
+declare module "lodash/xorWith" {
+ const xorWith: typeof _.xorWith;
+ export = xorWith;
+}
+
+
+declare module "lodash/zip" {
+ const zip: typeof _.zip;
+ export = zip;
+}
+
+
+declare module "lodash/zipObject" {
+ const zipObject: typeof _.zipObject;
+ export = zipObject;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/zipObjectDeep" {
+ const zipObjectDeep: typeof _.zipObjectDeep;
+ export = zipObjectDeep;
+ }
+ */
+
+
+declare module "lodash/zipWith" {
+ const zipWith: typeof _.zipWith;
+ export = zipWith;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/entries" {
+ const entries: typeof _.entries;
+ export = entries;
+ }
+ */
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/entriesIn" {
+ const entriesIn: typeof _.entriesIn;
+ export = entriesIn;
+ }
+ */
+
+
+declare module "lodash/extend" {
+ const extend: typeof _.extend;
+ export = extend;
+}
+
+
+declare module "lodash/extendWith" {
+ const extendWith: typeof _.extendWith;
+ export = extendWith;
+}
+
+
+declare module "lodash/add" {
+ const add: typeof _.add;
+ export = add;
+}
+
+
+declare module "lodash/attempt" {
+ const attempt: typeof _.attempt;
+ export = attempt;
+}
+
+
+declare module "lodash/camelCase" {
+ const camelCase: typeof _.camelCase;
+ export = camelCase;
+}
+
+
+declare module "lodash/capitalize" {
+ const capitalize: typeof _.capitalize;
+ export = capitalize;
+}
+
+
+declare module "lodash/ceil" {
+ const ceil: typeof _.ceil;
+ export = ceil;
+}
+
+
+declare module "lodash/clamp" {
+ const clamp: typeof _.clamp;
+ export = clamp;
+}
+
+
+declare module "lodash/clone" {
+ const clone: typeof _.clone;
+ export = clone;
+}
+
+
+declare module "lodash/cloneDeep" {
+ const cloneDeep: typeof _.cloneDeep;
+ export = cloneDeep;
+}
+
+
+declare module "lodash/cloneDeepWith" {
+ const cloneDeepWith: typeof _.cloneDeepWith;
+ export = cloneDeepWith;
+}
+
+
+declare module "lodash/cloneWith" {
+ const cloneWith: typeof _.cloneWith;
+ export = cloneWith;
+}
+
+
+declare module "lodash/deburr" {
+ const deburr: typeof _.deburr;
+ export = deburr;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/divide" {
+ const divide: typeof _.divide;
+ export = divide;
+ }
+ */
+
+declare module "lodash/endsWith" {
+ const endsWith: typeof _.endsWith;
+ export = endsWith;
+}
+
+
+declare module "lodash/eq" {
+ const eq: typeof _.eq;
+ export = eq;
+}
+
+
+declare module "lodash/escape" {
+ const escape: typeof _.escape;
+ export = escape;
+}
+
+
+declare module "lodash/escapeRegExp" {
+ const escapeRegExp: typeof _.escapeRegExp;
+ export = escapeRegExp;
+}
+
+
+declare module "lodash/every" {
+ const every: typeof _.every;
+ export = every;
+}
+
+
+declare module "lodash/find" {
+ const find: typeof _.find;
+ export = find;
+}
+
+
+declare module "lodash/findIndex" {
+ const findIndex: typeof _.findIndex;
+ export = findIndex;
+}
+
+
+declare module "lodash/findKey" {
+ const findKey: typeof _.findKey;
+ export = findKey;
+}
+
+
+declare module "lodash/findLast" {
+ const findLast: typeof _.findLast;
+ export = findLast;
+}
+
+
+declare module "lodash/findLastIndex" {
+ const findLastIndex: typeof _.findLastIndex;
+ export = findLastIndex;
+}
+
+
+declare module "lodash/findLastKey" {
+ const findLastKey: typeof _.findLastKey;
+ export = findLastKey;
+}
+
+
+declare module "lodash/floor" {
+ const floor: typeof _.floor;
+ export = floor;
+}
+
+
+declare module "lodash/forEach" {
+ const forEach: typeof _.forEach;
+ export = forEach;
+}
+
+
+declare module "lodash/forEachRight" {
+ const forEachRight: typeof _.forEachRight;
+ export = forEachRight;
+}
+
+
+declare module "lodash/forIn" {
+ const forIn: typeof _.forIn;
+ export = forIn;
+}
+
+
+declare module "lodash/forInRight" {
+ const forInRight: typeof _.forInRight;
+ export = forInRight;
+}
+
+
+declare module "lodash/forOwn" {
+ const forOwn: typeof _.forOwn;
+ export = forOwn;
+}
+
+
+declare module "lodash/forOwnRight" {
+ const forOwnRight: typeof _.forOwnRight;
+ export = forOwnRight;
+}
+
+
+declare module "lodash/get" {
+ const get: typeof _.get;
+ export = get;
+}
+
+
+declare module "lodash/gt" {
+ const gt: typeof _.gt;
+ export = gt;
+}
+
+
+declare module "lodash/gte" {
+ const gte: typeof _.gte;
+ export = gte;
+}
+
+
+declare module "lodash/has" {
+ const has: typeof _.has;
+ export = has;
+}
+
+
+declare module "lodash/hasIn" {
+ const hasIn: typeof _.hasIn;
+ export = hasIn;
+}
+
+
+declare module "lodash/head" {
+ const head: typeof _.head;
+ export = head;
+}
+
+
+declare module "lodash/identity" {
+ const identity: typeof _.identity;
+ export = identity;
+}
+
+
+declare module "lodash/includes" {
+ const includes: typeof _.includes;
+ export = includes;
+}
+
+
+declare module "lodash/indexOf" {
+ const indexOf: typeof _.indexOf;
+ export = indexOf;
+}
+
+
+declare module "lodash/inRange" {
+ const inRange: typeof _.inRange;
+ export = inRange;
+}
+
+
+declare module "lodash/invoke" {
+ const invoke: typeof _.invoke;
+ export = invoke;
+}
+
+
+declare module "lodash/isArguments" {
+ const isArguments: typeof _.isArguments;
+ export = isArguments;
+}
+
+
+declare module "lodash/isArray" {
+ const isArray: typeof _.isArray;
+ export = isArray;
+}
+
+
+declare module "lodash/isArrayBuffer" {
+ const isArrayBuffer: typeof _.isArrayBuffer;
+ export = isArrayBuffer;
+}
+
+
+declare module "lodash/isArrayLike" {
+ const isArrayLike: typeof _.isArrayLike;
+ export = isArrayLike;
+}
+
+
+declare module "lodash/isArrayLikeObject" {
+ const isArrayLikeObject: typeof _.isArrayLikeObject;
+ export = isArrayLikeObject;
+}
+
+
+declare module "lodash/isBoolean" {
+ const isBoolean: typeof _.isBoolean;
+ export = isBoolean;
+}
+
+
+declare module "lodash/isBuffer" {
+ const isBuffer: typeof _.isBuffer;
+ export = isBuffer;
+}
+
+
+declare module "lodash/isDate" {
+ const isDate: typeof _.isDate;
+ export = isDate;
+}
+
+
+declare module "lodash/isElement" {
+ const isElement: typeof _.isElement;
+ export = isElement;
+}
+
+
+declare module "lodash/isEmpty" {
+ const isEmpty: typeof _.isEmpty;
+ export = isEmpty;
+}
+
+
+declare module "lodash/isEqual" {
+ const isEqual: typeof _.isEqual;
+ export = isEqual;
+}
+
+
+declare module "lodash/isEqualWith" {
+ const isEqualWith: typeof _.isEqualWith;
+ export = isEqualWith;
+}
+
+
+declare module "lodash/isError" {
+ const isError: typeof _.isError;
+ export = isError;
+}
+
+
+declare module "lodash/isFinite" {
+ const isFinite: typeof _.isFinite;
+ export = isFinite;
+}
+
+
+declare module "lodash/isFunction" {
+ const isFunction: typeof _.isFunction;
+ export = isFunction;
+}
+
+
+declare module "lodash/isInteger" {
+ const isInteger: typeof _.isInteger;
+ export = isInteger;
+}
+
+
+declare module "lodash/isLength" {
+ const isLength: typeof _.isLength;
+ export = isLength;
+}
+
+
+declare module "lodash/isMap" {
+ const isMap: typeof _.isMap;
+ export = isMap;
+}
+
+
+declare module "lodash/isMatch" {
+ const isMatch: typeof _.isMatch;
+ export = isMatch;
+}
+
+
+declare module "lodash/isMatchWith" {
+ const isMatchWith: typeof _.isMatchWith;
+ export = isMatchWith;
+}
+
+
+declare module "lodash/isNaN" {
+ const isNaN: typeof _.isNaN;
+ export = isNaN;
+}
+
+
+declare module "lodash/isNative" {
+ const isNative: typeof _.isNative;
+ export = isNative;
+}
+
+
+declare module "lodash/isNil" {
+ const isNil: typeof _.isNil;
+ export = isNil;
+}
+
+
+declare module "lodash/isNull" {
+ const isNull: typeof _.isNull;
+ export = isNull;
+}
+
+
+declare module "lodash/isNumber" {
+ const isNumber: typeof _.isNumber;
+ export = isNumber;
+}
+
+
+declare module "lodash/isObject" {
+ const isObject: typeof _.isObject;
+ export = isObject;
+}
+
+
+declare module "lodash/isObjectLike" {
+ const isObjectLike: typeof _.isObjectLike;
+ export = isObjectLike;
+}
+
+
+declare module "lodash/isPlainObject" {
+ const isPlainObject: typeof _.isPlainObject;
+ export = isPlainObject;
+}
+
+
+declare module "lodash/isRegExp" {
+ const isRegExp: typeof _.isRegExp;
+ export = isRegExp;
+}
+
+
+declare module "lodash/isSafeInteger" {
+ const isSafeInteger: typeof _.isSafeInteger;
+ export = isSafeInteger;
+}
+
+
+declare module "lodash/isSet" {
+ const isSet: typeof _.isSet;
+ export = isSet;
+}
+
+
+declare module "lodash/isString" {
+ const isString: typeof _.isString;
+ export = isString;
+}
+
+
+declare module "lodash/isSymbol" {
+ const isSymbol: typeof _.isSymbol;
+ export = isSymbol;
+}
+
+
+declare module "lodash/isTypedArray" {
+ const isTypedArray: typeof _.isTypedArray;
+ export = isTypedArray;
+}
+
+
+declare module "lodash/isUndefined" {
+ const isUndefined: typeof _.isUndefined;
+ export = isUndefined;
+}
+
+
+declare module "lodash/isWeakMap" {
+ const isWeakMap: typeof _.isWeakMap;
+ export = isWeakMap;
+}
+
+
+declare module "lodash/isWeakSet" {
+ const isWeakSet: typeof _.isWeakSet;
+ export = isWeakSet;
+}
+
+
+declare module "lodash/join" {
+ const join: typeof _.join;
+ export = join;
+}
+
+
+declare module "lodash/kebabCase" {
+ const kebabCase: typeof _.kebabCase;
+ export = kebabCase;
+}
+
+
+declare module "lodash/last" {
+ const last: typeof _.last;
+ export = last;
+}
+
+
+declare module "lodash/lastIndexOf" {
+ const lastIndexOf: typeof _.lastIndexOf;
+ export = lastIndexOf;
+}
+
+
+declare module "lodash/lowerCase" {
+ const lowerCase: typeof _.lowerCase;
+ export = lowerCase;
+}
+
+
+declare module "lodash/lowerFirst" {
+ const lowerFirst: typeof _.lowerFirst;
+ export = lowerFirst;
+}
+
+
+declare module "lodash/lt" {
+ const lt: typeof _.lt;
+ export = lt;
+}
+
+
+declare module "lodash/lte" {
+ const lte: typeof _.lte;
+ export = lte;
+}
+
+
+declare module "lodash/max" {
+ const max: typeof _.max;
+ export = max;
+}
+
+
+declare module "lodash/maxBy" {
+ const maxBy: typeof _.maxBy;
+ export = maxBy;
+}
+
+
+declare module "lodash/mean" {
+ const mean: typeof _.mean;
+ export = mean;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/meanBy" {
+ const meanBy: typeof _.meanBy;
+ export = meanBy;
+ }
+ */
+
+declare module "lodash/min" {
+ const min: typeof _.min;
+ export = min;
+}
+
+
+declare module "lodash/minBy" {
+ const minBy: typeof _.minBy;
+ export = minBy;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/multiply" {
+ const multiply: typeof _.multiply;
+ export = multiply;
+ }
+ */
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash/nth" {
+ const nth: typeof _.nth;
+ export = nth;
+ }
+ */
+
+declare module "lodash/noConflict" {
+ const noConflict: typeof _.noConflict;
+ export = noConflict;
+}
+
+
+declare module "lodash/noop" {
+ const noop: typeof _.noop;
+ export = noop;
+}
+
+
+declare module "lodash/now" {
+ const now: typeof _.now;
+ export = now;
+}
+
+
+declare module "lodash/pad" {
+ const pad: typeof _.pad;
+ export = pad;
+}
+
+
+declare module "lodash/padEnd" {
+ const padEnd: typeof _.padEnd;
+ export = padEnd;
+}
+
+
+declare module "lodash/padStart" {
+ const padStart: typeof _.padStart;
+ export = padStart;
+}
+
+
+declare module "lodash/parseInt" {
+ const parseInt: typeof _.parseInt;
+ export = parseInt;
+}
+
+
+declare module "lodash/random" {
+ const random: typeof _.random;
+ export = random;
+}
+
+
+declare module "lodash/reduce" {
+ const reduce: typeof _.reduce;
+ export = reduce;
+}
+
+
+declare module "lodash/reduceRight" {
+ const reduceRight: typeof _.reduceRight;
+ export = reduceRight;
+}
+
+
+declare module "lodash/repeat" {
+ const repeat: typeof _.repeat;
+ export = repeat;
+}
+
+
+declare module "lodash/replace" {
+ const replace: typeof _.replace;
+ export = replace;
+}
+
+
+declare module "lodash/result" {
+ const result: typeof _.result;
+ export = result;
+}
+
+
+declare module "lodash/round" {
+ const round: typeof _.round;
+ export = round;
+}
+
+
+declare module "lodash/runInContext" {
+ const runInContext: typeof _.runInContext;
+ export = runInContext;
+}
+
+
+declare module "lodash/sample" {
+ const sample: typeof _.sample;
+ export = sample;
+}
+
+
+declare module "lodash/size" {
+ const size: typeof _.size;
+ export = size;
+}
+
+
+declare module "lodash/snakeCase" {
+ const snakeCase: typeof _.snakeCase;
+ export = snakeCase;
+}
+
+
+declare module "lodash/some" {
+ const some: typeof _.some;
+ export = some;
+}
+
+
+declare module "lodash/sortedIndex" {
+ const sortedIndex: typeof _.sortedIndex;
+ export = sortedIndex;
+}
+
+
+declare module "lodash/sortedIndexBy" {
+ const sortedIndexBy: typeof _.sortedIndexBy;
+ export = sortedIndexBy;
+}
+
+
+declare module "lodash/sortedIndexOf" {
+ const sortedIndexOf: typeof _.sortedIndexOf;
+ export = sortedIndexOf;
+}
+
+
+declare module "lodash/sortedLastIndex" {
+ const sortedLastIndex: typeof _.sortedLastIndex;
+ export = sortedLastIndex;
+}
+
+
+declare module "lodash/sortedLastIndexBy" {
+ const sortedLastIndexBy: typeof _.sortedLastIndexBy;
+ export = sortedLastIndexBy;
+}
+
+
+declare module "lodash/sortedLastIndexOf" {
+ const sortedLastIndexOf: typeof _.sortedLastIndexOf;
+ export = sortedLastIndexOf;
+}
+
+
+declare module "lodash/startCase" {
+ const startCase: typeof _.startCase;
+ export = startCase;
+}
+
+
+declare module "lodash/startsWith" {
+ const startsWith: typeof _.startsWith;
+ export = startsWith;
+}
+
+
+declare module "lodash/subtract" {
+ const subtract: typeof _.subtract;
+ export = subtract;
+}
+
+
+declare module "lodash/sum" {
+ const sum: typeof _.sum;
+ export = sum;
+}
+
+
+declare module "lodash/sumBy" {
+ const sumBy: typeof _.sumBy;
+ export = sumBy;
+}
+
+
+declare module "lodash/template" {
+ const template: typeof _.template;
+ export = template;
+}
+
+
+declare module "lodash/times" {
+ const times: typeof _.times;
+ export = times;
+}
+
+
+declare module "lodash/toInteger" {
+ const toInteger: typeof _.toInteger;
+ export = toInteger;
+}
+
+
+declare module "lodash/toLength" {
+ const toLength: typeof _.toLength;
+ export = toLength;
+}
+
+
+declare module "lodash/toLower" {
+ const toLower: typeof _.toLower;
+ export = toLower;
+}
+
+
+declare module "lodash/toNumber" {
+ const toNumber: typeof _.toNumber;
+ export = toNumber;
+}
+
+
+declare module "lodash/toSafeInteger" {
+ const toSafeInteger: typeof _.toSafeInteger;
+ export = toSafeInteger;
+}
+
+
+declare module "lodash/toString" {
+ const toString: typeof _.toString;
+ export = toString;
+}
+
+
+declare module "lodash/toUpper" {
+ const toUpper: typeof _.toUpper;
+ export = toUpper;
+}
+
+
+declare module "lodash/trim" {
+ const trim: typeof _.trim;
+ export = trim;
+}
+
+
+declare module "lodash/trimEnd" {
+ const trimEnd: typeof _.trimEnd;
+ export = trimEnd;
+}
+
+
+declare module "lodash/trimStart" {
+ const trimStart: typeof _.trimStart;
+ export = trimStart;
+}
+
+
+declare module "lodash/truncate" {
+ const truncate: typeof _.truncate;
+ export = truncate;
+}
+
+
+declare module "lodash/unescape" {
+ const unescape: typeof _.unescape;
+ export = unescape;
+}
+
+
+declare module "lodash/uniqueId" {
+ const uniqueId: typeof _.uniqueId;
+ export = uniqueId;
+}
+
+
+declare module "lodash/upperCase" {
+ const upperCase: typeof _.upperCase;
+ export = upperCase;
+}
+
+
+declare module "lodash/upperFirst" {
+ const upperFirst: typeof _.upperFirst;
+ export = upperFirst;
+}
+
+
+declare module "lodash/each" {
+ const each: typeof _.each;
+ export = each;
+}
+
+
+declare module "lodash/eachRight" {
+ const eachRight: typeof _.eachRight;
+ export = eachRight;
+}
+
+
+declare module "lodash/first" {
+ const first: typeof _.first;
+ export = first;
+}
+
+declare module "lodash/fp" {
+ export = _;
+}
+
+declare module "lodash" {
+ export = _;
+}
+
+/*************************************************
+ * *
+ * The lodash method _.XXX exported as a module. *
+ * *
+ *************************************************/
+
+
+declare module "lodash.after" {
+ const after: typeof _.after;
+ export = after;
+}
+
+
+declare module "lodash.ary" {
+ const ary: typeof _.ary;
+ export = ary;
+}
+
+
+declare module "lodash.assign" {
+ const assign: typeof _.assign;
+ export = assign;
+}
+
+
+declare module "lodash.assignIn" {
+ const assignIn: typeof _.assignIn;
+ export = assignIn;
+}
+
+
+declare module "lodash.assignInWith" {
+ const assignInWith: typeof _.assignInWith;
+ export = assignInWith;
+}
+
+
+declare module "lodash.assignWith" {
+ const assignWith: typeof _.assignWith;
+ export = assignWith;
+}
+
+
+declare module "lodash.at" {
+ const at: typeof _.at;
+ export = at;
+}
+
+
+declare module "lodash.before" {
+ const before: typeof _.before;
+ export = before;
+}
+
+
+declare module "lodash.bind" {
+ const bind: typeof _.bind;
+ export = bind;
+}
+
+
+declare module "lodash.bindAll" {
+ const bindAll: typeof _.bindAll;
+ export = bindAll;
+}
+
+
+declare module "lodash.bindKey" {
+ const bindKey: typeof _.bindKey;
+ export = bindKey;
+}
+
+
+declare module "lodash.castArray" {
+ const castArray: typeof _.castArray;
+ export = castArray;
+}
+
+
+declare module "lodash.chain" {
+ const chain: typeof _.chain;
+ export = chain;
+}
+
+
+declare module "lodash.chunk" {
+ const chunk: typeof _.chunk;
+ export = chunk;
+}
+
+
+declare module "lodash.compact" {
+ const compact: typeof _.compact;
+ export = compact;
+}
+
+
+declare module "lodash.concat" {
+ const concat: typeof _.concat;
+ export = concat;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.cond" {
+ const cond: typeof _.cond;
+ export = cond;
+ }
+ */
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.conforms" {
+ const conforms: typeof _.conforms;
+ export = conforms;
+ }
+ */
+
+declare module "lodash.constant" {
+ const constant: typeof _.constant;
+ export = constant;
+}
+
+
+declare module "lodash.countBy" {
+ const countBy: typeof _.countBy;
+ export = countBy;
+}
+
+
+declare module "lodash.create" {
+ const create: typeof _.create;
+ export = create;
+}
+
+
+declare module "lodash.curry" {
+ const curry: typeof _.curry;
+ export = curry;
+}
+
+
+declare module "lodash.curryRight" {
+ const curryRight: typeof _.curryRight;
+ export = curryRight;
+}
+
+
+declare module "lodash.debounce" {
+ const debounce: typeof _.debounce;
+ export = debounce;
+}
+
+
+declare module "lodash.defaults" {
+ const defaults: typeof _.defaults;
+ export = defaults;
+}
+
+
+declare module "lodash.defaultsDeep" {
+ const defaultsDeep: typeof _.defaultsDeep;
+ export = defaultsDeep;
+}
+
+
+declare module "lodash.defer" {
+ const defer: typeof _.defer;
+ export = defer;
+}
+
+
+declare module "lodash.delay" {
+ const delay: typeof _.delay;
+ export = delay;
+}
+
+
+declare module "lodash.difference" {
+ const difference: typeof _.difference;
+ export = difference;
+}
+
+
+declare module "lodash.differenceBy" {
+ const differenceBy: typeof _.differenceBy;
+ export = differenceBy;
+}
+
+
+declare module "lodash.differenceWith" {
+ const differenceWith: typeof _.differenceWith;
+ export = differenceWith;
+}
+
+
+declare module "lodash.drop" {
+ const drop: typeof _.drop;
+ export = drop;
+}
+
+
+declare module "lodash.dropRight" {
+ const dropRight: typeof _.dropRight;
+ export = dropRight;
+}
+
+
+declare module "lodash.dropRightWhile" {
+ const dropRightWhile: typeof _.dropRightWhile;
+ export = dropRightWhile;
+}
+
+
+declare module "lodash.dropWhile" {
+ const dropWhile: typeof _.dropWhile;
+ export = dropWhile;
+}
+
+
+declare module "lodash.fill" {
+ const fill: typeof _.fill;
+ export = fill;
+}
+
+
+declare module "lodash.filter" {
+ const filter: typeof _.filter;
+ export = filter;
+}
+
+
+declare module "lodash.flatMap" {
+ const flatMap: typeof _.flatMap;
+ export = flatMap;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.flatMapDeep" {
+ const flatMapDeep: typeof _.flatMapDeep;
+ export = flatMapDeep;
+ }
+ */
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.flatMapDepth" {
+ const flatMapDepth: typeof _.flatMapDepth;
+ export = flatMapDepth;
+ }
+ */
+
+declare module "lodash.flatten" {
+ const flatten: typeof _.flatten;
+ export = flatten;
+}
+
+
+declare module "lodash.flattenDeep" {
+ const flattenDeep: typeof _.flattenDeep;
+ export = flattenDeep;
+}
+
+declare module "lodash.flattenDepth" {
+ const flattenDepth: typeof _.flattenDepth;
+ export = flattenDepth;
+}
+
+declare module "lodash.flip" {
+ const flip: typeof _.flip;
+ export = flip;
+}
+
+
+declare module "lodash.flow" {
+ const flow: typeof _.flow;
+ export = flow;
+}
+
+
+declare module "lodash.flowRight" {
+ const flowRight: typeof _.flowRight;
+ export = flowRight;
+}
+
+
+declare module "lodash.fromPairs" {
+ const fromPairs: typeof _.fromPairs;
+ export = fromPairs;
+}
+
+
+declare module "lodash.functions" {
+ const functions: typeof _.functions;
+ export = functions;
+}
+
+
+declare module "lodash.functionsIn" {
+ const functionsIn: typeof _.functionsIn;
+ export = functionsIn;
+}
+
+
+declare module "lodash.groupBy" {
+ const groupBy: typeof _.groupBy;
+ export = groupBy;
+}
+
+
+declare module "lodash.initial" {
+ const initial: typeof _.initial;
+ export = initial;
+}
+
+
+declare module "lodash.intersection" {
+ const intersection: typeof _.intersection;
+ export = intersection;
+}
+
+
+declare module "lodash.intersectionBy" {
+ const intersectionBy: typeof _.intersectionBy;
+ export = intersectionBy;
+}
+
+
+declare module "lodash.intersectionWith" {
+ const intersectionWith: typeof _.intersectionWith;
+ export = intersectionWith;
+}
+
+
+declare module "lodash.invert" {
+ const invert: typeof _.invert;
+ export = invert;
+}
+
+
+declare module "lodash.invertBy" {
+ const invertBy: typeof _.invertBy;
+ export = invertBy;
+}
+
+
+declare module "lodash.invokeMap" {
+ const invokeMap: typeof _.invokeMap;
+ export = invokeMap;
+}
+
+
+declare module "lodash.iteratee" {
+ const iteratee: typeof _.iteratee;
+ export = iteratee;
+}
+
+
+declare module "lodash.keyBy" {
+ const keyBy: typeof _.keyBy;
+ export = keyBy;
+}
+
+
+declare module "lodash.keys" {
+ const keys: typeof _.keys;
+ export = keys;
+}
+
+
+declare module "lodash.keysIn" {
+ const keysIn: typeof _.keysIn;
+ export = keysIn;
+}
+
+
+declare module "lodash.map" {
+ const map: typeof _.map;
+ export = map;
+}
+
+
+declare module "lodash.mapKeys" {
+ const mapKeys: typeof _.mapKeys;
+ export = mapKeys;
+}
+
+
+declare module "lodash.mapValues" {
+ const mapValues: typeof _.mapValues;
+ export = mapValues;
+}
+
+
+declare module "lodash.matches" {
+ const matches: typeof _.matches;
+ export = matches;
+}
+
+
+declare module "lodash.matchesProperty" {
+ const matchesProperty: typeof _.matchesProperty;
+ export = matchesProperty;
+}
+
+
+declare module "lodash.memoize" {
+ const memoize: typeof _.memoize;
+ export = memoize;
+}
+
+
+declare module "lodash.merge" {
+ const merge: typeof _.merge;
+ export = merge;
+}
+
+
+declare module "lodash.mergeWith" {
+ const mergeWith: typeof _.mergeWith;
+ export = mergeWith;
+}
+
+
+declare module "lodash.method" {
+ const method: typeof _.method;
+ export = method;
+}
+
+
+declare module "lodash.methodOf" {
+ const methodOf: typeof _.methodOf;
+ export = methodOf;
+}
+
+
+declare module "lodash.mixin" {
+ const mixin: typeof _.mixin;
+ export = mixin;
+}
+
+
+declare module "lodash.negate" {
+ const negate: typeof _.negate;
+ export = negate;
+}
+
+
+declare module "lodash.nthArg" {
+ const nthArg: typeof _.nthArg;
+ export = nthArg;
+}
+
+
+declare module "lodash.omit" {
+ const omit: typeof _.omit;
+ export = omit;
+}
+
+
+declare module "lodash.omitBy" {
+ const omitBy: typeof _.omitBy;
+ export = omitBy;
+}
+
+
+declare module "lodash.once" {
+ const once: typeof _.once;
+ export = once;
+}
+
+
+declare module "lodash.orderBy" {
+ const orderBy: typeof _.orderBy;
+ export = orderBy;
+}
+
+
+declare module "lodash.over" {
+ const over: typeof _.over;
+ export = over;
+}
+
+
+declare module "lodash.overArgs" {
+ const overArgs: typeof _.overArgs;
+ export = overArgs;
+}
+
+
+declare module "lodash.overEvery" {
+ const overEvery: typeof _.overEvery;
+ export = overEvery;
+}
+
+
+declare module "lodash.overSome" {
+ const overSome: typeof _.overSome;
+ export = overSome;
+}
+
+
+declare module "lodash.partial" {
+ const partial: typeof _.partial;
+ export = partial;
+}
+
+
+declare module "lodash.partialRight" {
+ const partialRight: typeof _.partialRight;
+ export = partialRight;
+}
+
+
+declare module "lodash.partition" {
+ const partition: typeof _.partition;
+ export = partition;
+}
+
+
+declare module "lodash.pick" {
+ const pick: typeof _.pick;
+ export = pick;
+}
+
+
+declare module "lodash.pickBy" {
+ const pickBy: typeof _.pickBy;
+ export = pickBy;
+}
+
+
+declare module "lodash.property" {
+ const property: typeof _.property;
+ export = property;
+}
+
+
+declare module "lodash.propertyOf" {
+ const propertyOf: typeof _.propertyOf;
+ export = propertyOf;
+}
+
+
+declare module "lodash.pull" {
+ const pull: typeof _.pull;
+ export = pull;
+}
+
+
+declare module "lodash.pullAll" {
+ const pullAll: typeof _.pullAll;
+ export = pullAll;
+}
+
+
+declare module "lodash.pullAllBy" {
+ const pullAllBy: typeof _.pullAllBy;
+ export = pullAllBy;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.pullAllWith" {
+ const pullAllWith: typeof _.pullAllWith;
+ export = pullAllWith;
+ }
+ */
+
+declare module "lodash.pullAt" {
+ const pullAt: typeof _.pullAt;
+ export = pullAt;
+}
+
+
+declare module "lodash.range" {
+ const range: typeof _.range;
+ export = range;
+}
+
+
+declare module "lodash.rangeRight" {
+ const rangeRight: typeof _.rangeRight;
+ export = rangeRight;
+}
+
+
+declare module "lodash.rearg" {
+ const rearg: typeof _.rearg;
+ export = rearg;
+}
+
+
+declare module "lodash.reject" {
+ const reject: typeof _.reject;
+ export = reject;
+}
+
+
+declare module "lodash.remove" {
+ const remove: typeof _.remove;
+ export = remove;
+}
+
+
+declare module "lodash.rest" {
+ const rest: typeof _.rest;
+ export = rest;
+}
+
+
+declare module "lodash.reverse" {
+ const reverse: typeof _.reverse;
+ export = reverse;
+}
+
+
+declare module "lodash.sampleSize" {
+ const sampleSize: typeof _.sampleSize;
+ export = sampleSize;
+}
+
+
+declare module "lodash.set" {
+ const set: typeof _.set;
+ export = set;
+}
+
+
+declare module "lodash.setWith" {
+ const setWith: typeof _.setWith;
+ export = setWith;
+}
+
+
+declare module "lodash.shuffle" {
+ const shuffle: typeof _.shuffle;
+ export = shuffle;
+}
+
+
+declare module "lodash.slice" {
+ const slice: typeof _.slice;
+ export = slice;
+}
+
+
+declare module "lodash.sortBy" {
+ const sortBy: typeof _.sortBy;
+ export = sortBy;
+}
+
+
+declare module "lodash.sortedUniq" {
+ const sortedUniq: typeof _.sortedUniq;
+ export = sortedUniq;
+}
+
+
+declare module "lodash.sortedUniqBy" {
+ const sortedUniqBy: typeof _.sortedUniqBy;
+ export = sortedUniqBy;
+}
+
+
+declare module "lodash.split" {
+ const split: typeof _.split;
+ export = split;
+}
+
+
+declare module "lodash.spread" {
+ const spread: typeof _.spread;
+ export = spread;
+}
+
+
+declare module "lodash.tail" {
+ const tail: typeof _.tail;
+ export = tail;
+}
+
+
+declare module "lodash.take" {
+ const take: typeof _.take;
+ export = take;
+}
+
+
+declare module "lodash.takeRight" {
+ const takeRight: typeof _.takeRight;
+ export = takeRight;
+}
+
+
+declare module "lodash.takeRightWhile" {
+ const takeRightWhile: typeof _.takeRightWhile;
+ export = takeRightWhile;
+}
+
+
+declare module "lodash.takeWhile" {
+ const takeWhile: typeof _.takeWhile;
+ export = takeWhile;
+}
+
+
+declare module "lodash.tap" {
+ const tap: typeof _.tap;
+ export = tap;
+}
+
+
+declare module "lodash.throttle" {
+ const throttle: typeof _.throttle;
+ export = throttle;
+}
+
+
+declare module "lodash.thru" {
+ const thru: typeof _.thru;
+ export = thru;
+}
+
+
+declare module "lodash.toArray" {
+ const toArray: typeof _.toArray;
+ export = toArray;
+}
+
+
+declare module "lodash.toPairs" {
+ const toPairs: typeof _.toPairs;
+ export = toPairs;
+}
+
+
+declare module "lodash.toPairsIn" {
+ const toPairsIn: typeof _.toPairsIn;
+ export = toPairsIn;
+}
+
+
+declare module "lodash.toPath" {
+ const toPath: typeof _.toPath;
+ export = toPath;
+}
+
+
+declare module "lodash.toPlainObject" {
+ const toPlainObject: typeof _.toPlainObject;
+ export = toPlainObject;
+}
+
+
+declare module "lodash.transform" {
+ const transform: typeof _.transform;
+ export = transform;
+}
+
+
+declare module "lodash.unary" {
+ const unary: typeof _.unary;
+ export = unary;
+}
+
+
+declare module "lodash.union" {
+ const union: typeof _.union;
+ export = union;
+}
+
+
+declare module "lodash.unionBy" {
+ const unionBy: typeof _.unionBy;
+ export = unionBy;
+}
+
+
+declare module "lodash.unionWith" {
+ const unionWith: typeof _.unionWith;
+ export = unionWith;
+}
+
+
+declare module "lodash.uniq" {
+ const uniq: typeof _.uniq;
+ export = uniq;
+}
+
+
+declare module "lodash.uniqBy" {
+ const uniqBy: typeof _.uniqBy;
+ export = uniqBy;
+}
+
+
+declare module "lodash.uniqWith" {
+ const uniqWith: typeof _.uniqWith;
+ export = uniqWith;
+}
+
+
+declare module "lodash.unset" {
+ const unset: typeof _.unset;
+ export = unset;
+}
+
+
+declare module "lodash.unzip" {
+ const unzip: typeof _.unzip;
+ export = unzip;
+}
+
+
+declare module "lodash.unzipWith" {
+ const unzipWith: typeof _.unzipWith;
+ export = unzipWith;
+}
+
+
+declare module "lodash.update" {
+ const update: typeof _.update;
+ export = update;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.updateWith" {
+ const updateWith: typeof _.updateWith;
+ export = updateWith;
+ }
+ */
+
+declare module "lodash.values" {
+ const values: typeof _.values;
+ export = values;
+}
+
+
+declare module "lodash.valuesIn" {
+ const valuesIn: typeof _.valuesIn;
+ export = valuesIn;
+}
+
+
+declare module "lodash.without" {
+ const without: typeof _.without;
+ export = without;
+}
+
+
+declare module "lodash.words" {
+ const words: typeof _.words;
+ export = words;
+}
+
+
+declare module "lodash.wrap" {
+ const wrap: typeof _.wrap;
+ export = wrap;
+}
+
+
+declare module "lodash.xor" {
+ const xor: typeof _.xor;
+ export = xor;
+}
+
+
+declare module "lodash.xorBy" {
+ const xorBy: typeof _.xorBy;
+ export = xorBy;
+}
+
+
+declare module "lodash.xorWith" {
+ const xorWith: typeof _.xorWith;
+ export = xorWith;
+}
+
+
+declare module "lodash.zip" {
+ const zip: typeof _.zip;
+ export = zip;
+}
+
+
+declare module "lodash.zipObject" {
+ const zipObject: typeof _.zipObject;
+ export = zipObject;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.zipObjectDeep" {
+ const zipObjectDeep: typeof _.zipObjectDeep;
+ export = zipObjectDeep;
+ }
+ */
+
+
+declare module "lodash.zipWith" {
+ const zipWith: typeof _.zipWith;
+ export = zipWith;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.entries" {
+ const entries: typeof _.entries;
+ export = entries;
+ }
+ */
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.entriesIn" {
+ const entriesIn: typeof _.entriesIn;
+ export = entriesIn;
+ }
+ */
+
+
+declare module "lodash.extend" {
+ const extend: typeof _.extend;
+ export = extend;
+}
+
+
+declare module "lodash.extendWith" {
+ const extendWith: typeof _.extendWith;
+ export = extendWith;
+}
+
+
+declare module "lodash.add" {
+ const add: typeof _.add;
+ export = add;
+}
+
+
+declare module "lodash.attempt" {
+ const attempt: typeof _.attempt;
+ export = attempt;
+}
+
+
+declare module "lodash.camelCase" {
+ const camelCase: typeof _.camelCase;
+ export = camelCase;
+}
+
+
+declare module "lodash.capitalize" {
+ const capitalize: typeof _.capitalize;
+ export = capitalize;
+}
+
+
+declare module "lodash.ceil" {
+ const ceil: typeof _.ceil;
+ export = ceil;
+}
+
+
+declare module "lodash.clamp" {
+ const clamp: typeof _.clamp;
+ export = clamp;
+}
+
+
+declare module "lodash.clone" {
+ const clone: typeof _.clone;
+ export = clone;
+}
+
+
+declare module "lodash.cloneDeep" {
+ const cloneDeep: typeof _.cloneDeep;
+ export = cloneDeep;
+}
+
+
+declare module "lodash.cloneDeepWith" {
+ const cloneDeepWith: typeof _.cloneDeepWith;
+ export = cloneDeepWith;
+}
+
+
+declare module "lodash.cloneWith" {
+ const cloneWith: typeof _.cloneWith;
+ export = cloneWith;
+}
+
+
+declare module "lodash.deburr" {
+ const deburr: typeof _.deburr;
+ export = deburr;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.divide" {
+ const divide: typeof _.divide;
+ export = divide;
+ }
+ */
+
+declare module "lodash.endsWith" {
+ const endsWith: typeof _.endsWith;
+ export = endsWith;
+}
+
+
+declare module "lodash.eq" {
+ const eq: typeof _.eq;
+ export = eq;
+}
+
+
+declare module "lodash.escape" {
+ const escape: typeof _.escape;
+ export = escape;
+}
+
+
+declare module "lodash.escapeRegExp" {
+ const escapeRegExp: typeof _.escapeRegExp;
+ export = escapeRegExp;
+}
+
+
+declare module "lodash.every" {
+ const every: typeof _.every;
+ export = every;
+}
+
+
+declare module "lodash.find" {
+ const find: typeof _.find;
+ export = find;
+}
+
+
+declare module "lodash.findIndex" {
+ const findIndex: typeof _.findIndex;
+ export = findIndex;
+}
+
+
+declare module "lodash.findKey" {
+ const findKey: typeof _.findKey;
+ export = findKey;
+}
+
+
+declare module "lodash.findLast" {
+ const findLast: typeof _.findLast;
+ export = findLast;
+}
+
+
+declare module "lodash.findLastIndex" {
+ const findLastIndex: typeof _.findLastIndex;
+ export = findLastIndex;
+}
+
+
+declare module "lodash.findLastKey" {
+ const findLastKey: typeof _.findLastKey;
+ export = findLastKey;
+}
+
+
+declare module "lodash.floor" {
+ const floor: typeof _.floor;
+ export = floor;
+}
+
+
+declare module "lodash.forEach" {
+ const forEach: typeof _.forEach;
+ export = forEach;
+}
+
+
+declare module "lodash.forEachRight" {
+ const forEachRight: typeof _.forEachRight;
+ export = forEachRight;
+}
+
+
+declare module "lodash.forIn" {
+ const forIn: typeof _.forIn;
+ export = forIn;
+}
+
+
+declare module "lodash.forInRight" {
+ const forInRight: typeof _.forInRight;
+ export = forInRight;
+}
+
+
+declare module "lodash.forOwn" {
+ const forOwn: typeof _.forOwn;
+ export = forOwn;
+}
+
+
+declare module "lodash.forOwnRight" {
+ const forOwnRight: typeof _.forOwnRight;
+ export = forOwnRight;
+}
+
+
+declare module "lodash.get" {
+ const get: typeof _.get;
+ export = get;
+}
+
+
+declare module "lodash.gt" {
+ const gt: typeof _.gt;
+ export = gt;
+}
+
+
+declare module "lodash.gte" {
+ const gte: typeof _.gte;
+ export = gte;
+}
+
+
+declare module "lodash.has" {
+ const has: typeof _.has;
+ export = has;
+}
+
+
+declare module "lodash.hasIn" {
+ const hasIn: typeof _.hasIn;
+ export = hasIn;
+}
+
+
+declare module "lodash.head" {
+ const head: typeof _.head;
+ export = head;
+}
+
+
+declare module "lodash.identity" {
+ const identity: typeof _.identity;
+ export = identity;
+}
+
+
+declare module "lodash.includes" {
+ const includes: typeof _.includes;
+ export = includes;
+}
+
+
+declare module "lodash.indexOf" {
+ const indexOf: typeof _.indexOf;
+ export = indexOf;
+}
+
+
+declare module "lodash.inRange" {
+ const inRange: typeof _.inRange;
+ export = inRange;
+}
+
+
+declare module "lodash.invoke" {
+ const invoke: typeof _.invoke;
+ export = invoke;
+}
+
+
+declare module "lodash.isArguments" {
+ const isArguments: typeof _.isArguments;
+ export = isArguments;
+}
+
+
+declare module "lodash.isArray" {
+ const isArray: typeof _.isArray;
+ export = isArray;
+}
+
+
+declare module "lodash.isArrayBuffer" {
+ const isArrayBuffer: typeof _.isArrayBuffer;
+ export = isArrayBuffer;
+}
+
+
+declare module "lodash.isArrayLike" {
+ const isArrayLike: typeof _.isArrayLike;
+ export = isArrayLike;
+}
+
+
+declare module "lodash.isArrayLikeObject" {
+ const isArrayLikeObject: typeof _.isArrayLikeObject;
+ export = isArrayLikeObject;
+}
+
+
+declare module "lodash.isBoolean" {
+ const isBoolean: typeof _.isBoolean;
+ export = isBoolean;
+}
+
+
+declare module "lodash.isBuffer" {
+ const isBuffer: typeof _.isBuffer;
+ export = isBuffer;
+}
+
+
+declare module "lodash.isDate" {
+ const isDate: typeof _.isDate;
+ export = isDate;
+}
+
+
+declare module "lodash.isElement" {
+ const isElement: typeof _.isElement;
+ export = isElement;
+}
+
+
+declare module "lodash.isEmpty" {
+ const isEmpty: typeof _.isEmpty;
+ export = isEmpty;
+}
+
+
+declare module "lodash.isEqual" {
+ const isEqual: typeof _.isEqual;
+ export = isEqual;
+}
+
+
+declare module "lodash.isEqualWith" {
+ const isEqualWith: typeof _.isEqualWith;
+ export = isEqualWith;
+}
+
+
+declare module "lodash.isError" {
+ const isError: typeof _.isError;
+ export = isError;
+}
+
+
+declare module "lodash.isFinite" {
+ const isFinite: typeof _.isFinite;
+ export = isFinite;
+}
+
+
+declare module "lodash.isFunction" {
+ const isFunction: typeof _.isFunction;
+ export = isFunction;
+}
+
+
+declare module "lodash.isInteger" {
+ const isInteger: typeof _.isInteger;
+ export = isInteger;
+}
+
+
+declare module "lodash.isLength" {
+ const isLength: typeof _.isLength;
+ export = isLength;
+}
+
+
+declare module "lodash.isMap" {
+ const isMap: typeof _.isMap;
+ export = isMap;
+}
+
+
+declare module "lodash.isMatch" {
+ const isMatch: typeof _.isMatch;
+ export = isMatch;
+}
+
+
+declare module "lodash.isMatchWith" {
+ const isMatchWith: typeof _.isMatchWith;
+ export = isMatchWith;
+}
+
+
+declare module "lodash.isNaN" {
+ const isNaN: typeof _.isNaN;
+ export = isNaN;
+}
+
+
+declare module "lodash.isNative" {
+ const isNative: typeof _.isNative;
+ export = isNative;
+}
+
+
+declare module "lodash.isNil" {
+ const isNil: typeof _.isNil;
+ export = isNil;
+}
+
+
+declare module "lodash.isNull" {
+ const isNull: typeof _.isNull;
+ export = isNull;
+}
+
+
+declare module "lodash.isNumber" {
+ const isNumber: typeof _.isNumber;
+ export = isNumber;
+}
+
+
+declare module "lodash.isObject" {
+ const isObject: typeof _.isObject;
+ export = isObject;
+}
+
+
+declare module "lodash.isObjectLike" {
+ const isObjectLike: typeof _.isObjectLike;
+ export = isObjectLike;
+}
+
+
+declare module "lodash.isPlainObject" {
+ const isPlainObject: typeof _.isPlainObject;
+ export = isPlainObject;
+}
+
+
+declare module "lodash.isRegExp" {
+ const isRegExp: typeof _.isRegExp;
+ export = isRegExp;
+}
+
+
+declare module "lodash.isSafeInteger" {
+ const isSafeInteger: typeof _.isSafeInteger;
+ export = isSafeInteger;
+}
+
+
+declare module "lodash.isSet" {
+ const isSet: typeof _.isSet;
+ export = isSet;
+}
+
+
+declare module "lodash.isString" {
+ const isString: typeof _.isString;
+ export = isString;
+}
+
+
+declare module "lodash.isSymbol" {
+ const isSymbol: typeof _.isSymbol;
+ export = isSymbol;
+}
+
+
+declare module "lodash.isTypedArray" {
+ const isTypedArray: typeof _.isTypedArray;
+ export = isTypedArray;
+}
+
+
+declare module "lodash.isUndefined" {
+ const isUndefined: typeof _.isUndefined;
+ export = isUndefined;
+}
+
+
+declare module "lodash.isWeakMap" {
+ const isWeakMap: typeof _.isWeakMap;
+ export = isWeakMap;
+}
+
+
+declare module "lodash.isWeakSet" {
+ const isWeakSet: typeof _.isWeakSet;
+ export = isWeakSet;
+}
+
+
+declare module "lodash.join" {
+ const join: typeof _.join;
+ export = join;
+}
+
+
+declare module "lodash.kebabCase" {
+ const kebabCase: typeof _.kebabCase;
+ export = kebabCase;
+}
+
+
+declare module "lodash.last" {
+ const last: typeof _.last;
+ export = last;
+}
+
+
+declare module "lodash.lastIndexOf" {
+ const lastIndexOf: typeof _.lastIndexOf;
+ export = lastIndexOf;
+}
+
+
+declare module "lodash.lowerCase" {
+ const lowerCase: typeof _.lowerCase;
+ export = lowerCase;
+}
+
+
+declare module "lodash.lowerFirst" {
+ const lowerFirst: typeof _.lowerFirst;
+ export = lowerFirst;
+}
+
+
+declare module "lodash.lt" {
+ const lt: typeof _.lt;
+ export = lt;
+}
+
+
+declare module "lodash.lte" {
+ const lte: typeof _.lte;
+ export = lte;
+}
+
+
+declare module "lodash.max" {
+ const max: typeof _.max;
+ export = max;
+}
+
+
+declare module "lodash.maxBy" {
+ const maxBy: typeof _.maxBy;
+ export = maxBy;
+}
+
+
+declare module "lodash.mean" {
+ const mean: typeof _.mean;
+ export = mean;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.meanBy" {
+ const meanBy: typeof _.meanBy;
+ export = meanBy;
+ }
+ */
+
+declare module "lodash.min" {
+ const min: typeof _.min;
+ export = min;
+}
+
+
+declare module "lodash.minBy" {
+ const minBy: typeof _.minBy;
+ export = minBy;
+}
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.multiply" {
+ const multiply: typeof _.multiply;
+ export = multiply;
+ }
+ */
+
+/**
+ * uncoment it if definition exists
+ */
+/*
+ declare module "lodash.nth" {
+ const nth: typeof _.nth;
+ export = nth;
+ }
+ */
+
+declare module "lodash.noConflict" {
+ const noConflict: typeof _.noConflict;
+ export = noConflict;
+}
+
+
+declare module "lodash.noop" {
+ const noop: typeof _.noop;
+ export = noop;
+}
+
+
+declare module "lodash.now" {
+ const now: typeof _.now;
+ export = now;
+}
+
+
+declare module "lodash.pad" {
+ const pad: typeof _.pad;
+ export = pad;
+}
+
+
+declare module "lodash.padEnd" {
+ const padEnd: typeof _.padEnd;
+ export = padEnd;
+}
+
+
+declare module "lodash.padStart" {
+ const padStart: typeof _.padStart;
+ export = padStart;
+}
+
+
+declare module "lodash.parseInt" {
+ const parseInt: typeof _.parseInt;
+ export = parseInt;
+}
+
+
+declare module "lodash.random" {
+ const random: typeof _.random;
+ export = random;
+}
+
+
+declare module "lodash.reduce" {
+ const reduce: typeof _.reduce;
+ export = reduce;
+}
+
+
+declare module "lodash.reduceRight" {
+ const reduceRight: typeof _.reduceRight;
+ export = reduceRight;
+}
+
+
+declare module "lodash.repeat" {
+ const repeat: typeof _.repeat;
+ export = repeat;
+}
+
+
+declare module "lodash.replace" {
+ const replace: typeof _.replace;
+ export = replace;
+}
+
+
+declare module "lodash.result" {
+ const result: typeof _.result;
+ export = result;
+}
+
+
+declare module "lodash.round" {
+ const round: typeof _.round;
+ export = round;
+}
+
+
+declare module "lodash.runInContext" {
+ const runInContext: typeof _.runInContext;
+ export = runInContext;
+}
+
+
+declare module "lodash.sample" {
+ const sample: typeof _.sample;
+ export = sample;
+}
+
+
+declare module "lodash.size" {
+ const size: typeof _.size;
+ export = size;
+}
+
+
+declare module "lodash.snakeCase" {
+ const snakeCase: typeof _.snakeCase;
+ export = snakeCase;
+}
+
+
+declare module "lodash.some" {
+ const some: typeof _.some;
+ export = some;
+}
+
+
+declare module "lodash.sortedIndex" {
+ const sortedIndex: typeof _.sortedIndex;
+ export = sortedIndex;
+}
+
+
+declare module "lodash.sortedIndexBy" {
+ const sortedIndexBy: typeof _.sortedIndexBy;
+ export = sortedIndexBy;
+}
+
+
+declare module "lodash.sortedIndexOf" {
+ const sortedIndexOf: typeof _.sortedIndexOf;
+ export = sortedIndexOf;
+}
+
+
+declare module "lodash.sortedLastIndex" {
+ const sortedLastIndex: typeof _.sortedLastIndex;
+ export = sortedLastIndex;
+}
+
+
+declare module "lodash.sortedLastIndexBy" {
+ const sortedLastIndexBy: typeof _.sortedLastIndexBy;
+ export = sortedLastIndexBy;
+}
+
+
+declare module "lodash.sortedLastIndexOf" {
+ const sortedLastIndexOf: typeof _.sortedLastIndexOf;
+ export = sortedLastIndexOf;
+}
+
+
+declare module "lodash.startCase" {
+ const startCase: typeof _.startCase;
+ export = startCase;
+}
+
+
+declare module "lodash.startsWith" {
+ const startsWith: typeof _.startsWith;
+ export = startsWith;
+}
+
+
+declare module "lodash.subtract" {
+ const subtract: typeof _.subtract;
+ export = subtract;
+}
+
+
+declare module "lodash.sum" {
+ const sum: typeof _.sum;
+ export = sum;
+}
+
+
+declare module "lodash.sumBy" {
+ const sumBy: typeof _.sumBy;
+ export = sumBy;
+}
+
+
+declare module "lodash.template" {
+ const template: typeof _.template;
+ export = template;
+}
+
+
+declare module "lodash.times" {
+ const times: typeof _.times;
+ export = times;
+}
+
+
+declare module "lodash.toInteger" {
+ const toInteger: typeof _.toInteger;
+ export = toInteger;
+}
+
+
+declare module "lodash.toLength" {
+ const toLength: typeof _.toLength;
+ export = toLength;
+}
+
+
+declare module "lodash.toLower" {
+ const toLower: typeof _.toLower;
+ export = toLower;
+}
+
+
+declare module "lodash.toNumber" {
+ const toNumber: typeof _.toNumber;
+ export = toNumber;
+}
+
+
+declare module "lodash.toSafeInteger" {
+ const toSafeInteger: typeof _.toSafeInteger;
+ export = toSafeInteger;
+}
+
+
+declare module "lodash.toString" {
+ const toString: typeof _.toString;
+ export = toString;
+}
+
+
+declare module "lodash.toUpper" {
+ const toUpper: typeof _.toUpper;
+ export = toUpper;
+}
+
+
+declare module "lodash.trim" {
+ const trim: typeof _.trim;
+ export = trim;
+}
+
+
+declare module "lodash.trimEnd" {
+ const trimEnd: typeof _.trimEnd;
+ export = trimEnd;
+}
+
+
+declare module "lodash.trimStart" {
+ const trimStart: typeof _.trimStart;
+ export = trimStart;
+}
+
+
+declare module "lodash.truncate" {
+ const truncate: typeof _.truncate;
+ export = truncate;
+}
+
+
+declare module "lodash.unescape" {
+ const unescape: typeof _.unescape;
+ export = unescape;
+}
+
+
+declare module "lodash.uniqueId" {
+ const uniqueId: typeof _.uniqueId;
+ export = uniqueId;
+}
+
+
+declare module "lodash.upperCase" {
+ const upperCase: typeof _.upperCase;
+ export = upperCase;
+}
+
+
+declare module "lodash.upperFirst" {
+ const upperFirst: typeof _.upperFirst;
+ export = upperFirst;
+}
+
+
+declare module "lodash.each" {
+ const each: typeof _.each;
+ export = each;
+}
+
+
+declare module "lodash.eachRight" {
+ const eachRight: typeof _.eachRight;
+ export = eachRight;
+}
+
+
+declare module "lodash.first" {
+ const first: typeof _.first;
+ export = first;
+}
+
+// Backward compatibility with --target es5
+interface Set<T> {}
+interface Map<K, V> {}
+interface WeakSet<T> {}
+interface WeakMap<K, V> {} \ No newline at end of file