// Type definitions for Lo-Dash 4.14 // Project: http://lodash.com/ // Definitions by: Brian Zengel , // Ilya Mochalov , // Stepan Mikhaylyuk , // Eric L Anderson , // AJ Richardson , // Junyoung Clare Jang , // e-cloud , // Georgii Dolzhykov , // Jack Moore // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.2 /** ### 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 20 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 - [X] _.conforms - [X] _.conformsTo 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 - [x] 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 - [ ] _.nthArg - [ ] _.over - [ ] _.overEvery - [ ] _.overSome - [ ] _.rangeRight - [ ] _.next */ export = _; export as namespace _; declare let _: _.LoDashStatic; type PartialObject = Partial; declare namespace _ { type Many = T | T[]; interface LoDashStatic { /** * Creates a lodash object which wraps value to enable implicit method chain sequences. * Methods that operate on and return arrays, collections, and functions can be chained together. * Methods that retrieve a single value or may return a primitive value will automatically end the * chain sequence and return the unwrapped value. Otherwise, the value must be unwrapped with value(). * * Explicit chain sequences, which must be unwrapped with value(), may be enabled using _.chain. * * The execution of chained methods is lazy, that is, it's deferred until value() is * implicitly or explicitly called. * * Lazy evaluation allows several methods to support shortcut fusion. Shortcut fusion * is an optimization to merge iteratee calls; this avoids the creation of intermediate * arrays and can greatly reduce the number of iteratee executions. Sections of a chain * sequence qualify for shortcut fusion if the section is applied to an array and iteratees * accept only one argument. The heuristic for whether a section qualifies for shortcut * fusion is subject to change. * * Chaining is supported in custom builds as long as the value() method is directly or * indirectly included in the build. * * In addition to lodash methods, wrappers have Array and String methods. * The wrapper Array methods are: * concat, join, pop, push, shift, sort, splice, and unshift. * The wrapper String methods are: * replace and split. * * The wrapper methods that support shortcut fusion are: * at, compact, drop, dropRight, dropWhile, filter, find, findLast, head, initial, last, * map, reject, reverse, slice, tail, take, takeRight, takeRightWhile, takeWhile, and toArray * * The chainable wrapper methods are: * after, ary, assign, assignIn, assignInWith, assignWith, at, before, bind, bindAll, bindKey, * castArray, chain, chunk, commit, compact, concat, conforms, constant, countBy, create, * curry, debounce, defaults, defaultsDeep, defer, delay, difference, differenceBy, differenceWith, * drop, dropRight, dropRightWhile, dropWhile, extend, extendWith, fill, filter, flatMap, * flatMapDeep, flatMapDepth, flatten, flattenDeep, flattenDepth, flip, flow, flowRight, * fromPairs, functions, functionsIn, groupBy, initial, intersection, intersectionBy, intersectionWith, * invert, invertBy, invokeMap, iteratee, keyBy, keys, keysIn, map, mapKeys, mapValues, * matches, matchesProperty, memoize, merge, mergeWith, method, methodOf, mixin, negate, * nthArg, omit, omitBy, once, orderBy, over, overArgs, overEvery, overSome, partial, partialRight, * partition, pick, pickBy, plant, property, propertyOf, pull, pullAll, pullAllBy, pullAllWith, pullAt, * push, range, rangeRight, rearg, reject, remove, rest, reverse, sampleSize, set, setWith, * shuffle, slice, sort, sortBy, sortedUniq, sortedUniqBy, splice, spread, tail, take, * takeRight, takeRightWhile, takeWhile, tap, throttle, thru, toArray, toPairs, toPairsIn, * toPath, toPlainObject, transform, unary, union, unionBy, unionWith, uniq, uniqBy, uniqWith, * unset, unshift, unzip, unzipWith, update, updateWith, values, valuesIn, without, wrap, * xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, and zipWith. * * The wrapper methods that are not chainable by default are: * add, attempt, camelCase, capitalize, ceil, clamp, clone, cloneDeep, cloneDeepWith, cloneWith, * conformsTo, deburr, defaultTo, divide, each, eachRight, endsWith, eq, escape, escapeRegExp, * every, find, findIndex, findKey, findLast, findLastIndex, findLastKey, first, floor, forEach, * forEachRight, forIn, forInRight, forOwn, forOwnRight, get, gt, gte, has, hasIn, head, * identity, includes, indexOf, inRange, invoke, isArguments, isArray, isArrayBuffer, * isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isElement, isEmpty, isEqual, isEqualWith, * isError, isFinite, isFunction, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN, * isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isRegExp, * isSafeInteger, isSet, isString, isUndefined, isTypedArray, isWeakMap, isWeakSet, join, * kebabCase, last, lastIndexOf, lowerCase, lowerFirst, lt, lte, max, maxBy, mean, meanBy, * min, minBy, multiply, noConflict, noop, now, nth, pad, padEnd, padStart, parseInt, pop, * random, reduce, reduceRight, repeat, result, round, runInContext, sample, shift, size, * snakeCase, some, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy, startCase, * startsWith, stubArray, stubFalse, stubObject, stubString, stubTrue, subtract, sum, sumBy, * template, times, toFinite, toInteger, toJSON, toLength, toLower, toNumber, toSafeInteger, * toString, toUpper, trim, trimEnd, trimStart, truncate, unescape, uniqueId, upperCase, * upperFirst, value, and words. **/ (value: T): LoDashImplicitWrapper; /** * 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; /** * 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; /** * Removes all key-value entries from the map. */ clear(): void; } interface MapCacheConstructor { new (): MapCache; } interface LoDashWrapper { } interface LoDashImplicitWrapper extends LoDashWrapper { pop(this: LoDashImplicitWrapper | null | undefined>): T | undefined; push(this: LoDashImplicitWrapper | null | undefined>, ...items: T[]): this; shift(this: LoDashImplicitWrapper | null | undefined>): T | undefined; sort(this: LoDashImplicitWrapper | null | undefined>, compareFn?: (a: T, b: T) => number): this; splice(this: LoDashImplicitWrapper | null | undefined>, start: number, deleteCount?: number, ...items: T[]): this; unshift(this: LoDashImplicitWrapper | null | undefined>, ...items: T[]): this; } interface LoDashExplicitWrapper extends LoDashWrapper { pop(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; push(this: LoDashExplicitWrapper | null | undefined>, ...items: T[]): this; shift(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; sort(this: LoDashExplicitWrapper | null | undefined>, compareFn?: (a: T, b: T) => number): this; splice(this: LoDashExplicitWrapper | null | undefined>, start: number, deleteCount?: number, ...items: T[]): this; unshift(this: LoDashExplicitWrapper | null | undefined>, ...items: T[]): this; } /********* * 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( array: List | null | undefined, size?: number ): T[][]; } interface LoDashImplicitWrapper { /** * @see _.chunk */ chunk( this: LoDashImplicitWrapper | null | undefined>, size?: number, ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.chunk */ chunk( this: LoDashExplicitWrapper | null | undefined>, size?: number, ): LoDashExplicitWrapper; } //_.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 Returns the new array of filtered values. */ compact(array: List | null | undefined): T[]; } interface LoDashImplicitWrapper { /** * @see _.compact */ compact(this: LoDashImplicitWrapper | null | undefined>): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.compact */ compact(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; } //_.concat interface LoDashStatic { /** * Creates a new array concatenating `array` with any additional arrays * and/or values. * * @category Array * @param array The array to concatenate. * @param [values] The values to concatenate. * @returns 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(array: Many, ...values: Array>): T[]; } interface LoDashImplicitWrapper { /** * @see _.compact */ concat(this: LoDashImplicitWrapper>, ...values: Array>): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.compact */ concat(this: LoDashExplicitWrapper>, ...values: Array>): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, ...values: Array> ): T[]; } interface LoDashImplicitWrapper { /** * @see _.difference */ difference( this: LoDashImplicitWrapper | null | undefined>, ...values: Array> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.difference */ difference( this: LoDashExplicitWrapper | null | undefined>, ...values: Array> ): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, values: List, iteratee: ValueIteratee ): T1[]; /** * @see _.differenceBy */ differenceBy( array: List | null | undefined, values1: List, values2: List, iteratee: ValueIteratee ): T1[]; /** * @see _.differenceBy */ differenceBy( array: List | null | undefined, values1: List, values2: List, values3: List, iteratee: ValueIteratee ): T1[]; /** * @see _.differenceBy */ differenceBy( array: List | null | undefined, values1: List, values2: List, values3: List, values4: List, iteratee: ValueIteratee ): T1[]; /** * @see _.differenceBy */ differenceBy( array: List | null | undefined, values1: List, values2: List, values3: List, values4: List, values5: List, iteratee: ValueIteratee ): T1[]; /** * @see _.differenceBy */ differenceBy( array: List | null | undefined, values1: List, values2: List, values3: List, values4: List, values5: List, ...values: Array | ValueIteratee> ): T1[]; /** * @see _.differenceBy */ differenceBy( array: List | null | undefined, ...values: Array> ): T[]; } interface LoDashImplicitWrapper { /** * @see _.differenceBy */ differenceBy( this: LoDashImplicitWrapper | null | undefined>, values: List, iteratee: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.differenceBy */ differenceBy( this: LoDashImplicitWrapper | null | undefined>, values1: List, values2: List, iteratee: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.differenceBy */ differenceBy( this: LoDashImplicitWrapper | null | undefined>, values1: List, values2: List, values3: List, iteratee: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.differenceBy */ differenceBy( this: LoDashImplicitWrapper | null | undefined>, values1: List, values2: List, values3: List, values4: List, iteratee: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.differenceBy */ differenceBy( this: LoDashImplicitWrapper | null | undefined>, values1: List, values2: List, values3: List, values4: List, values5: List, iteratee: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.differenceBy */ differenceBy( this: LoDashImplicitWrapper | null | undefined>, values1: List, values2: List, values3: List, values4: List, values5: List, ...values: Array | ValueIteratee> ): LoDashImplicitWrapper; /** * @see _.differenceBy */ differenceBy( this: LoDashImplicitWrapper | null | undefined>, ...values: Array> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.differenceBy */ differenceBy( this: LoDashExplicitWrapper | null | undefined>, values: List, iteratee: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.differenceBy */ differenceBy( this: LoDashExplicitWrapper | null | undefined>, values1: List, values2: List, iteratee: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.differenceBy */ differenceBy( this: LoDashExplicitWrapper | null | undefined>, values1: List, values2: List, values3: List, iteratee: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.differenceBy */ differenceBy( this: LoDashExplicitWrapper | null | undefined>, values1: List, values2: List, values3: List, values4: List, iteratee: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.differenceBy */ differenceBy( this: LoDashExplicitWrapper | null | undefined>, values1: List, values2: List, values3: List, values4: List, values5: List, iteratee: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.differenceBy */ differenceBy( this: LoDashExplicitWrapper | null | undefined>, values1: List, values2: List, values3: List, values4: List, values5: List, ...values: Array | ValueIteratee> ): LoDashExplicitWrapper; /** * @see _.differenceBy */ differenceBy( this: LoDashExplicitWrapper | null | undefined>, ...values: Array> ): LoDashExplicitWrapper; } //_.differenceWith 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. * * @category Array * @param [values] The arrays to inspect. * @param [comparator] The comparator invoked per element. * @returns Returns the new array of filtered values. * @example * * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual); * // => [{ 'x': 2, 'y': 1 }] */ differenceWith( array: List | null | undefined, values: List, comparator: Comparator2 ): T1[]; /** * @see _.differenceWith */ differenceWith( array: List | null | undefined, values1: List, values2: List, comparator: Comparator2 ): T1[]; /** * @see _.differenceWith */ differenceWith( array: List | null | undefined, values1: List, values2: List, ...values: Array | Comparator2> ): T1[]; /** * @see _.differenceWith */ differenceWith( array: List | null | undefined, ...values: Array> ): T[]; } interface LoDashImplicitWrapper { /** * @see _.differenceWith */ differenceWith( this: LoDashImplicitWrapper | null | undefined>, values: List, comparator: Comparator2 ): LoDashImplicitWrapper; /** * @see _.differenceWith */ differenceWith( this: LoDashImplicitWrapper | null | undefined>, values1: List, values2: List, comparator: Comparator2 ): LoDashImplicitWrapper; /** * @see _.differenceWith */ differenceWith( this: LoDashImplicitWrapper | null | undefined>, values1: List, values2: List, ...values: Array | Comparator2> ): LoDashImplicitWrapper; /** * @see _.differenceWith */ differenceWith( this: LoDashImplicitWrapper | null | undefined>, ...values: Array> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.differenceWith */ differenceWith( this: LoDashExplicitWrapper | null | undefined>, values: List, comparator: Comparator2 ): LoDashExplicitWrapper; /** * @see _.differenceWith */ differenceWith( this: LoDashExplicitWrapper | null | undefined>, values1: List, values2: List, comparator: Comparator2 ): LoDashExplicitWrapper; /** * @see _.differenceWith */ differenceWith( this: LoDashExplicitWrapper | null | undefined>, values1: List, values2: List, ...values: Array | Comparator2> ): LoDashExplicitWrapper; /** * @see _.differenceWith */ differenceWith( this: LoDashExplicitWrapper | null | undefined>, ...values: Array> ): LoDashExplicitWrapper; } //_.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(array: List | null | undefined, n?: number): T[]; } interface LoDashImplicitWrapper { /** * @see _.drop */ drop(this: LoDashImplicitWrapper | null | undefined>, n?: number): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.drop */ drop(this: LoDashExplicitWrapper | null | undefined>, n?: number): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, n?: number ): T[]; } interface LoDashImplicitWrapper { /** * @see _.dropRight */ dropRight(this: LoDashImplicitWrapper | null | undefined>, n?: number): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.dropRight */ dropRight(this: LoDashExplicitWrapper | null | undefined>, n?: number): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, predicate?: ListIteratee ): T[]; } interface LoDashImplicitWrapper { /** * @see _.dropRightWhile */ dropRightWhile( this: LoDashImplicitWrapper | null | undefined>, predicate?: ListIteratee ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.dropRightWhile */ dropRightWhile( this: LoDashExplicitWrapper | null | undefined>, predicate?: ListIteratee ): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, predicate?: ListIteratee ): T[]; } interface LoDashImplicitWrapper { /** * @see _.dropWhile */ dropWhile( this: LoDashImplicitWrapper | null | undefined>, predicate?: ListIteratee ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.dropWhile */ dropWhile( this: LoDashExplicitWrapper | null | undefined>, predicate?: ListIteratee ): LoDashExplicitWrapper; } //_.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( array: any[] | null | undefined, value: T ): T[]; /** * @see _.fill */ fill( array: List | null | undefined, value: T ): List; /** * @see _.fill */ fill( array: U[] | null | undefined, value: T, start?: number, end?: number ): Array; /** * @see _.fill */ fill( array: List | null | undefined, value: T, start?: number, end?: number ): List; } interface LoDashImplicitWrapper { /** * @see _.fill */ fill( this: LoDashImplicitWrapper, value: T ): LoDashImplicitWrapper; /** * @see _.fill */ fill( this: LoDashImplicitWrapper | null | undefined>, value: T ): LoDashImplicitWrapper>; /** * @see _.fill */ fill( this: LoDashImplicitWrapper, value: T, start?: number, end?: number ): LoDashImplicitWrapper>; /** * @see _.fill */ fill( this: LoDashImplicitWrapper | null | undefined>, value: T, start?: number, end?: number ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.fill */ fill( this: LoDashExplicitWrapper, value: T ): LoDashExplicitWrapper; /** * @see _.fill */ fill( this: LoDashExplicitWrapper | null | undefined>, value: T ): LoDashExplicitWrapper>; /** * @see _.fill */ fill( this: LoDashExplicitWrapper, value: T, start?: number, end?: number ): LoDashExplicitWrapper>; /** * @see _.fill */ fill( this: LoDashExplicitWrapper | null | undefined>, value: T, start?: number, end?: number ): LoDashExplicitWrapper>; } //_.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( array: List | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number ): number; } interface LoDashImplicitWrapper { /** * @see _.findIndex */ findIndex( this: LoDashImplicitWrapper | null | undefined>, predicate?: ListIterateeCustom, fromIndex?: number ): number; } interface LoDashExplicitWrapper { /** * @see _.findIndex */ findIndex( this: LoDashExplicitWrapper | null | undefined>, predicate?: ListIterateeCustom, fromIndex?: number ): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number ): number; } interface LoDashImplicitWrapper { /** * @see _.findLastIndex */ findLastIndex( this: LoDashImplicitWrapper | null | undefined>, predicate?: ListIterateeCustom, fromIndex?: number ): number; } interface LoDashExplicitWrapper { /** * @see _.findLastIndex */ findLastIndex( this: LoDashExplicitWrapper | null | undefined>, predicate?: ListIterateeCustom, fromIndex?: number ): LoDashExplicitWrapper; } //_.first interface LoDashStatic { first: typeof _.head; // tslint:disable-line:no-unnecessary-qualifier } interface LoDashImplicitWrapper { /** * @see _.head */ first(this: LoDashImplicitWrapper | null | undefined>): T | undefined; } interface LoDashExplicitWrapper { /** * @see _.head */ first(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; } interface RecursiveArray extends Array> {} interface ListOfRecursiveArraysOrValues extends List> {} //_.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(array: ListOfRecursiveArraysOrValues | null | undefined, isDeep: boolean): T[]; /** * @see _.flatten */ flatten(array: List> | null | undefined): T[]; } interface LoDashImplicitWrapper { /** * @see _.flatten */ flatten(this: LoDashImplicitWrapper | null | undefined>, isDeep: boolean): LoDashImplicitWrapper; /** * @see _.flatten */ flatten(this: LoDashImplicitWrapper> | null | undefined>): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.flatten */ flatten(this: LoDashExplicitWrapper | null | undefined>, isDeep: boolean): LoDashExplicitWrapper; /** * @see _.flatten */ flatten(this: LoDashExplicitWrapper> | null | undefined>): LoDashExplicitWrapper; } //_.flattenDeep interface LoDashStatic { /** * Recursively flattens a nested array. * * @param array The array to recursively flatten. * @return Returns the new flattened array. */ flattenDeep(array: ListOfRecursiveArraysOrValues | null | undefined): T[]; } interface LoDashImplicitWrapper { /** * @see _.flattenDeep */ flattenDeep(this: LoDashImplicitWrapper | null | undefined>): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.flattenDeep */ flattenDeep(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; } // _.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(array: ListOfRecursiveArraysOrValues | null | undefined, depth?: number): T[]; } interface LoDashImplicitWrapper { /** * @see _.flattenDeep */ flattenDepth(this: LoDashImplicitWrapper | null | undefined>, depth?: number): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.flattenDeep */ flattenDepth(this: LoDashExplicitWrapper | null | undefined>, depth?: number): LoDashExplicitWrapper; } //_.fromPairs interface LoDashStatic { /** * The inverse of `_.toPairs`; this method returns an object composed * from key-value `pairs`. * * @category Array * @param pairs The key-value pairs. * @returns Returns the new object. * @example * * _.fromPairs([['fred', 30], ['barney', 40]]); * // => { 'fred': 30, 'barney': 40 } */ fromPairs( pairs: List<[PropertyName, T]> | null | undefined ): Dictionary; /** @see _.fromPairs */ fromPairs( pairs: List | null | undefined ): Dictionary; } //_.fromPairs interface LoDashImplicitWrapper { /** * @see _.fromPairs */ fromPairs( this: LoDashImplicitWrapper | null | undefined> ): LoDashImplicitWrapper>; /** @see _.fromPairs */ fromPairs( this: LoDashImplicitWrapper | null | undefined> ): LoDashImplicitWrapper>; } //_.fromPairs interface LoDashExplicitWrapper { /** * @see _.fromPairs */ fromPairs( this: LoDashExplicitWrapper | null | undefined> ): LoDashExplicitWrapper>; /** @see _.fromPairs */ fromPairs( this: LoDashExplicitWrapper | null | undefined> ): LoDashExplicitWrapper>; } //_.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(array: List | null | undefined): T | undefined; } interface LoDashImplicitWrapper { /** * @see _.head */ head(this: LoDashImplicitWrapper | null | undefined>): T | undefined; } interface LoDashExplicitWrapper { /** * @see _.head */ head(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; } //_.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. * * @category Array * @param array The array to search. * @param value The value to search for. * @param [fromIndex=0] The index to search from. * @returns 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( array: List | null | undefined, value: T, fromIndex?: boolean|number ): number; } interface LoDashImplicitWrapper { /** * @see _.indexOf */ indexOf( this: LoDashImplicitWrapper | null | undefined>, value: T, fromIndex?: boolean|number ): number; } interface LoDashExplicitWrapper { /** * @see _.indexOf */ indexOf( this: LoDashExplicitWrapper | null | undefined>, value: T, fromIndex?: boolean|number ): LoDashExplicitWrapper; } //_.sortedIndexOf interface LoDashStatic { /** * This method is like `_.indexOf` except that it performs a binary * search on a sorted `array`. * * @category Array * @param array The array to search. * @param value The value to search for. * @returns Returns the index of the matched value, else `-1`. * @example * * _.sortedIndexOf([1, 1, 2, 2], 2); * // => 2 */ sortedIndexOf( array: List | null | undefined, value: T ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedIndexOf */ sortedIndexOf( this: LoDashImplicitWrapper | null | undefined>, value: T ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedIndexOf */ sortedIndexOf( this: LoDashExplicitWrapper | null | undefined>, value: T ): LoDashExplicitWrapper; } //_.initial interface LoDashStatic { /** * Gets all but the last element of array. * * @param array The array to query. * @return Returns the slice of array. */ initial(array: List | null | undefined): T[]; } interface LoDashImplicitWrapper { /** * @see _.initial */ initial(this: LoDashImplicitWrapper | null | undefined>): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.initial */ initial(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; } //_.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(...arrays: Array>): T[]; } interface LoDashImplicitWrapper { /** * @see _.intersection */ intersection( this: LoDashImplicitWrapper>, ...arrays: Array> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.intersection */ intersection( this: LoDashExplicitWrapper>, ...arrays: Array> ): LoDashExplicitWrapper; } //_.intersectionBy 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). * * @category Array * @param [arrays] The arrays to inspect. * @param [iteratee=_.identity] The iteratee invoked per element. * @returns 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: List | null, values: List, iteratee: ValueIteratee ): T1[]; /** * @see _.intersectionBy */ intersectionBy( array: List | null, values1: List, values2: List, iteratee: ValueIteratee ): T1[]; /** * @see _.intersectionBy */ intersectionBy( array: List | null | undefined, values1: List, values2: List, ...values: Array | ValueIteratee> ): T1[]; /** * @see _.intersectionBy */ intersectionBy( array?: List | null, ...values: Array> ): T[]; } interface LoDashImplicitWrapper { /** * @see _.intersectionBy */ intersectionBy( this: LoDashImplicitWrapper | null | undefined>, values: List, iteratee: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.intersectionBy */ intersectionBy( this: LoDashImplicitWrapper | null | undefined>, values1: List, values2: List, iteratee: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.intersectionBy */ intersectionBy( this: LoDashImplicitWrapper | null | undefined>, values1: List, values2: List, ...values: Array | ValueIteratee> ): LoDashImplicitWrapper; /** * @see _.intersectionBy */ intersectionBy( this: LoDashImplicitWrapper | null | undefined>, ...values: Array> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.intersectionBy */ intersectionBy( this: LoDashExplicitWrapper | null | undefined>, values: List, iteratee: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.intersectionBy */ intersectionBy( this: LoDashExplicitWrapper | null | undefined>, values1: List, values2: List, iteratee: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.intersectionBy */ intersectionBy( this: LoDashExplicitWrapper | null | undefined>, values1: List, values2: List, ...values: Array | ValueIteratee> ): LoDashExplicitWrapper; /** * @see _.intersectionBy */ intersectionBy( this: LoDashExplicitWrapper | null | undefined>, ...values: Array> ): LoDashExplicitWrapper; } //_.intersectionWith 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. * * @category Array * @param [values] The arrays to inspect. * @param [comparator] The comparator invoked per element. * @returns Returns the new array of filtered 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: List | null | undefined, values: List, comparator: Comparator2 ): T1[]; /** * @see _.intersectionWith */ intersectionWith( array: List | null | undefined, values1: List, values2: List, comparator: Comparator2 ): T1[]; /** * @see _.intersectionWith */ intersectionWith( array: List | null | undefined, values1: List, values2: List, ...values: Array | Comparator2> ): T1[]; /** * @see _.intersectionWith */ intersectionWith( array?: List | null, ...values: Array> ): T[]; } interface LoDashImplicitWrapper { /** * @see _.intersectionWith */ intersectionWith( this: LoDashImplicitWrapper | null | undefined>, values: List, comparator: Comparator2 ): LoDashImplicitWrapper; /** * @see _.intersectionWith */ intersectionWith( this: LoDashImplicitWrapper | null | undefined>, values1: List, values2: List, comparator: Comparator2 ): LoDashImplicitWrapper; /** * @see _.intersectionWith */ intersectionWith( this: LoDashImplicitWrapper | null | undefined>, values1: List, values2: List, ...values: Array | Comparator2>, ): LoDashImplicitWrapper; /** * @see _.intersectionWith */ intersectionWith( this: LoDashImplicitWrapper | null | undefined>, ...values: Array> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.intersectionWith */ intersectionWith( this: LoDashExplicitWrapper | null | undefined>, values: List, comparator: Comparator2 ): LoDashExplicitWrapper; /** * @see _.intersectionWith */ intersectionWith( this: LoDashExplicitWrapper | null | undefined>, values1: List, values2: List, comparator: Comparator2 ): LoDashExplicitWrapper; /** * @see _.intersectionWith */ intersectionWith( this: LoDashExplicitWrapper | null | undefined>, values1: List, values2: List, ...values: Array | Comparator2>, ): LoDashExplicitWrapper; /** * @see _.intersectionWith */ intersectionWith( this: LoDashExplicitWrapper | null | undefined>, ...values: Array> ): LoDashExplicitWrapper; } //_.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 | null | undefined, separator?: string ): string; } interface LoDashImplicitWrapper { /** * @see _.join */ join(separator?: string): string; } interface LoDashExplicitWrapper { /** * @see _.join */ join(separator?: string): LoDashExplicitWrapper; } //_.reverse 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). * * @category Array * @returns Returns `array`. * @example * * var array = [1, 2, 3]; * * _.reverse(array); * // => [3, 2, 1] * * console.log(array); * // => [3, 2, 1] */ reverse>( array: TList, ): TList; } //_.prototype.reverse interface LoDashWrapper { /** * 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(): this; } //_.last interface LoDashStatic { /** * Gets the last element of array. * * @param array The array to query. * @return Returns the last element of array. */ last(array: List | null | undefined): T | undefined; } interface LoDashImplicitWrapper { /** * @see _.last */ last(this: LoDashImplicitWrapper | null | undefined>): T | undefined; } interface LoDashExplicitWrapper { /** * @see _.last */ last(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, value: T, fromIndex?: true|number ): number; } interface LoDashImplicitWrapper { /** * @see _.indexOf */ lastIndexOf( this: LoDashImplicitWrapper | null | undefined>, value: T, fromIndex?: true|number ): number; } interface LoDashExplicitWrapper { /** * @see _.indexOf */ lastIndexOf( this: LoDashExplicitWrapper | null | undefined>, value: T, fromIndex?: true|number ): LoDashExplicitWrapper; } //_.nth interface LoDashStatic { /** * Gets the element at index `n` of `array`. If `n` is negative, the nth element from the end is returned. * * @param array array The array to query. * @param value The index of the element to return. * @return Returns the nth element of `array`. */ nth( array: List | null | undefined, n?: number ): T | undefined; } interface LoDashImplicitWrapper { /** * @see _.nth */ nth( this: LoDashImplicitWrapper | null | undefined>, n?: number ): T | undefined; } interface LoDashExplicitWrapper { /** * @see _.nth */ nth( this: LoDashExplicitWrapper | null | undefined>, n?: number ): LoDashExplicitWrapper; } //_.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( array: T[], ...values: T[] ): T[]; /** * @see _.pull */ pull( array: List, ...values: T[] ): List; } interface LoDashImplicitWrapper { /** * @see _.pull */ pull( this: LoDashImplicitWrapper>, ...values: T[] ): this; } interface LoDashExplicitWrapper { /** * @see _.pull */ pull( this: LoDashExplicitWrapper>, ...values: T[] ): this; } //_.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( array: T[], ...indexes: Array> ): T[]; /** * @see _.pullAt */ pullAt( array: List, ...indexes: Array> ): List; } interface LoDashWrapper { /** * @see _.pullAt */ pullAt(...indexes: Array>): this; } //_.pullAll interface LoDashStatic { /** * This method is like `_.pull` except that it accepts an array of values to remove. * * **Note:** Unlike `_.difference`, this method mutates `array`. * * @category Array * @param array The array to modify. * @param values The values to remove. * @returns Returns `array`. * @example * * var array = [1, 2, 3, 1, 2, 3]; * * _.pull(array, [2, 3]); * console.log(array); * // => [1, 1] */ pullAll( array: T[], values?: List, ): T[]; /** * @see _.pullAll */ pullAll( array: List, values?: List, ): List; } interface LoDashImplicitWrapper { /** * @see _.pullAll */ pullAll( this: LoDashImplicitWrapper>, values?: List ): this; } interface LoDashExplicitWrapper { /** * @see _.pullAll */ pullAll( this: LoDashExplicitWrapper>, values?: List ): this; } //_.pullAllBy 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`. * * @category Array * @param array The array to modify. * @param values The values to remove. * @param [iteratee=_.identity] The iteratee invoked per element. * @returns 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: T[], values?: List, iteratee?: ValueIteratee ): T[]; /** * @see _.pullAllBy */ pullAllBy( array: List, values?: List, iteratee?: ValueIteratee ): List; /** * @see _.pullAllBy */ pullAllBy( array: T1[], values: List, iteratee: ValueIteratee ): T1[]; /** * @see _.pullAllBy */ pullAllBy( array: List, values: List, iteratee: ValueIteratee ): List; } interface LoDashWrapper { /** * @see _.pullAllBy */ pullAllBy( this: LoDashWrapper>, values?: List, iteratee?: ValueIteratee ): this; /** * @see _.pullAllBy */ pullAllBy( this: LoDashWrapper>, values: List, iteratee: ValueIteratee ): this; } //_.pullAllWith interface LoDashStatic { /** * This method is like `_.pullAll` except that it accepts `comparator` which is * invoked to compare elements of array to values. The comparator is invoked with * two arguments: (arrVal, othVal). * * **Note:** Unlike `_.differenceWith`, this method mutates `array`. * * @category Array * @param array The array to modify. * @param values The values to remove. * @param [iteratee=_.identity] The iteratee invoked per element. * @returns Returns `array`. * @example * * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; * * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); * console.log(array); * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] */ pullAllWith( array: T[], values?: List, comparator?: Comparator ): T[]; /** * @see _.pullAllWith */ pullAllWith( array: List, values?: List, comparator?: Comparator ): List; /** * @see _.pullAllWith */ pullAllWith( array: T1[], values: List, comparator: Comparator2 ): T1[]; /** * @see _.pullAllWith */ pullAllWith( array: List, values: List, comparator: Comparator2 ): List; } interface LoDashWrapper { /** * @see _.pullAllWith */ pullAllWith( this: LoDashWrapper>, values?: List, comparator?: Comparator ): this; /** * @see _.pullAllWith */ pullAllWith( this: LoDashWrapper>, values: List, comparator: Comparator2 ): this; } //_.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( array: List, predicate?: ListIteratee ): T[]; } interface LoDashImplicitWrapper { /** * @see _.remove */ remove( this: LoDashImplicitWrapper>, predicate?: ListIteratee ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.remove */ remove( this: LoDashExplicitWrapper>, predicate?: ListIteratee ): LoDashExplicitWrapper; } //_.tail interface LoDashStatic { /** * Gets all but the first element of array. * * @param array The array to query. * @return Returns the slice of array. */ tail(array: List | null | undefined): T[]; } interface LoDashImplicitWrapper { /** * @see _.tail */ tail(this: LoDashImplicitWrapper | null | undefined>): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.tail */ tail(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, start?: number, end?: number ): T[]; } interface LoDashImplicitWrapper { /** * @see _.slice */ slice( this: LoDashImplicitWrapper | null | undefined>, start?: number, end?: number ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.slice */ slice( this: LoDashExplicitWrapper | null | undefined>, start?: number, end?: number ): LoDashExplicitWrapper; } //_.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. * * @category Array * @param array The sorted array to inspect. * @param value The value to evaluate. * @returns Returns the index at which `value` should be inserted into `array`. * @example * * _.sortedIndex([30, 50], 40); * // => 1 * * _.sortedIndex([4, 5], 4); * // => 0 */ sortedIndex( array: List | null | undefined, value: T ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedIndex */ sortedIndex( this: LoDashImplicitWrapper | null | undefined>, value: T ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedIndex */ sortedIndex( this: LoDashExplicitWrapper | null | undefined>, value: T ): LoDashExplicitWrapper; } // _.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). * * @category Array * @param array The sorted array to inspect. * @param value The value to evaluate. * @param [iteratee=_.identity] The iteratee invoked per element. * @returns 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( array: List | null | undefined, value: T, iteratee?: ValueIteratee ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( this: LoDashImplicitWrapper | null | undefined>, value: T, iteratee?: ValueIteratee ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( this: LoDashExplicitWrapper | null | undefined>, value: T, iteratee?: ValueIteratee ): LoDashExplicitWrapper; } //_.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. * * @category Array * @param array The sorted array to inspect. * @param value The value to evaluate. * @returns Returns the index at which `value` should be inserted into `array`. * @example * * _.sortedLastIndex([4, 5], 4); * // => 1 */ sortedLastIndex( array: List | null | undefined, value: T ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( this: LoDashImplicitWrapper | null | undefined>, value: T ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( this: LoDashExplicitWrapper | null | undefined>, value: T ): LoDashExplicitWrapper; } //_.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). * * @category Array * @param array The sorted array to inspect. * @param value The value to evaluate. * @param [iteratee=_.identity] The iteratee invoked per element. * @returns 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( array: List | null | undefined, value: T, iteratee: ValueIteratee ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( this: LoDashImplicitWrapper | null | undefined>, value: T, iteratee: ValueIteratee ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( this: LoDashExplicitWrapper | null | undefined>, value: T, iteratee: ValueIteratee ): LoDashExplicitWrapper; } //_.sortedLastIndexOf interface LoDashStatic { /** * This method is like `_.lastIndexOf` except that it performs a binary * search on a sorted `array`. * * @category Array * @param array The array to search. * @param value The value to search for. * @returns Returns the index of the matched value, else `-1`. * @example * * _.sortedLastIndexOf([1, 1, 2, 2], 2); * // => 3 */ sortedLastIndexOf( array: List | null | undefined, value: T ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedLastIndexOf */ sortedLastIndexOf( this: LoDashImplicitWrapper | null | undefined>, value: T ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedLastIndexOf */ sortedLastIndexOf( this: LoDashExplicitWrapper | null | undefined>, value: T ): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, n?: number ): T[]; } interface LoDashImplicitWrapper { /** * @see _.take */ take( this: LoDashImplicitWrapper | null | undefined>, n?: number ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.take */ take( this: LoDashExplicitWrapper | null | undefined>, n?: number ): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, n?: number ): T[]; } interface LoDashImplicitWrapper { /** * @see _.takeRight */ takeRight( this: LoDashImplicitWrapper | null | undefined>, n?: number ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.takeRight */ takeRight( this: LoDashExplicitWrapper | null | undefined>, n?: number ): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, predicate?: ListIteratee ): T[]; } interface LoDashImplicitWrapper { /** * @see _.takeRightWhile */ takeRightWhile( this: LoDashImplicitWrapper | null | undefined>, predicate?: ListIteratee ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.takeRightWhile */ takeRightWhile( this: LoDashExplicitWrapper | null | undefined>, predicate?: ListIteratee ): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, predicate?: ListIteratee ): T[]; } interface LoDashImplicitWrapper { /** * @see _.takeWhile */ takeWhile( this: LoDashImplicitWrapper | null | undefined>, predicate?: ListIteratee ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.takeWhile */ takeWhile( this: LoDashExplicitWrapper | null | undefined>, predicate?: ListIteratee ): LoDashExplicitWrapper; } //_.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(...arrays: Array | null | undefined>): T[]; } interface LoDashImplicitWrapper { /** * @see _.union */ union( this: LoDashImplicitWrapper | null | undefined>, ...arrays: Array | null | undefined> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.union */ union( this: LoDashExplicitWrapper | null | undefined>, ...arrays: Array | null | undefined> ): LoDashExplicitWrapper; } //_.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( arrays: List | null | undefined, iteratee?: ValueIteratee ): T[]; /** * @see _.unionBy */ unionBy( arrays1: List | null | undefined, arrays2: List | null | undefined, iteratee?: ValueIteratee ): T[]; /** * @see _.unionBy */ unionBy( arrays1: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, iteratee?: ValueIteratee ): T[]; /** * @see _.unionBy */ unionBy( arrays1: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, iteratee?: ValueIteratee ): T[]; /** * @see _.unionBy */ unionBy( arrays1: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, arrays5: List | null | undefined, ...iteratee: Array | List | null | undefined> ): T[]; } interface LoDashImplicitWrapper { /** * @see _.unionBy */ unionBy( this: LoDashImplicitWrapper | null | undefined>, iteratee?: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.unionBy */ unionBy( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, iteratee?: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.unionBy */ unionBy( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, iteratee?: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.unionBy */ unionBy( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, iteratee?: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.unionBy */ unionBy( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, arrays5: List | null | undefined, ...iteratee: Array | List | null | undefined> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.unionBy */ unionBy( this: LoDashExplicitWrapper | null | undefined>, iteratee?: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.unionBy */ unionBy( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, iteratee?: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.unionBy */ unionBy( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, iteratee?: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.unionBy */ unionBy( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, iteratee?: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.unionBy */ unionBy( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, arrays5: List | null | undefined, ...iteratee: Array | List | null | undefined> ): LoDashExplicitWrapper; } //_.unionWith 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). * * @category Array * @param [arrays] The arrays to inspect. * @param [comparator] The comparator invoked per element. * @returns 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( arrays: List | null | undefined, comparator?: Comparator ): T[]; /** * @see _.unionBy */ unionWith( arrays: List | null | undefined, arrays2: List | null | undefined, comparator?: Comparator ): T[]; /** * @see _.unionWith */ unionWith( arrays: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, ...comparator: Array | List | null | undefined> ): T[]; } interface LoDashImplicitWrapper { /** * @see _.unionWith */ unionWith( this: LoDashImplicitWrapper | null | undefined>, comparator?: Comparator ): LoDashImplicitWrapper; /** * @see _.unionWith */ unionWith( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, comparator?: Comparator ): LoDashImplicitWrapper; /** * @see _.unionWith */ unionWith( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, ...comparator: Array | List | null | undefined> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.unionWith */ unionWith( this: LoDashExplicitWrapper | null | undefined>, comparator?: Comparator ): LoDashExplicitWrapper; /** * @see _.unionWith */ unionWith( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, comparator?: Comparator ): LoDashExplicitWrapper; /** * @see _.unionWith */ unionWith( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, ...comparator: Array | List | null | undefined> ): LoDashExplicitWrapper; } //_.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. * * @category Array * @param array The array to inspect. * @returns Returns the new duplicate free array. * @example * * _.uniq([2, 1, 2]); * // => [2, 1] */ uniq( array: List | null | undefined ): T[]; } interface LoDashImplicitWrapper { /** * @see _.uniq */ uniq(this: LoDashImplicitWrapper | null | undefined>): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.uniq */ uniq(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; } //_.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). * * @category Array * @param array The array to inspect. * @param [iteratee=_.identity] The iteratee invoked per element. * @returns 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( array: string | null | undefined, iteratee: StringIterator ): string[]; /** * @see _.uniqBy */ uniqBy( array: List | null | undefined, iteratee: ListIteratee ): T[]; } interface LoDashImplicitWrapper { /** * @see _.uniqBy */ uniqBy( this: LoDashImplicitWrapper, iteratee: StringIterator ): LoDashImplicitWrapper; /** * @see _.uniqBy */ uniqBy( this: LoDashImplicitWrapper | null | undefined>, iteratee: ListIteratee ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.uniqBy */ uniqBy( this: LoDashExplicitWrapper, iteratee: StringIterator ): LoDashExplicitWrapper; /** * @see _.uniqBy */ uniqBy( this: LoDashExplicitWrapper | null | undefined>, iteratee: ListIteratee ): LoDashExplicitWrapper; } //_.uniqWith 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). * * @category Array * @param array The array to inspect. * @param [comparator] The comparator invoked per element. * @returns 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: List | null | undefined, comparator?: Comparator ): T[]; } interface LoDashImplicitWrapper { /** * @see _.uniqWith */ uniqWith( this: LoDashImplicitWrapper | null | undefined>, comparator?: Comparator ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.uniqWith */ uniqWith( this: LoDashExplicitWrapper | null | undefined>, comparator?: Comparator ): LoDashExplicitWrapper; } //_.sortedUniq interface LoDashStatic { /** * This method is like `_.uniq` except that it's designed and optimized * for sorted arrays. * * @category Array * @param array The array to inspect. * @returns Returns the new duplicate free array. * @example * * _.sortedUniq([1, 1, 2]); * // => [1, 2] */ sortedUniq( array: List | null | undefined ): T[]; } interface LoDashImplicitWrapper { /** * @see _.sortedUniq */ sortedUniq(this: LoDashImplicitWrapper | null | undefined>): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.sortedUniq */ sortedUniq(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; } //_.sortedUniqBy interface LoDashStatic { /** * This method is like `_.uniqBy` except that it's designed and optimized * for sorted arrays. * * @category Array * @param array The array to inspect. * @param [iteratee] The iteratee invoked per element. * @returns Returns the new duplicate free array. * @example * * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor); * // => [1.1, 2.2] */ sortedUniqBy( array: string | null | undefined, iteratee: StringIterator ): string[]; /** * @see _.sortedUniqBy */ sortedUniqBy( array: List | null | undefined, iteratee: ListIteratee ): T[]; } interface LoDashImplicitWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( this: LoDashImplicitWrapper, iteratee: StringIterator ): LoDashImplicitWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( this: LoDashImplicitWrapper | null | undefined>, iteratee: ListIteratee ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( this: LoDashExplicitWrapper, iteratee: StringIterator ): LoDashExplicitWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( this: LoDashExplicitWrapper | null | undefined>, iteratee: ListIteratee ): LoDashExplicitWrapper; } //_.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(array: T[][] | List> | null | undefined): T[][]; } interface LoDashImplicitWrapper { /** * @see _.unzip */ unzip(this: LoDashImplicitWrapper> | null | undefined>): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.unzip */ unzip(this: LoDashExplicitWrapper> | null | undefined>): LoDashExplicitWrapper; } //_.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( array: List> | null | undefined, iteratee: (...values: T[]) => TResult ): TResult[]; /** * @see _.unzipWith */ unzipWith( array: List> | null | undefined ): T[][]; } interface LoDashImplicitWrapper { /** * @see _.unzipWith */ unzipWith( this: LoDashImplicitWrapper> | null | undefined>, iteratee: (...values: T[]) => TResult ): LoDashImplicitWrapper; /** * @see _.unzipWith */ unzipWith( this: LoDashImplicitWrapper> | null | undefined> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.unzipWith */ unzipWith( this: LoDashExplicitWrapper> | null | undefined>, iteratee: (...values: T[]) => TResult ): LoDashExplicitWrapper; /** * @see _.unzipWith */ unzipWith( this: LoDashExplicitWrapper> | null | undefined> ): LoDashExplicitWrapper; } //_.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( array: List | null | undefined, ...values: T[] ): T[]; } interface LoDashImplicitWrapper { /** * @see _.without */ without( this: LoDashImplicitWrapper | null | undefined>, ...values: T[] ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.without */ without( this: LoDashExplicitWrapper | null | undefined>, ...values: T[] ): LoDashExplicitWrapper; } //_.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(...arrays: Array | null | undefined>): T[]; } interface LoDashImplicitWrapper { /** * @see _.xor */ xor( this: LoDashImplicitWrapper | null | undefined>, ...arrays: Array | null | undefined> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.xor */ xor( this: LoDashExplicitWrapper | null | undefined>, ...arrays: Array | null | undefined> ): LoDashExplicitWrapper; } //_.xorBy 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). * * @category Array * @param [arrays] The arrays to inspect. * @param [iteratee=_.identity] The iteratee invoked per element. * @returns 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( arrays: List | null | undefined, iteratee?: ValueIteratee ): T[]; /** * @see _.xorBy */ xorBy( arrays: List | null | undefined, arrays2: List | null | undefined, iteratee?: ValueIteratee ): T[]; /** * @see _.xorBy */ xorBy( arrays: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, ...iteratee: Array | List | null | undefined> ): T[]; } interface LoDashImplicitWrapper { /** * @see _.xor */ xorBy( this: LoDashImplicitWrapper | null | undefined>, iteratee?: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.xorBy */ xorBy( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, iteratee?: ValueIteratee ): LoDashImplicitWrapper; /** * @see _.xorBy */ xorBy( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, ...iteratee: Array | List | null | undefined> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.xorBy */ xorBy( this: LoDashExplicitWrapper | null | undefined>, iteratee?: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.xorBy */ xorBy( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, iteratee?: ValueIteratee ): LoDashExplicitWrapper; /** * @see _.xorBy */ xorBy( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, ...iteratee: Array | List | null | undefined> ): LoDashExplicitWrapper; } //_.xorWith 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). * * @category Array * @param [arrays] The arrays to inspect. * @param [comparator] The comparator invoked per element. * @returns 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( arrays: List | null | undefined, comparator?: Comparator ): T[]; /** * @see _.xorWith */ xorWith( arrays: List | null | undefined, arrays2: List | null | undefined, comparator?: Comparator ): T[]; /** * @see _.xorWith */ xorWith( arrays: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, ...comparator: Array | List | null | undefined> ): T[]; } interface LoDashImplicitWrapper { /** * @see _.xorWith */ xorWith( this: LoDashImplicitWrapper | null | undefined>, comparator?: Comparator ): LoDashImplicitWrapper; /** * @see _.xorWith */ xorWith( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, comparator?: Comparator ): LoDashImplicitWrapper; /** * @see _.xorWith */ xorWith( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, ...comparator: Array | List | null | undefined> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.xorWith */ xorWith( this: LoDashExplicitWrapper | null | undefined>, comparator?: Comparator ): LoDashExplicitWrapper; /** * @see _.xorWith */ xorWith( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, comparator?: Comparator ): LoDashExplicitWrapper; /** * @see _.xorWith */ xorWith( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, ...comparator: Array | List | null | undefined> ): LoDashExplicitWrapper; } //_.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(...arrays: Array | null | undefined>): T[][]; } interface LoDashImplicitWrapper { /** * @see _.zip */ zip( this: LoDashImplicitWrapper | null | undefined>, ...arrays: Array | null | undefined> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.zip */ zip( this: LoDashExplicitWrapper | null | undefined>, ...arrays: Array | null | undefined> ): LoDashExplicitWrapper; } //_.zipObject interface LoDashStatic { /** * This method is like _.fromPairs except that it accepts two arrays, one of property * identifiers and one of corresponding values. * * @param props The property names. * @param values The property values. * @return Returns the new object. */ zipObject( props: List, values: List ): Dictionary; /** * @see _.zipObject */ zipObject( props?: List ): Dictionary; /** * This method is like _.zipObject except that it supports property paths. * * @param paths The property names. * @param values The property values. * @return Returns the new object. */ zipObjectDeep( paths?: List, values?: List ): object; } interface LoDashImplicitWrapper { /** * @see _.zipObject */ zipObject( this: LoDashImplicitWrapper>, values: List ): LoDashImplicitWrapper>; /** * @see _.zipObject */ zipObject( this: LoDashImplicitWrapper> ): LoDashImplicitWrapper>; /** * @see _.zipObjectDeep */ zipObjectDeep( this: LoDashImplicitWrapper>, values?: List ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.zipObject */ zipObject( this: LoDashExplicitWrapper>, values: List ): LoDashExplicitWrapper>; /** * @see _.zipObject */ zipObject( this: LoDashExplicitWrapper> ): LoDashExplicitWrapper>; /** * @see _.zipObjectDeep */ zipObjectDeep( this: LoDashExplicitWrapper>, values?: List ): LoDashExplicitWrapper; } //_.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 [arrays] The arrays to process. * @param [iteratee] The function to combine grouped values. * @param [thisArg] The `this` binding of `iteratee`. * @return Returns the new array of grouped elements. */ zipWith( ...arrays: Array | null | undefined> ): T[][]; /** * @see _.zipWith */ zipWith( arrays: List | null | undefined, iteratee: (value1: T) => TResult ): TResult[]; /** * @see _.zipWith */ zipWith( arrays: List | null | undefined, arrays2: List | null | undefined, iteratee: (value1: T, value2: T) => TResult ): TResult[]; /** * @see _.zipWith */ zipWith( arrays: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, iteratee: (value1: T, value2: T, value3: T) => TResult ): TResult[]; /** * @see _.zipWith */ zipWith( arrays: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, iteratee: (value1: T, value2: T, value3: T, value4: T) => TResult ): TResult[]; /** * @see _.zipWith */ zipWith( arrays: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, arrays5: List | null | undefined, iteratee: (value1: T, value2: T, value3: T, value4: T, value5: T) => TResult ): TResult[]; zipWith( ...iteratee: Array<((...group: T[]) => TResult) | List | null | undefined> ): TResult[]; } interface LoDashImplicitWrapper { /** * @see _.zipWith */ zipWith( this: LoDashImplicitWrapper | null | undefined>, ...arrays: Array | null | undefined> ): LoDashImplicitWrapper; /** * @see _.zipWith */ zipWith( this: LoDashImplicitWrapper | null | undefined>, iteratee: (value1: T) => TResult ): LoDashImplicitWrapper; /** * @see _.zipWith */ zipWith( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, iteratee: (value1: T, value2: T) => TResult ): LoDashImplicitWrapper; /** * @see _.zipWith */ zipWith( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, iteratee: (value1: T, value2: T, value3: T) => TResult ): LoDashImplicitWrapper; /** * @see _.zipWith */ zipWith( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, iteratee: (value1: T, value2: T, value3: T, value4: T) => TResult ): LoDashImplicitWrapper; /** * @see _.zipWith */ zipWith( this: LoDashImplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, arrays5: List | null | undefined, ...iteratee: Array<((...group: T[]) => TResult) | List | null | undefined> ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.zipWith */ zipWith( this: LoDashExplicitWrapper | null | undefined>, ...arrays: Array | null | undefined> ): LoDashExplicitWrapper; /** * @see _.zipWith */ zipWith( this: LoDashExplicitWrapper | null | undefined>, iteratee: (value1: T) => TResult ): LoDashExplicitWrapper; /** * @see _.zipWith */ zipWith( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, iteratee: (value1: T, value2: T) => TResult ): LoDashExplicitWrapper; /** * @see _.zipWith */ zipWith( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, iteratee: (value1: T, value2: T, value3: T) => TResult ): LoDashExplicitWrapper; /** * @see _.zipWith */ zipWith( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, iteratee: (value1: T, value2: T, value3: T, value4: T) => TResult ): LoDashExplicitWrapper; /** * @see _.zipWith */ zipWith( this: LoDashExplicitWrapper | null | undefined>, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, arrays5: List | null | undefined, ...iteratee: Array<((...group: T[]) => TResult) | List | null | undefined> ): LoDashExplicitWrapper; } /********* * 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: T): LoDashExplicitWrapper; } interface LoDashImplicitWrapper { /** * @see _.chain */ chain(): LoDashExplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.chain */ chain(): this; } //_.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( value: T, interceptor: (value: T) => void ): T; } interface LoDashWrapper { /** * @see _.tap */ tap( interceptor: (value: TValue) => void ): this; } //_.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( value: T, interceptor: (value: T) => TResult ): TResult; } interface LoDashImplicitWrapper { /** * @see _.thru */ thru(interceptor: (value: TValue) => TResult): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.thru */ thru(interceptor: (value: TValue) => TResult): LoDashExplicitWrapper; } //_.prototype.commit interface LoDashWrapper { /** * Executes the chained sequence and returns the wrapped result. * * @return Returns the new lodash wrapper instance. */ commit(): this; } //_.prototype.plant interface LoDashImplicitWrapper { /** * 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: T): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.plant */ plant(value: T): LoDashExplicitWrapper; } //_.prototype.toJSON interface LoDashWrapper { /** * @see _.value */ toJSON(): TValue; } //_.prototype.toString interface LoDashWrapper { /** * Produces the result of coercing the unwrapped value to a string. * * @return Returns the coerced string value. */ toString(): string; } //_.prototype.value interface LoDashWrapper { /** * Executes the chained sequence to extract the unwrapped value. * * @alias _.toJSON, _.valueOf * * @return Returns the resolved unwrapped value. */ value(): TValue; } //_.valueOf interface LoDashWrapper { /** * @see _.value */ valueOf(): TValue; } /************** * 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 object The object 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( object: List | Dictionary | null | undefined, ...props: PropertyPath[] ): T[]; /** * @see _.at */ at( object: T | null | undefined, ...props: Array> ): Array; } interface LoDashImplicitWrapper { /** * @see _.at */ at( this: LoDashImplicitWrapper | Dictionary | null | undefined>, ...props: PropertyPath[] ): LoDashImplicitWrapper; /** * @see _.at */ at( this: LoDashImplicitWrapper, ...props: Array> ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.at */ at( this: LoDashExplicitWrapper | Dictionary | null | undefined>, ...props: PropertyPath[] ): LoDashExplicitWrapper; /** * @see _.at */ at( this: LoDashExplicitWrapper, ...props: Array> ): LoDashExplicitWrapper>; } //_.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( collection: string | null | undefined, iteratee?: StringIterator ): Dictionary; /** * @see _.countBy */ countBy( collection: List | null | undefined, iteratee?: ListIteratee ): Dictionary; /** * @see _.countBy */ countBy( collection: NumericDictionary | null | undefined, iteratee?: NumericDictionaryIteratee ): Dictionary; /** * @see _.countBy */ countBy( collection: T | null | undefined, iteratee?: ObjectIteratee ): Dictionary; } interface LoDashImplicitWrapper { /** * @see _.countBy */ countBy( this: LoDashImplicitWrapper, iteratee?: StringIterator ): LoDashImplicitWrapper>; /** * @see _.countBy */ countBy( this: LoDashImplicitWrapper | null | undefined>, iteratee?: ListIteratee ): LoDashImplicitWrapper>; /** * @see _.countBy */ countBy( this: LoDashImplicitWrapper, iteratee?: ObjectIteratee ): LoDashImplicitWrapper>; /** * @see _.countBy */ countBy( this: LoDashImplicitWrapper | null | undefined>, iteratee?: NumericDictionaryIteratee ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.countBy */ countBy( this: LoDashExplicitWrapper, iteratee?: StringIterator ): LoDashExplicitWrapper>; /** * @see _.countBy */ countBy( this: LoDashExplicitWrapper | null | undefined>, iteratee?: ListIteratee ): LoDashExplicitWrapper>; /** * @see _.countBy */ countBy( this: LoDashExplicitWrapper, iteratee?: ObjectIteratee ): LoDashExplicitWrapper>; /** * @see _.countBy */ countBy( this: LoDashExplicitWrapper | null | undefined>, iteratee?: NumericDictionaryIteratee ): LoDashExplicitWrapper>; } //_.each interface LoDashStatic { each: typeof _.forEach; // tslint:disable-line:no-unnecessary-qualifier } interface LoDashWrapper { /** * @see _.forEach */ each( this: LoDashWrapper, iteratee?: ArrayIterator ): this; /** * @see _.forEach */ each( this: LoDashWrapper, iteratee?: StringIterator ): this; /** * @see _.forEach */ each( this: LoDashWrapper | null | undefined>, iteratee?: ListIterator ): this; /** * @see _.forEach */ each( this: LoDashWrapper, iteratee?: ObjectIterator ): this; } //_.eachRight interface LoDashStatic { eachRight: typeof _.forEachRight; // tslint:disable-line:no-unnecessary-qualifier } interface LoDashWrapper { /** * @see _.forEachRight */ eachRight( this: LoDashWrapper, iteratee?: ArrayIterator ): this; /** * @see _.forEachRight */ eachRight( this: LoDashWrapper, iteratee?: StringIterator ): this; /** * @see _.forEachRight */ eachRight( this: LoDashWrapper | null | undefined>, iteratee?: ListIterator ): this; /** * @see _.forEachRight */ eachRight( this: LoDashWrapper, iteratee?: ObjectIterator ): this; } //_.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( collection: List | null | undefined, predicate?: ListIterateeCustom ): boolean; /** * @see _.every */ every( collection: NumericDictionary | null | undefined, predicate?: NumericDictionaryIterateeCustom ): boolean; /** * @see _.every */ every( collection: T | null | undefined, predicate?: ObjectIterateeCustom ): boolean; } interface LoDashImplicitWrapper { /** * @see _.every */ every( this: LoDashImplicitWrapper | null | undefined>, predicate?: ListIterateeCustom ): boolean; /** * @see _.every */ every( this: LoDashImplicitWrapper, predicate?: ObjectIterateeCustom ): boolean; /** * @see _.every */ every( this: LoDashImplicitWrapper | null | undefined>, predicate?: NumericDictionaryIterateeCustom ): boolean; } interface LoDashExplicitWrapper { /** * @see _.every */ every( this: LoDashExplicitWrapper | null | undefined>, predicate?: ListIterateeCustom ): LoDashExplicitWrapper; /** * @see _.every */ every( this: LoDashExplicitWrapper, predicate?: ObjectIterateeCustom ): LoDashExplicitWrapper; /** * @see _.every */ every( this: LoDashExplicitWrapper | null | undefined>, predicate?: NumericDictionaryIterateeCustom ): LoDashExplicitWrapper; } //_.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( collection: string | null | undefined, predicate?: StringIterator ): string[]; /** * @see _.filter */ filter( collection: List | null | undefined, predicate: ListIteratorTypeGuard ): S[]; /** * @see _.filter */ filter( collection: List | null | undefined, predicate?: ListIterateeCustom ): T[]; /** * @see _.filter */ filter( collection: T | null | undefined, predicate: ObjectIteratorTypeGuard ): S[]; /** * @see _.filter */ filter( collection: T | null | undefined, predicate?: ObjectIterateeCustom ): Array; } interface LoDashImplicitWrapper { /** * @see _.filter */ filter( this: LoDashImplicitWrapper, predicate?: StringIterator ): LoDashImplicitWrapper; /** * @see _.filter */ filter( this: LoDashImplicitWrapper | null | undefined>, predicate: ListIteratorTypeGuard ): LoDashImplicitWrapper; /** * @see _.filter */ filter( this: LoDashImplicitWrapper | null | undefined>, predicate?: ListIterateeCustom ): LoDashImplicitWrapper; /** * @see _.filter */ filter( this: LoDashImplicitWrapper, predicate: ObjectIteratorTypeGuard ): LoDashImplicitWrapper; /** * @see _.filter */ filter( this: LoDashImplicitWrapper, predicate?: ObjectIterateeCustom ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.filter */ filter( this: LoDashExplicitWrapper, predicate?: StringIterator ): LoDashExplicitWrapper; /** * @see _.filter */ filter( this: LoDashExplicitWrapper | null | undefined>, predicate: ListIteratorTypeGuard ): LoDashExplicitWrapper; /** * @see _.filter */ filter( this: LoDashExplicitWrapper | null | undefined>, predicate?: ListIterateeCustom ): LoDashExplicitWrapper; /** * @see _.filter */ filter( this: LoDashExplicitWrapper, predicate: ObjectIteratorTypeGuard ): LoDashExplicitWrapper; /** * @see _.filter */ filter( this: LoDashExplicitWrapper, predicate?: ObjectIterateeCustom ): LoDashExplicitWrapper>; } //_.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( collection: List | null | undefined, predicate: ListIteratorTypeGuard, fromIndex?: number ): S|undefined; /** * @see _.find */ find( collection: List | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number ): T|undefined; /** * @see _.find */ find( collection: T | null | undefined, predicate: ObjectIteratorTypeGuard, fromIndex?: number ): S|undefined; /** * @see _.find */ find( collection: T | null | undefined, predicate?: ObjectIterateeCustom, fromIndex?: number ): T[keyof T]|undefined; } interface LoDashImplicitWrapper { /** * @see _.find */ find( this: LoDashImplicitWrapper | null | undefined>, predicate: ListIteratorTypeGuard, fromIndex?: number ): S|undefined; /** * @see _.find */ find( this: LoDashImplicitWrapper | null | undefined>, predicate?: ListIterateeCustom, fromIndex?: number ): T|undefined; /** * @see _.find */ find( this: LoDashImplicitWrapper, predicate: ObjectIteratorTypeGuard, fromIndex?: number ): S|undefined; /** * @see _.find */ find( this: LoDashImplicitWrapper, predicate?: ObjectIterateeCustom, fromIndex?: number ): T[keyof T]|undefined; } interface LoDashExplicitWrapper { /** * @see _.find */ find( this: LoDashExplicitWrapper | null | undefined>, predicate: ListIteratorTypeGuard, fromIndex?: number ): LoDashExplicitWrapper; /** * @see _.find */ find( this: LoDashExplicitWrapper | null | undefined>, predicate?: ListIterateeCustom, fromIndex?: number ): LoDashExplicitWrapper; /** * @see _.find */ find( this: LoDashExplicitWrapper, predicate: ObjectIteratorTypeGuard, fromIndex?: number ): LoDashExplicitWrapper; /** * @see _.find */ find( this: LoDashExplicitWrapper, predicate?: ObjectIterateeCustom, fromIndex?: number ): LoDashExplicitWrapper; } //_.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 predicate The function called per iteration. * @param fromIndex The index to search from. * @return The found element, else undefined. **/ findLast( collection: List | null | undefined, predicate: ListIteratorTypeGuard, fromIndex?: number ): S|undefined; /** * @see _.findLast */ findLast( collection: List | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number ): T|undefined; /** * @see _.findLast */ findLast( collection: T | null | undefined, predicate: ObjectIteratorTypeGuard, fromIndex?: number ): S|undefined; /** * @see _.findLast */ findLast( collection: T | null | undefined, predicate?: ObjectIterateeCustom, fromIndex?: number ): T[keyof T]|undefined; } interface LoDashImplicitWrapper { /** * @see _.findLast */ findLast( this: LoDashImplicitWrapper | null | undefined>, predicate: ListIteratorTypeGuard, fromIndex?: number ): S | undefined; /** * @see _.findLast */ findLast( this: LoDashImplicitWrapper | null | undefined>, predicate?: ListIterateeCustom, fromIndex?: number ): T | undefined; /** * @see _.findLast */ findLast( this: LoDashImplicitWrapper, predicate: ObjectIteratorTypeGuard, fromIndex?: number ): S|undefined; /** * @see _.findLast */ findLast( this: LoDashImplicitWrapper, predicate?: ObjectIterateeCustom, fromIndex?: number ): T[keyof T]|undefined; } interface LoDashExplicitWrapper { /** * @see _.findLast */ findLast( this: LoDashExplicitWrapper | null | undefined>, predicate: ListIteratorTypeGuard, fromIndex?: number ): LoDashExplicitWrapper; /** * @see _.findLast */ findLast( this: LoDashExplicitWrapper | null | undefined>, predicate?: ListIterateeCustom, fromIndex?: number ): LoDashExplicitWrapper; /** * @see _.findLast */ findLast( this: LoDashExplicitWrapper, predicate: ObjectIteratorTypeGuard, fromIndex?: number ): LoDashExplicitWrapper; /** * @see _.findLast */ findLast( this: LoDashExplicitWrapper, predicate?: ObjectIterateeCustom, fromIndex?: number ): LoDashExplicitWrapper; } //_.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( collection: List> | Dictionary> | NumericDictionary> | null | undefined ): T[]; /** * @see _.flatMap */ flatMap( collection: object | null | undefined ): any[]; /** * @see _.flatMap */ flatMap( collection: List | null | undefined, iteratee: ListIterator> ): TResult[]; /** * @see _.flatMap */ flatMap( collection: NumericDictionary | null | undefined, iteratee: NumericDictionaryIterator> ): TResult[]; /** * @see _.flatMap */ flatMap( collection: T | null | undefined, iteratee: ObjectIterator> ): TResult[]; /** * @see _.flatMap */ flatMap( collection: object | null | undefined, iteratee: string ): any[]; /** * @see _.flatMap */ flatMap( collection: object | null | undefined, iteratee: object ): boolean[]; } interface LoDashImplicitWrapper { /** * @see _.flatMap */ flatMap(this: LoDashImplicitWrapper> | Dictionary> | NumericDictionary> | null | undefined>): LoDashImplicitWrapper; /** * @see _.flatMap */ flatMap(): LoDashImplicitWrapper; /** * @see _.flatMap */ flatMap( this: LoDashImplicitWrapper | null | undefined>, iteratee: ListIterator> ): LoDashImplicitWrapper; /** * @see _.flatMap */ flatMap( this: LoDashImplicitWrapper, iteratee: ObjectIterator> ): LoDashImplicitWrapper; /** * @see _.flatMap */ flatMap( this: LoDashImplicitWrapper | null | undefined>, iteratee: NumericDictionaryIterator> ): LoDashImplicitWrapper; /** * @see _.flatMap */ flatMap( iteratee: string ): LoDashImplicitWrapper; /** * @see _.flatMap */ flatMap( iteratee: object ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.flatMap */ flatMap(this: LoDashExplicitWrapper> | Dictionary> | NumericDictionary> | null | undefined>): LoDashExplicitWrapper; /** * @see _.flatMap */ flatMap(): LoDashExplicitWrapper; /** * @see _.flatMap */ flatMap( this: LoDashExplicitWrapper | null | undefined>, iteratee: ListIterator> ): LoDashExplicitWrapper; /** * @see _.flatMap */ flatMap( this: LoDashExplicitWrapper | null | undefined>, iteratee: NumericDictionaryIterator> ): LoDashExplicitWrapper; /** * @see _.flatMap */ flatMap( this: LoDashExplicitWrapper, iteratee: ObjectIterator> ): LoDashExplicitWrapper; /** * @see _.flatMap */ flatMap( iteratee: string ): LoDashExplicitWrapper; /** * @see _.flatMap */ flatMap( iteratee: object ): LoDashExplicitWrapper; } //_.flatMapDeep interface LoDashStatic { /** * This method is like `_.flatMap` except that it recursively flattens the * mapped results. * * @since 4.7.0 * @category Collection * @param collection The collection to iterate over. * @param [iteratee=_.identity] The function invoked per iteration. * @returns Returns the new flattened array. * @example * * function duplicate(n) { * return [[[n, n]]]; * } * * _.flatMapDeep([1, 2], duplicate); * // => [1, 1, 2, 2] */ flatMapDeep( collection: List | T> | Dictionary | T> | NumericDictionary | T> | null | undefined ): T[]; /** * @see _.flatMapDeep */ flatMapDeep( collection: List | null | undefined, iteratee: ListIterator | TResult> ): TResult[]; /** * @see _.flatMapDeep */ flatMapDeep( collection: NumericDictionary | null | undefined, iteratee: NumericDictionaryIterator | TResult> ): TResult[]; /** * @see _.flatMapDeep */ flatMapDeep( collection: T | null | undefined, iteratee: ObjectIterator | TResult> ): TResult[]; /** * @see _.flatMapDeep */ flatMapDeep( collection: object | null | undefined, iteratee: string ): any[]; /** * @see _.flatMapDeep */ flatMapDeep( collection: object | null | undefined, iteratee: object ): boolean[]; } interface LoDashImplicitWrapper { /** * @see _.flatMapDeep */ flatMapDeep( this: LoDashImplicitWrapper | T> | Dictionary | T> | NumericDictionary | T> | null | undefined> ): LoDashImplicitWrapper; /** * @see _.flatMapDeep */ flatMapDeep( this: LoDashImplicitWrapper | null | undefined>, iteratee: ListIterator | TResult> ): LoDashImplicitWrapper; /** * @see _.flatMapDeep */ flatMapDeep( this: LoDashImplicitWrapper | null | undefined>, iteratee: NumericDictionaryIterator | TResult> ): LoDashImplicitWrapper; /** * @see _.flatMapDeep */ flatMapDeep( this: LoDashImplicitWrapper, iteratee: ObjectIterator | TResult> ): LoDashImplicitWrapper; /** * @see _.flatMapDeep */ flatMapDeep( this: LoDashImplicitWrapper, iteratee: string ): LoDashImplicitWrapper; /** * @see _.flatMapDeep */ flatMapDeep( this: LoDashImplicitWrapper, iteratee: object ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.flatMapDeep */ flatMapDeep( this: LoDashExplicitWrapper | T> | Dictionary | T> | NumericDictionary | T> | null | undefined> ): LoDashExplicitWrapper; /** * @see _.flatMapDeep */ flatMapDeep( this: LoDashExplicitWrapper | null | undefined>, iteratee: ListIterator | TResult> ): LoDashExplicitWrapper; /** * @see _.flatMapDeep */ flatMapDeep( this: LoDashExplicitWrapper | null | undefined>, iteratee: NumericDictionaryIterator | TResult> ): LoDashExplicitWrapper; /** * @see _.flatMapDeep */ flatMapDeep( this: LoDashExplicitWrapper, iteratee: ObjectIterator | TResult> ): LoDashExplicitWrapper; /** * @see _.flatMapDeep */ flatMapDeep( this: LoDashExplicitWrapper, iteratee: string ): LoDashExplicitWrapper; /** * @see _.flatMapDeep */ flatMapDeep( this: LoDashExplicitWrapper, iteratee: object ): LoDashExplicitWrapper; } //_.flatMapDepth interface LoDashStatic { /** * This method is like `_.flatMap` except that it recursively flattens the * mapped results up to `depth` times. * * @since 4.7.0 * @category Collection * @param collection The collection to iterate over. * @param [iteratee=_.identity] The function invoked per iteration. * @param [depth=1] The maximum recursion depth. * @returns Returns the new flattened array. * @example * * function duplicate(n) { * return [[[n, n]]]; * } * * _.flatMapDepth([1, 2], duplicate, 2); * // => [[1, 1], [2, 2]] */ flatMapDepth( collection: List | T> | Dictionary | T> | NumericDictionary | T> | null | undefined ): T[]; /** * @see _.flatMapDepth */ flatMapDepth( collection: List | null | undefined, iteratee: ListIterator | TResult>, depth?: number ): TResult[]; /** * @see _.flatMapDepth */ flatMapDepth( collection: NumericDictionary | null | undefined, iteratee: NumericDictionaryIterator | TResult>, depth?: number ): TResult[]; /** * @see _.flatMapDepth */ flatMapDepth( collection: T | null | undefined, iteratee: ObjectIterator | TResult>, depth?: number ): TResult[]; /** * @see _.flatMapDepth */ flatMapDepth( collection: object | null | undefined, iteratee: string, depth?: number ): any[]; /** * @see _.flatMapDepth */ flatMapDepth( collection: object | null | undefined, iteratee: object, depth?: number ): boolean[]; } interface LoDashImplicitWrapper { /** * @see _.flatMapDepth */ flatMapDepth( this: LoDashImplicitWrapper | T> | Dictionary | T> | NumericDictionary | T> | null | undefined> ): LoDashImplicitWrapper; /** * @see _.flatMapDepth */ flatMapDepth( this: LoDashImplicitWrapper | null | undefined>, iteratee: ListIterator | TResult>, depth?: number ): LoDashImplicitWrapper; /** * @see _.flatMapDepth */ flatMapDepth( this: LoDashImplicitWrapper | null | undefined>, iteratee: NumericDictionaryIterator | TResult>, depth?: number ): LoDashImplicitWrapper; /** * @see _.flatMapDepth */ flatMapDepth( this: LoDashImplicitWrapper, iteratee: ObjectIterator | TResult>, depth?: number ): LoDashImplicitWrapper; /** * @see _.flatMapDepth */ flatMapDepth( this: LoDashImplicitWrapper, iteratee: string, depth?: number ): LoDashImplicitWrapper; /** * @see _.flatMapDepth */ flatMapDepth( this: LoDashImplicitWrapper, iteratee: object, depth?: number ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.flatMapDepth */ flatMapDepth( this: LoDashExplicitWrapper | T> | Dictionary | T> | NumericDictionary | T> | null | undefined> ): LoDashExplicitWrapper; /** * @see _.flatMapDepth */ flatMapDepth( this: LoDashExplicitWrapper | null | undefined>, iteratee: ListIterator | TResult>, depth?: number ): LoDashExplicitWrapper; /** * @see _.flatMapDepth */ flatMapDepth( this: LoDashExplicitWrapper | null | undefined>, iteratee: NumericDictionaryIterator | TResult>, depth?: number ): LoDashExplicitWrapper; /** * @see _.flatMapDepth */ flatMapDepth( this: LoDashExplicitWrapper, iteratee: ObjectIterator | TResult>, depth?: number ): LoDashExplicitWrapper; /** * @see _.flatMapDepth */ flatMapDepth( this: LoDashExplicitWrapper, iteratee: string, depth?: number ): LoDashExplicitWrapper; /** * @see _.flatMapDepth */ flatMapDepth( this: LoDashExplicitWrapper, iteratee: object, depth?: number ): LoDashExplicitWrapper; } //_.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( collection: T[], iteratee?: ArrayIterator ): T[]; /** * @see _.forEach */ forEach( collection: string, iteratee?: StringIterator ): string; /** * @see _.forEach */ forEach( collection: List, iteratee?: ListIterator ): List; /** * @see _.forEach */ forEach( collection: T, iteratee?: ObjectIterator ): T; /** * @see _.forEach */ forEach( collection: TArray & (T[] | null | undefined), iteratee?: ArrayIterator ): TArray; /** * @see _.forEach */ forEach( collection: TString, iteratee?: StringIterator ): TString; /** * @see _.forEach */ forEach | null | undefined>( collection: TList & (List | null | undefined), iteratee?: ListIterator ): TList; /** * @see _.forEach */ forEach( collection: T | null | undefined, iteratee?: ObjectIterator ): T | null | undefined; } interface LoDashWrapper { /** * @see _.forEach */ forEach( this: LoDashWrapper, iteratee?: ArrayIterator ): this; /** * @see _.forEach */ forEach( this: LoDashWrapper, iteratee?: StringIterator ): this; /** * @see _.forEach */ forEach( this: LoDashWrapper | null | undefined>, iteratee?: ListIterator ): this; /** * @see _.forEach */ forEach( this: LoDashWrapper, iteratee?: ObjectIterator ): this; } //_.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( collection: T[], iteratee?: ArrayIterator ): T[]; /** * @see _.forEachRight */ forEachRight( collection: string, iteratee?: StringIterator ): string; /** * @see _.forEachRight */ forEachRight( collection: List, iteratee?: ListIterator ): List; /** * @see _.forEachRight */ forEachRight( collection: T, iteratee?: ObjectIterator ): T; /** * @see _.forEachRight */ forEachRight( collection: TArray & (T[] | null | undefined), iteratee?: ArrayIterator ): TArray; /** * @see _.forEachRight */ forEachRight( collection: TString, iteratee?: StringIterator ): TString; /** * @see _.forEachRight */ forEachRight | null | undefined>( collection: TList & (List | null | undefined), iteratee?: ListIterator ): TList; /** * @see _.forEachRight */ forEachRight( collection: T | null | undefined, iteratee?: ObjectIterator ): T | null | undefined; } interface LoDashWrapper { /** * @see _.forEachRight */ forEachRight( this: LoDashWrapper, iteratee?: ArrayIterator ): this; /** * @see _.forEachRight */ forEachRight( this: LoDashWrapper, iteratee?: StringIterator ): this; /** * @see _.forEachRight */ forEachRight( this: LoDashWrapper | null | undefined>, iteratee?: ListIterator ): this; /** * @see _.forEachRight */ forEachRight( this: LoDashWrapper, iteratee?: ObjectIterator ): this; } //_.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( collection: string | null | undefined, iteratee?: StringIterator ): Dictionary; /** * @see _.groupBy */ groupBy( collection: List | null | undefined, iteratee?: ListIteratee ): Dictionary; /** * @see _.groupBy */ groupBy( collection: NumericDictionary | null | undefined, iteratee?: NumericDictionaryIteratee ): Dictionary; /** * @see _.groupBy */ groupBy( collection: T | null | undefined, iteratee?: ObjectIteratee ): Dictionary>; } interface LoDashImplicitWrapper { /** * @see _.groupBy */ groupBy( this: LoDashImplicitWrapper, iteratee?: StringIterator ): LoDashImplicitWrapper>; /** * @see _.groupBy */ groupBy( this: LoDashImplicitWrapper | null | undefined>, iteratee?: ListIteratee ): LoDashImplicitWrapper>; /** * @see _.groupBy */ groupBy( this: LoDashImplicitWrapper, iteratee?: ObjectIteratee ): LoDashImplicitWrapper>>; /** * @see _.groupBy */ groupBy( this: LoDashImplicitWrapper | null | undefined>, iteratee?: NumericDictionaryIteratee ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.groupBy */ groupBy( this: LoDashExplicitWrapper, iteratee?: StringIterator ): LoDashExplicitWrapper>; /** * @see _.groupBy */ groupBy( this: LoDashExplicitWrapper | null | undefined>, iteratee?: ListIteratee ): LoDashExplicitWrapper>; /** * @see _.groupBy */ groupBy( this: LoDashExplicitWrapper | null | undefined>, iteratee?: NumericDictionaryIteratee ): LoDashExplicitWrapper>; /** * @see _.groupBy */ groupBy( this: LoDashExplicitWrapper, iteratee?: ObjectIteratee ): LoDashExplicitWrapper>>; } //_.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( collection: List|Dictionary | null | undefined, target: T, fromIndex?: number ): boolean; } interface LoDashImplicitWrapper { /** * @see _.includes */ includes( this: LoDashImplicitWrapper | Dictionary | null | undefined>, target: T, fromIndex?: number ): boolean; } interface LoDashExplicitWrapper { /** * @see _.includes */ includes( this: LoDashExplicitWrapper | Dictionary | null | undefined>, target: T, fromIndex?: number ): LoDashExplicitWrapper; } //_.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( collection: string | null | undefined, iteratee?: StringIterator ): Dictionary; /** * @see _.keyBy */ keyBy( collection: List | null | undefined, iteratee?: ListIterateeCustom ): Dictionary; /** * @see _.keyBy */ keyBy( collection: T | null | undefined, iteratee?: ObjectIterateeCustom ): Dictionary; /** * @see _.keyBy */ keyBy( collection: NumericDictionary | null | undefined, iteratee?: NumericDictionaryIterateeCustom ): Dictionary; } interface LoDashImplicitWrapper { /** * @see _.keyBy */ keyBy( this: LoDashImplicitWrapper, iteratee?: StringIterator ): LoDashImplicitWrapper>; /** * @see _.keyBy */ keyBy( this: LoDashImplicitWrapper | null | undefined>, iteratee?: ListIterateeCustom ): LoDashImplicitWrapper>; /** * @see _.keyBy */ keyBy( this: LoDashImplicitWrapper, iteratee?: ObjectIterateeCustom ): LoDashImplicitWrapper>; /** * @see _.keyBy */ keyBy( this: LoDashImplicitWrapper | null | undefined>, iteratee?: NumericDictionaryIterateeCustom ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.keyBy */ keyBy( this: LoDashExplicitWrapper, iteratee?: StringIterator ): LoDashExplicitWrapper>; /** * @see _.keyBy */ keyBy( this: LoDashExplicitWrapper | null | undefined>, iteratee?: ListIterateeCustom ): LoDashExplicitWrapper>; /** * @see _.keyBy */ keyBy( this: LoDashExplicitWrapper, iteratee?: ObjectIterateeCustom ): LoDashExplicitWrapper>; /** * @see _.keyBy */ keyBy( this: LoDashExplicitWrapper | null | undefined>, iteratee?: NumericDictionaryIterateeCustom ): LoDashExplicitWrapper>; } //_.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( object: any, path: PropertyPath, ...args: any[]): any; } interface LoDashImplicitWrapper { /** * @see _.invoke **/ invoke( path: PropertyPath, ...args: any[]): any; } interface LoDashExplicitWrapper { /** * @see _.invoke **/ invoke( path: PropertyPath, ...args: any[]): LoDashExplicitWrapper; } //_.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( collection: object | null | undefined, methodName: string, ...args: any[]): any[]; /** * @see _.invokeMap **/ invokeMap( collection: object | null | undefined, method: (...args: any[]) => TResult, ...args: any[]): TResult[]; } interface LoDashImplicitWrapper { /** * @see _.invokeMap **/ invokeMap( methodName: string, ...args: any[]): LoDashImplicitWrapper; /** * @see _.invokeMap **/ invokeMap( method: (...args: any[]) => TResult, ...args: any[]): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.invokeMap **/ invokeMap( methodName: string, ...args: any[]): LoDashExplicitWrapper; /** * @see _.invokeMap **/ invokeMap( method: (...args: any[]) => TResult, ...args: any[]): LoDashExplicitWrapper; } //_.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( collection: List | null | undefined, iteratee: ListIterator ): TResult[]; /** * @see _.map */ map(collection: List | Dictionary | null | undefined): T[]; /** * @see _.map */ map( collection: Dictionary | null | undefined, iteratee: DictionaryIterator ): TResult[]; /** @see _.map */ map( collection: List | Dictionary | null | undefined, iteratee: K ): Array; /** @see _.map */ map( collection: NumericDictionary | null | undefined, iteratee?: NumericDictionaryIterator ): TResult[]; /** * @see _.map */ map( collection: List|Dictionary|NumericDictionary | null | undefined, iteratee?: string ): TResult[]; /** * @see _.map */ map( collection: List|Dictionary|NumericDictionary | null | undefined, iteratee?: object ): boolean[]; } interface LoDashImplicitWrapper { /** * @see _.map */ map( this: LoDashImplicitWrapper | null | undefined>, iteratee: ListIterator ): LoDashImplicitWrapper; /** * @see _.map */ map(this: LoDashImplicitWrapper | Dictionary | null | undefined>): LoDashImplicitWrapper; /** * @see _.map */ map( this: LoDashImplicitWrapper | null | undefined>, iteratee: DictionaryIterator ): LoDashImplicitWrapper; /** @see _.map */ map( this: LoDashImplicitWrapper | Dictionary | null | undefined>, iteratee: K ): LoDashImplicitWrapper>; /** @see _.map */ map( this: LoDashImplicitWrapper | null | undefined>, iteratee?: NumericDictionaryIterator ): LoDashImplicitWrapper; /** * @see _.map */ map( this: LoDashImplicitWrapper | Dictionary | NumericDictionary | null | undefined>, iteratee?: string ): LoDashImplicitWrapper; /** * @see _.map */ map( this: LoDashImplicitWrapper | Dictionary | NumericDictionary | null | undefined>, iteratee?: object ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.map */ map( this: LoDashExplicitWrapper | null | undefined>, iteratee: ListIterator ): LoDashExplicitWrapper; /** * @see _.map */ map(this: LoDashExplicitWrapper | Dictionary | null | undefined>): LoDashExplicitWrapper; /** * @see _.map */ map( this: LoDashExplicitWrapper | null | undefined>, iteratee: DictionaryIterator ): LoDashExplicitWrapper; /** @see _.map */ map( this: LoDashExplicitWrapper | Dictionary | null | undefined>, iteratee: K ): LoDashExplicitWrapper>; /** * @see _.map */ map( this: LoDashExplicitWrapper | null | undefined>, iteratee?: NumericDictionaryIterator ): LoDashExplicitWrapper; /** * @see _.map */ map( this: LoDashExplicitWrapper | Dictionary | NumericDictionary | null | undefined>, iteratee?: string ): LoDashExplicitWrapper; /** * @see _.map */ map( this: LoDashExplicitWrapper | Dictionary | NumericDictionary | null | undefined>, iteratee?: object ): LoDashExplicitWrapper; } //_.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( collection: List | null | undefined, callback: ValueIteratee ): [T[], T[]]; /** * @see _.partition */ partition( collection: T | null | undefined, callback: ValueIteratee ): [Array, Array]; } interface LoDashImplicitWrapper { /** * @see _.partition */ partition( this: LoDashImplicitWrapper | null | undefined>, callback: ValueIteratee ): LoDashImplicitWrapper<[T[], T[]]>; /** * @see _.partition */ partition( this: LoDashImplicitWrapper, callback: ValueIteratee ): LoDashImplicitWrapper<[Array, Array]>; } interface LoDashExplicitWrapper { /** * @see _.partition */ partition( this: LoDashExplicitWrapper | null | undefined>, callback: ValueIteratee ): LoDashExplicitWrapper<[T[], T[]]>; /** * @see _.partition */ partition( this: LoDashExplicitWrapper, callback: ValueIteratee ): LoDashExplicitWrapper<[Array, Array]>; } //_.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. * @return Returns the accumulated value. **/ reduce( collection: T[] | null | undefined, callback: MemoListIterator, accumulator: TResult ): TResult; /** * @see _.reduce **/ reduce( collection: List | null | undefined, callback: MemoListIterator>, accumulator: TResult ): TResult; /** * @see _.reduce **/ reduce( collection: T | null | undefined, callback: MemoObjectIterator, accumulator: TResult ): TResult; /** * @see _.reduce **/ reduce( collection: NumericDictionary | null | undefined, callback: MemoListIterator>, accumulator: TResult ): TResult; /** * @see _.reduce **/ reduce( collection: T[] | null | undefined, callback: MemoListIterator ): TResult | undefined; /** * @see _.reduce **/ reduce( collection: List | null | undefined, callback: MemoListIterator> ): TResult | undefined; /** * @see _.reduce **/ reduce( collection: T | null | undefined, callback: MemoObjectIterator ): TResult | undefined; /** * @see _.reduce **/ reduce( collection: NumericDictionary | null | undefined, callback: MemoListIterator> ): TResult | undefined; } interface LoDashImplicitWrapper { /** * @see _.reduce **/ reduce( this: LoDashImplicitWrapper, callback: MemoListIterator, accumulator: TResult ): TResult; /** * @see _.reduce **/ reduce( this: LoDashImplicitWrapper | null | undefined>, callback: MemoListIterator>, accumulator: TResult ): TResult; /** * @see _.reduce **/ reduce( this: LoDashImplicitWrapper, callback: MemoObjectIterator, accumulator: TResult ): TResult; /** * @see _.reduce **/ reduce( this: LoDashImplicitWrapper | null | undefined>, callback: MemoListIterator>, accumulator: TResult ): TResult; /** * @see _.reduce **/ reduce( this: LoDashImplicitWrapper, callback: MemoListIterator ): TResult | undefined; /** * @see _.reduce **/ reduce( this: LoDashImplicitWrapper | null | undefined>, callback: MemoListIterator> ): TResult | undefined; /** * @see _.reduce **/ reduce( this: LoDashImplicitWrapper, callback: MemoObjectIterator ): TResult | undefined; /** * @see _.reduce **/ reduce( this: LoDashImplicitWrapper | null | undefined>, callback: MemoListIterator> ): TResult | undefined; } interface LoDashExplicitWrapper { /** * @see _.reduce **/ reduce( this: LoDashExplicitWrapper, callback: MemoListIterator, accumulator: TResult ): LoDashExplicitWrapper; /** * @see _.reduce **/ reduce( this: LoDashExplicitWrapper | null | undefined>, callback: MemoListIterator>, accumulator: TResult ): LoDashExplicitWrapper; /** * @see _.reduce **/ reduce( this: LoDashExplicitWrapper, callback: MemoObjectIterator, accumulator: TResult ): LoDashExplicitWrapper; /** * @see _.reduce **/ reduce( this: LoDashExplicitWrapper | null | undefined>, callback: MemoListIterator>, accumulator: TResult ): LoDashExplicitWrapper; /** * @see _.reduce **/ reduce( this: LoDashExplicitWrapper, callback: MemoListIterator ): LoDashExplicitWrapper; /** * @see _.reduce **/ reduce( this: LoDashExplicitWrapper | null | undefined>, callback: MemoListIterator> ): LoDashExplicitWrapper; /** * @see _.reduce **/ reduce( this: LoDashExplicitWrapper, callback: MemoObjectIterator ): LoDashExplicitWrapper; /** * @see _.reduce **/ reduce( this: LoDashExplicitWrapper | null | undefined>, callback: MemoListIterator> ): LoDashExplicitWrapper; } //_.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. * @return The accumulated value. **/ reduceRight( collection: T[] | null | undefined, callback: MemoListIterator, accumulator: TResult ): TResult; /** * @see _.reduceRight **/ reduceRight( collection: List | null | undefined, callback: MemoListIterator>, accumulator: TResult ): TResult; /** * @see _.reduceRight **/ reduceRight( collection: T | null | undefined, callback: MemoObjectIterator, accumulator: TResult ): TResult; /** * @see _.reduceRight **/ reduceRight( collection: NumericDictionary | null | undefined, callback: MemoListIterator>, accumulator: TResult ): TResult; /** * @see _.reduceRight **/ reduceRight( collection: T[] | null | undefined, callback: MemoListIterator ): TResult | undefined; /** * @see _.reduceRight **/ reduceRight( collection: List | null | undefined, callback: MemoListIterator> ): TResult | undefined; /** * @see _.reduceRight **/ reduceRight( collection: T | null | undefined, callback: MemoObjectIterator ): TResult | undefined; /** * @see _.reduceRight **/ reduceRight( collection: NumericDictionary | null | undefined, callback: MemoListIterator> ): TResult | undefined; } interface LoDashImplicitWrapper { /** * @see _.reduceRight **/ reduceRight( this: LoDashImplicitWrapper, callback: MemoListIterator, accumulator: TResult ): TResult; /** * @see _.reduceRight **/ reduceRight( this: LoDashImplicitWrapper | null | undefined>, callback: MemoListIterator>, accumulator: TResult ): TResult; /** * @see _.reduceRight **/ reduceRight( this: LoDashImplicitWrapper, callback: MemoObjectIterator, accumulator: TResult ): TResult; /** * @see _.reduceRight **/ reduceRight( this: LoDashImplicitWrapper | null | undefined>, callback: MemoListIterator>, accumulator: TResult ): TResult; /** * @see _.reduceRight **/ reduceRight( this: LoDashImplicitWrapper, callback: MemoListIterator ): TResult | undefined; /** * @see _.reduceRight **/ reduceRight( this: LoDashImplicitWrapper | null | undefined>, callback: MemoListIterator> ): TResult | undefined; /** * @see _.reduceRight **/ reduceRight( this: LoDashImplicitWrapper, callback: MemoObjectIterator ): TResult | undefined; /** * @see _.reduceRight **/ reduceRight( this: LoDashImplicitWrapper | null | undefined>, callback: MemoListIterator> ): TResult | undefined; } interface LoDashExplicitWrapper { /** * @see _.reduceRight **/ reduceRight( this: LoDashExplicitWrapper, callback: MemoListIterator, accumulator: TResult ): LoDashExplicitWrapper; /** * @see _.reduceRight **/ reduceRight( this: LoDashExplicitWrapper | null | undefined>, callback: MemoListIterator>, accumulator: TResult ): LoDashExplicitWrapper; /** * @see _.reduceRight **/ reduceRight( this: LoDashExplicitWrapper, callback: MemoObjectIterator, accumulator: TResult ): LoDashExplicitWrapper; /** * @see _.reduceRight **/ reduceRight( this: LoDashExplicitWrapper | null | undefined>, callback: MemoListIterator>, accumulator: TResult ): LoDashExplicitWrapper; /** * @see _.reduceRight **/ reduceRight( this: LoDashExplicitWrapper, callback: MemoListIterator ): LoDashExplicitWrapper; /** * @see _.reduceRight **/ reduceRight( this: LoDashExplicitWrapper | null | undefined>, callback: MemoListIterator> ): LoDashExplicitWrapper; /** * @see _.reduceRight **/ reduceRight( this: LoDashExplicitWrapper, callback: MemoObjectIterator ): LoDashExplicitWrapper; /** * @see _.reduceRight **/ reduceRight( this: LoDashExplicitWrapper | null | undefined>, callback: MemoListIterator> ): LoDashExplicitWrapper; } //_.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( collection: string | null | undefined, predicate?: StringIterator ): string[]; /** * @see _.reject */ reject( collection: List | null | undefined, predicate?: ListIterateeCustom ): T[]; /** * @see _.reject */ reject( collection: T | null | undefined, predicate?: ObjectIterateeCustom ): Array; } interface LoDashImplicitWrapper { /** * @see _.reject */ reject( this: LoDashImplicitWrapper, predicate?: StringIterator ): LoDashImplicitWrapper; /** * @see _.reject */ reject( this: LoDashImplicitWrapper | null | undefined>, predicate?: ListIterateeCustom ): LoDashImplicitWrapper; /** * @see _.reject */ reject( this: LoDashImplicitWrapper, predicate?: ObjectIterateeCustom ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.reject */ reject( this: LoDashExplicitWrapper, predicate?: StringIterator ): LoDashExplicitWrapper; /** * @see _.reject */ reject( this: LoDashExplicitWrapper | null | undefined>, predicate?: ListIterateeCustom ): LoDashExplicitWrapper; /** * @see _.reject */ reject( this: LoDashExplicitWrapper, predicate?: ObjectIterateeCustom ): LoDashExplicitWrapper>; } //_.sample interface LoDashStatic { /** * Gets a random element from collection. * * @param collection The collection to sample. * @return Returns the random element. */ sample( collection: List | Dictionary | NumericDictionary | null | undefined ): T | undefined; /** * @see _.sample */ sample( collection: T ): T[keyof T]; /** * @see _.sample */ sample( collection: T | null | undefined ): T[keyof T] | undefined; } interface LoDashImplicitWrapper { /** * @see _.sample */ sample( this: LoDashImplicitWrapper | Dictionary | NumericDictionary | null | undefined> ): T | undefined; /** * @see _.sample */ sample( this: LoDashImplicitWrapper, ): T[keyof T]; /** * @see _.sample */ sample( this: LoDashImplicitWrapper ): T[keyof T] | undefined; } interface LoDashExplicitWrapper { /** * @see _.sample */ sample( this: LoDashExplicitWrapper | Dictionary | NumericDictionary | null | undefined> ): LoDashExplicitWrapper; /** * @see _.sample */ sample( this: LoDashExplicitWrapper, ): LoDashExplicitWrapper; /** * @see _.sample */ sample( this: LoDashExplicitWrapper ): LoDashExplicitWrapper; } //_.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( collection: List|Dictionary|NumericDictionary | null | undefined, n?: number ): T[]; /** * @see _.sampleSize */ sampleSize( collection: T | null | undefined, n?: number ): Array; } interface LoDashImplicitWrapper { /** * @see _.sampleSize */ sampleSize( this: LoDashImplicitWrapper|Dictionary|NumericDictionary | null | undefined>, n?: number ): LoDashImplicitWrapper; /** * @see _.sampleSize */ sampleSize( this: LoDashImplicitWrapper, n?: number ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.sampleSize */ sampleSize( this: LoDashExplicitWrapper|Dictionary|NumericDictionary | null | undefined>, n?: number ): LoDashExplicitWrapper; /** * @see _.sampleSize */ sampleSize( this: LoDashExplicitWrapper, n?: number ): LoDashExplicitWrapper>; } //_.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(collection: List | null | undefined): T[]; /** * @see _.shuffle */ shuffle(collection: T | null | undefined): Array; } interface LoDashImplicitWrapper { /** * @see _.shuffle */ shuffle(this: LoDashImplicitWrapper | null | undefined>): LoDashImplicitWrapper; /** * @see _.shuffle */ shuffle(this: LoDashImplicitWrapper): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.shuffle */ shuffle(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; /** * @see _.shuffle */ shuffle(this: LoDashExplicitWrapper): LoDashExplicitWrapper>; } //_.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(collection: object | string | null | undefined): number; } interface LoDashImplicitWrapper { /** * @see _.size */ size(): number; } interface LoDashExplicitWrapper { /** * @see _.size */ size(): LoDashExplicitWrapper; } //_.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( collection: List | null | undefined, predicate?: ListIterateeCustom ): boolean; /** * @see _.some */ some( collection: T | null | undefined, predicate?: ObjectIterateeCustom ): boolean; /** * @see _.some */ some( collection: NumericDictionary | null | undefined, predicate?: NumericDictionaryIterateeCustom ): boolean; } interface LoDashImplicitWrapper { /** * @see _.some */ some( this: LoDashImplicitWrapper | null | undefined>, predicate?: ListIterateeCustom ): boolean; /** * @see _.some */ some( this: LoDashImplicitWrapper, predicate?: ObjectIterateeCustom ): boolean; /** * @see _.some */ some( this: LoDashImplicitWrapper | null | undefined>, predicate?: NumericDictionaryIterateeCustom ): boolean; } interface LoDashExplicitWrapper { /** * @see _.some */ some( this: LoDashExplicitWrapper | null | undefined>, predicate?: ListIterateeCustom ): LoDashExplicitWrapper; /** * @see _.some */ some( this: LoDashExplicitWrapper, predicate?: ObjectIterateeCustom ): LoDashExplicitWrapper; /** * @see _.some */ some( this: LoDashExplicitWrapper | null | undefined>, predicate?: NumericDictionaryIterateeCustom ): LoDashExplicitWrapper; } //_.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). * * @category Collection * @param collection The collection to iterate over. * @param [iteratees=[_.identity]] * The iteratees to sort by, specified individually or in arrays. * @returns 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( collection: List | null | undefined, ...iteratees: Array>> ): T[]; /** * @see _.sortBy */ sortBy( collection: T | null | undefined, ...iteratees: Array>> ): Array; } interface LoDashImplicitWrapper { /** * @see _.sortBy */ sortBy( this: LoDashImplicitWrapper | null | undefined>, ...iteratees: Array>> ): LoDashImplicitWrapper; /** * @see _.sortBy */ sortBy( this: LoDashImplicitWrapper, ...iteratees: Array>> ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.sortBy */ sortBy( this: LoDashExplicitWrapper | null | undefined>, ...iteratees: Array>> ): LoDashExplicitWrapper; /** * @see _.sortBy */ sortBy( this: LoDashExplicitWrapper, ...iteratees: Array>> ): LoDashExplicitWrapper>; } //_.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. * * @category Collection * @param collection The collection to iterate over. * @param [iteratees=[_.identity]] The iteratees to sort by. * @param [orders] The sort orders of `iteratees`. * @param- {Object} [guard] Enables use as an iteratee for functions like `_.reduce`. * @returns 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( collection: List | null | undefined, iteratees?: Many>, orders?: Many ): T[]; /** * @see _.orderBy */ orderBy( collection: List | null | undefined, iteratees?: Many>, orders?: Many ): T[]; /** * @see _.orderBy */ orderBy( collection: T | null | undefined, iteratees?: Many>, orders?: Many ): Array; /** * @see _.orderBy */ orderBy( collection: T | null | undefined, iteratees?: Many>, orders?: Many ): Array; /** * @see _.orderBy */ orderBy( collection: NumericDictionary | null | undefined, iteratees?: Many>, orders?: Many ): T[]; /** * @see _.orderBy */ orderBy( collection: NumericDictionary | null | undefined, iteratees?: Many>, orders?: Many ): T[]; } interface LoDashImplicitWrapper { /** * @see _.orderBy */ orderBy( this: LoDashImplicitWrapper | null | undefined>, iteratees?: Many>, orders?: Many ): LoDashImplicitWrapper; /** * @see _.orderBy */ orderBy( this: LoDashImplicitWrapper | null | undefined>, iteratees?: Many>, orders?: Many ): LoDashImplicitWrapper; /** * @see _.orderBy */ orderBy( this: LoDashImplicitWrapper, iteratees?: Many>, orders?: Many ): LoDashImplicitWrapper>; /** * @see _.orderBy */ orderBy( this: LoDashImplicitWrapper, iteratees?: Many>, orders?: Many ): LoDashImplicitWrapper>; /** * @see _.orderBy */ orderBy( this: LoDashImplicitWrapper | null | undefined>, iteratees?: Many>, orders?: Many ): LoDashImplicitWrapper; /** * @see _.orderBy */ orderBy( this: LoDashImplicitWrapper | null | undefined>, iteratees?: Many>, orders?: Many ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.orderBy */ orderBy( this: LoDashExplicitWrapper | null | undefined>, iteratees?: Many>, orders?: Many ): LoDashExplicitWrapper; /** * @see _.orderBy */ orderBy( this: LoDashExplicitWrapper | null | undefined>, iteratees?: Many>, orders?: Many ): LoDashExplicitWrapper; /** * @see _.orderBy */ orderBy( this: LoDashExplicitWrapper, iteratees?: Many>, orders?: Many ): LoDashExplicitWrapper>; /** * @see _.orderBy */ orderBy( this: LoDashExplicitWrapper, iteratees?: Many>, orders?: Many ): LoDashExplicitWrapper>; /** * @see _.orderBy */ orderBy( this: LoDashExplicitWrapper | null | undefined>, iteratees?: Many>, orders?: Many ): LoDashExplicitWrapper; /** * @see _.orderBy */ orderBy( this: LoDashExplicitWrapper | null | undefined>, iteratees?: Many>, orders?: Many ): LoDashExplicitWrapper; } /******** * 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 LoDashImplicitWrapper { /** * @see _.now */ now(): number; } interface LoDashExplicitWrapper { /** * @see _.now */ now(): LoDashExplicitWrapper; } /************* * 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 any>( n: number, func: TFunc ): TFunc; } interface LoDashImplicitWrapper { /** * @see _.after **/ after any>(func: TFunc): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.after **/ after any>(func: TFunc): LoDashExplicitWrapper; } //_.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( func: (...args: any[]) => any, n?: number ): (...args: any[]) => any; } interface LoDashImplicitWrapper { /** * @see _.ary */ ary(n?: number): LoDashImplicitWrapper<(...args: any[]) => any>; } interface LoDashExplicitWrapper { /** * @see _.ary */ ary(n?: number): LoDashExplicitWrapper<(...args: any[]) => any>; } //_.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 any>( n: number, func: TFunc ): TFunc; } interface LoDashImplicitWrapper { /** * @see _.before **/ before any>(func: TFunc): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.before **/ before any>(func: TFunc): LoDashExplicitWrapper; } //_.bind interface FunctionBind { placeholder: any; ( func: (...args: any[]) => any, thisArg: any, ...partials: any[] ): (...args: any[]) => any; } 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 LoDashImplicitWrapper { /** * @see _.bind */ bind( thisArg: any, ...partials: any[] ): LoDashImplicitWrapper<(...args: any[]) => any>; } interface LoDashExplicitWrapper { /** * @see _.bind */ bind( thisArg: any, ...partials: any[] ): LoDashExplicitWrapper<(...args: any[]) => any>; } //_.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( object: T, ...methodNames: Array> ): T; } interface LoDashWrapper { /** * @see _.bindAll */ bindAll(...methodNames: Array>): this; } //_.bindKey interface FunctionBindKey { placeholder: any; ( object: object, key: string, ...partials: any[] ): (...args: any[]) => any; } 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 LoDashImplicitWrapper { /** * @see _.bindKey */ bindKey( key: string, ...partials: any[] ): LoDashImplicitWrapper<(...args: any[]) => any>; } interface LoDashExplicitWrapper { /** * @see _.bindKey */ bindKey( key: string, ...partials: any[] ): LoDashExplicitWrapper<(...args: any[]) => 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. * @param arity The arity of func. * @return Returns the new curried function. */ curry(func: (t1: T1) => R, arity?: number): CurriedFunction1; /** * 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(func: (t1: T1, t2: T2) => R, arity?: number): CurriedFunction2; /** * 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(func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): CurriedFunction3; /** * 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(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): CurriedFunction4; /** * 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(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): CurriedFunction5; /** * 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(func: (...args: any[]) => any, arity?: number): (...args: any[]) => any; } interface CurriedFunction1 { (): CurriedFunction1; (t1: T1): R; } interface CurriedFunction2 { (): CurriedFunction2; (t1: T1): CurriedFunction1; (t1: T1, t2: T2): R; } interface CurriedFunction3 { (): CurriedFunction3; (t1: T1): CurriedFunction2; (t1: T1, t2: T2): CurriedFunction1; (t1: T1, t2: T2, t3: T3): R; } interface CurriedFunction4 { (): CurriedFunction4; (t1: T1): CurriedFunction3; (t1: T1, t2: T2): CurriedFunction2; (t1: T1, t2: T2, t3: T3): CurriedFunction1; (t1: T1, t2: T2, t3: T3, t4: T4): R; } interface CurriedFunction5 { (): CurriedFunction5; (t1: T1): CurriedFunction4; (t1: T1, t2: T2): CurriedFunction3; (t1: T1, t2: T2, t3: T3): CurriedFunction2; (t1: T1, t2: T2, t3: T3, t4: T4): CurriedFunction1; (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; } interface RightCurriedFunction1 { (): RightCurriedFunction1; (t1: T1): R; } interface RightCurriedFunction2 { (): RightCurriedFunction2; (t2: T2): RightCurriedFunction1; (t1: T1, t2: T2): R; } interface RightCurriedFunction3 { (): RightCurriedFunction3; (t3: T3): RightCurriedFunction2; (t2: T2, t3: T3): RightCurriedFunction1; (t1: T1, t2: T2, t3: T3): R; } interface RightCurriedFunction4 { (): RightCurriedFunction4; (t4: T4): RightCurriedFunction3; (t3: T3, t4: T4): RightCurriedFunction2; (t2: T2, t3: T3, t4: T4): RightCurriedFunction1; (t1: T1, t2: T2, t3: T3, t4: T4): R; } interface RightCurriedFunction5 { (): RightCurriedFunction5; (t5: T5): RightCurriedFunction4; (t4: T4, t5: T5): RightCurriedFunction3; (t3: T3, t4: T4, t5: T5): RightCurriedFunction2; (t2: T2, t3: T3, t4: T4, t5: T5): RightCurriedFunction1; (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; } interface LoDashImplicitWrapper { /** * @see _.curry **/ curry(this: LoDashImplicitWrapper<(t1: T1) => R>, arity?: number): LoDashImplicitWrapper>; /** * @see _.curry **/ curry(this: LoDashImplicitWrapper<(t1: T1, t2: T2) => R>, arity?: number): LoDashImplicitWrapper>; /** * @see _.curry **/ curry(this: LoDashImplicitWrapper<(t1: T1, t2: T2, t3: T3) => R>, arity?: number): LoDashImplicitWrapper>; /** * @see _.curry **/ curry(this: LoDashImplicitWrapper<(t1: T1, t2: T2, t3: T3, t4: T4) => R>, arity?: number): LoDashImplicitWrapper>; /** * @see _.curry **/ curry(this: LoDashImplicitWrapper<(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R>, arity?: number): LoDashImplicitWrapper>; /** * @see _.curry **/ curry(arity?: number): LoDashImplicitWrapper<(...args: any[]) => any>; } interface LoDashExplicitWrapper { /** * @see _.curry **/ curry(this: LoDashExplicitWrapper<(t1: T1) => R>): LoDashExplicitWrapper>; /** * @see _.curry **/ curry(this: LoDashExplicitWrapper<(t1: T1, t2: T2) => R>): LoDashExplicitWrapper>; /** * @see _.curry **/ curry(this: LoDashExplicitWrapper<(t1: T1, t2: T2, t3: T3) => R>): LoDashExplicitWrapper>; /** * @see _.curry **/ curry(this: LoDashExplicitWrapper<(t1: T1, t2: T2, t3: T3, t4: T4) => R>): LoDashExplicitWrapper>; /** * @see _.curry **/ curry(this: LoDashExplicitWrapper<(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R>): LoDashExplicitWrapper>; /** * @see _.curry **/ curry(arity?: number): LoDashExplicitWrapper<(...args: any[]) => any>; } //_.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. * @param arity The arity of func. * @return Returns the new curried function. */ curryRight(func: (t1: T1) => R, arity?: number): RightCurriedFunction1; /** * 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(func: (t1: T1, t2: T2) => R, arity?: number): RightCurriedFunction2; /** * 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(func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): RightCurriedFunction3; /** * 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(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): RightCurriedFunction4; /** * 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(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): RightCurriedFunction5; /** * 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(func: (...args: any[]) => any, arity?: number): (...args: any[]) => any; } interface LoDashImplicitWrapper { /** * @see _.curryRight **/ curryRight(this: LoDashImplicitWrapper<(t1: T1) => R>, arity?: number): LoDashImplicitWrapper>; /** * @see _.curryRight **/ curryRight(this: LoDashImplicitWrapper<(t1: T1, t2: T2) => R>, arity?: number): LoDashImplicitWrapper>; /** * @see _.curryRight **/ curryRight(this: LoDashImplicitWrapper<(t1: T1, t2: T2, t3: T3) => R>, arity?: number): LoDashImplicitWrapper>; /** * @see _.curryRight **/ curryRight(this: LoDashImplicitWrapper<(t1: T1, t2: T2, t3: T3, t4: T4) => R>, arity?: number): LoDashImplicitWrapper>; /** * @see _.curryRight **/ curryRight(this: LoDashImplicitWrapper<(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R>, arity?: number): LoDashImplicitWrapper>; /** * @see _.curryRight **/ curryRight(arity?: number): LoDashImplicitWrapper<(...args: any[]) => any>; } interface LoDashExplicitWrapper { /** * @see _.curryRight **/ curryRight(this: LoDashExplicitWrapper<(t1: T1) => R>, arity?: number): LoDashExplicitWrapper>; /** * @see _.curryRight **/ curryRight(this: LoDashExplicitWrapper<(t1: T1, t2: T2) => R>, arity?: number): LoDashExplicitWrapper>; /** * @see _.curryRight **/ curryRight(this: LoDashExplicitWrapper<(t1: T1, t2: T2, t3: T3) => R>, arity?: number): LoDashExplicitWrapper>; /** * @see _.curryRight **/ curryRight(this: LoDashExplicitWrapper<(t1: T1, t2: T2, t3: T3, t4: T4) => R>, arity?: number): LoDashExplicitWrapper>; /** * @see _.curryRight **/ curryRight(this: LoDashExplicitWrapper<(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R>, arity?: number): LoDashExplicitWrapper>; /** * @see _.curryRight **/ curryRight(arity?: number): LoDashExplicitWrapper<(...args: any[]) => any>; } //_.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 any>( func: T, wait?: number, options?: DebounceSettings ): T & Cancelable; } interface LoDashImplicitWrapper { /** * @see _.debounce */ debounce( wait?: number, options?: DebounceSettings ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.debounce */ debounce( wait?: number, options?: DebounceSettings ): LoDashExplicitWrapper; } //_.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( func: (...args: any[]) => any, ...args: any[] ): number; } interface LoDashImplicitWrapper { /** * @see _.defer */ defer(...args: any[]): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.defer */ defer(...args: any[]): LoDashExplicitWrapper; } //_.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( func: (...args: any[]) => any, wait: number, ...args: any[] ): number; } interface LoDashImplicitWrapper { /** * @see _.delay */ delay( wait: number, ...args: any[] ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.delay */ delay( wait: number, ...args: any[] ): LoDashExplicitWrapper; } interface LoDashStatic { /** * Creates a function that invokes `func` with arguments reversed. * * @category Function * @param func The function to flip arguments for. * @returns Returns the new function. * @example * * var flipped = _.flip(function() { * return _.toArray(arguments); * }); * * flipped('a', 'b', 'c', 'd'); * // => ['d', 'c', 'b', 'a'] */ flip any>(func: T): T; } interface LoDashWrapper { /** * @see _.flip */ flip(): this; } //_.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. */ // 0-argument first function flow(f1: () => R1, f2: (a: R1) => R2): () => R2; flow(f1: () => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): () => R3; flow(f1: () => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): () => R4; flow(f1: () => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): () => R5; flow(f1: () => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): () => R6; flow(f1: () => 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): () => R7; flow(f1: () => 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, ...funcs: Array any>>): () => any; // 1-argument first function flow(f1: (a1: A1) => R1, f2: (a: R1) => R2): (a1: A1) => R2; flow(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1) => R3; flow(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (a1: A1) => R4; flow(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (a1: A1) => R5; flow(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(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; flow(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, ...funcs: Array any>>): (a1: A1) => any; // 2-argument first function flow(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2): (a1: A1, a2: A2) => R2; flow(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1, a2: A2) => R3; flow(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (a1: A1, a2: A2) => R4; flow(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(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(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; flow(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, ...funcs: Array any>>): (a1: A1, a2: A2) => any; // 3-argument first function flow(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2): (a1: A1, a2: A2, a3: A3) => R2; flow(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1, a2: A2, a3: A3) => R3; flow(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(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(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(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; flow(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, ...funcs: Array any>>): (a1: A1, a2: A2, a3: A3) => any; // 4-argument first function flow(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2): (a1: A1, a2: A2, a3: A3, a4: A4) => R2; flow(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(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(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(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(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; flow(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, ...funcs: Array any>>): (a1: A1, a2: A2, a3: A3, a4: A4) => any; // any-argument first function flow(f1: (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1, f2: (a: R1) => R2): (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R2; flow(f1: (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R3; flow(f1: (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R4; flow(f1: (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => 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, ...args: any[]) => R5; flow(f1: (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => 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, ...args: any[]) => R6; flow(f1: (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => 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, ...args: any[]) => R7; flow(f1: (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => 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, ...funcs: Array any>>): (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => any; flow(funcs: Array any>>): (...args: any[]) => any; } interface LoDashImplicitWrapper { /** * @see _.flow */ // 0-argument first function flow(this: LoDashImplicitWrapper<() => R1>, f2: (a: R1) => R2): LoDashImplicitWrapper<() => R2>; flow(this: LoDashImplicitWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashImplicitWrapper<() => R3>; flow(this: LoDashImplicitWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashImplicitWrapper<() => R4>; flow(this: LoDashImplicitWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashImplicitWrapper<() => R5>; flow(this: LoDashImplicitWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashImplicitWrapper<() => R6>; flow(this: LoDashImplicitWrapper<() => 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): LoDashImplicitWrapper<() => R7>; flow(this: LoDashImplicitWrapper<() => 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, ...funcs: Array any>>): LoDashImplicitWrapper<() => any>; // 1-argument first function flow(this: LoDashImplicitWrapper<(a1: A1) => R1>, f2: (a: R1) => R2): LoDashImplicitWrapper<(a1: A1) => R2>; flow(this: LoDashImplicitWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashImplicitWrapper<(a1: A1) => R3>; flow(this: LoDashImplicitWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashImplicitWrapper<(a1: A1) => R4>; flow(this: LoDashImplicitWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashImplicitWrapper<(a1: A1) => R5>; flow(this: LoDashImplicitWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashImplicitWrapper<(a1: A1) => R6>; flow(this: LoDashImplicitWrapper<(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): LoDashImplicitWrapper<(a1: A1) => R7>; flow(this: LoDashImplicitWrapper<(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, ...funcs: Array any>>): LoDashImplicitWrapper<(a1: A1) => any>; // 2-argument first function flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2): LoDashImplicitWrapper<(a1: A1, a2: A2) => R2>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashImplicitWrapper<(a1: A1, a2: A2) => R3>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashImplicitWrapper<(a1: A1, a2: A2) => R4>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashImplicitWrapper<(a1: A1, a2: A2) => R5>; flow(this: LoDashImplicitWrapper<(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): LoDashImplicitWrapper<(a1: A1, a2: A2) => R6>; flow(this: LoDashImplicitWrapper<(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): LoDashImplicitWrapper<(a1: A1, a2: A2) => R7>; flow(this: LoDashImplicitWrapper<(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, ...funcs: Array any>>): LoDashImplicitWrapper<(a1: A1, a2: A2) => any>; // 3-argument first function flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R2>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R3>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R4>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R5>; flow(this: LoDashImplicitWrapper<(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): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R6>; flow(this: LoDashImplicitWrapper<(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): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R7>; flow(this: LoDashImplicitWrapper<(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, ...funcs: Array any>>): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => any>; // 4-argument first function flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R2>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R3>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R4>; flow(this: LoDashImplicitWrapper<(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): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R5>; flow(this: LoDashImplicitWrapper<(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): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R6>; flow(this: LoDashImplicitWrapper<(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): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R7>; flow(this: LoDashImplicitWrapper<(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, ...funcs: Array any>>): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => any>; // any-argument first function flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R2>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R3>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R4>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R5>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R6>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => 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): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R7>; flow(this: LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => 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, ...funcs: Array any>>): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => any>; flow(this: LoDashImplicitWrapper<(...args: any[]) => any>, funcs: Array any>>): LoDashImplicitWrapper<(...args: any[]) => any>; } interface LoDashExplicitWrapper { /** * @see _.flow */ // 0-argument first function flow(this: LoDashExplicitWrapper<() => R1>, f2: (a: R1) => R2): LoDashExplicitWrapper<() => R2>; flow(this: LoDashExplicitWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitWrapper<() => R3>; flow(this: LoDashExplicitWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitWrapper<() => R4>; flow(this: LoDashExplicitWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitWrapper<() => R5>; flow(this: LoDashExplicitWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitWrapper<() => R6>; flow(this: LoDashExplicitWrapper<() => 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): LoDashExplicitWrapper<() => R7>; flow(this: LoDashExplicitWrapper<() => 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, ...funcs: Array any>>): LoDashExplicitWrapper<() => any>; // 1-argument first function flow(this: LoDashExplicitWrapper<(a1: A1) => R1>, f2: (a: R1) => R2): LoDashExplicitWrapper<(a1: A1) => R2>; flow(this: LoDashExplicitWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitWrapper<(a1: A1) => R3>; flow(this: LoDashExplicitWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitWrapper<(a1: A1) => R4>; flow(this: LoDashExplicitWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitWrapper<(a1: A1) => R5>; flow(this: LoDashExplicitWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitWrapper<(a1: A1) => R6>; flow(this: LoDashExplicitWrapper<(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): LoDashExplicitWrapper<(a1: A1) => R7>; flow(this: LoDashExplicitWrapper<(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, ...funcs: Array any>>): LoDashExplicitWrapper<(a1: A1) => any>; // 2-argument first function flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2): LoDashExplicitWrapper<(a1: A1, a2: A2) => R2>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitWrapper<(a1: A1, a2: A2) => R3>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitWrapper<(a1: A1, a2: A2) => R4>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitWrapper<(a1: A1, a2: A2) => R5>; flow(this: LoDashExplicitWrapper<(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): LoDashExplicitWrapper<(a1: A1, a2: A2) => R6>; flow(this: LoDashExplicitWrapper<(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): LoDashExplicitWrapper<(a1: A1, a2: A2) => R7>; flow(this: LoDashExplicitWrapper<(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, ...funcs: Array any>>): LoDashExplicitWrapper<(a1: A1, a2: A2) => any>; // 3-argument first function flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R2>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R3>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R4>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R5>; flow(this: LoDashExplicitWrapper<(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): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R6>; flow(this: LoDashExplicitWrapper<(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): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R7>; flow(this: LoDashExplicitWrapper<(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, ...funcs: Array any>>): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => any>; // 4-argument first function flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R2>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R3>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R4>; flow(this: LoDashExplicitWrapper<(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): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R5>; flow(this: LoDashExplicitWrapper<(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): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R6>; flow(this: LoDashExplicitWrapper<(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): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R7>; flow(this: LoDashExplicitWrapper<(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, ...funcs: Array any>>): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => any>; // any-argument first function flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R2>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R3>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R4>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R5>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R6>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => 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): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R7>; flow(this: LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => 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, ...funcs: Array any>>): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => any>; flow(this: LoDashExplicitWrapper<(...args: any[]) => any>, funcs: Array any>>): LoDashExplicitWrapper<(...args: any[]) => any>; } //_.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. */ // 0-argument first function flowRight(f2: (a: R1) => R2, f1: () => R1): () => R2; flowRight(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): () => R3; flowRight(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): () => R4; flowRight(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): () => R5; flowRight(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): () => R6; flowRight(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): () => R7; // 1-argument first function flowRight(f2: (a: R1) => R2, f1: (a1: A1) => R1): (a1: A1) => R2; flowRight(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): (a1: A1) => R3; flowRight(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): (a1: A1) => R4; flowRight(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): (a1: A1) => R5; flowRight(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): (a1: A1) => R6; flowRight(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): (a1: A1) => R7; // 2-argument first function flowRight(f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): (a1: A1, a2: A2) => R2; flowRight(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): (a1: A1, a2: A2) => R3; flowRight(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): (a1: A1, a2: A2) => R4; flowRight(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): (a1: A1, a2: A2) => R5; flowRight(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): (a1: A1, a2: A2) => R6; flowRight(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): (a1: A1, a2: A2) => R7; // 3-argument first function flowRight(f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): (a1: A1, a2: A2, a3: A3) => R2; flowRight(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): (a1: A1, a2: A2, a3: A3) => R3; flowRight(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): (a1: A1, a2: A2, a3: A3) => R4; flowRight(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): (a1: A1, a2: A2, a3: A3) => R5; flowRight(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): (a1: A1, a2: A2, a3: A3) => R6; flowRight(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): (a1: A1, a2: A2, a3: A3) => R7; // 4-argument first function flowRight(f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): (a1: A1, a2: A2, a3: A3, a4: A4) => R2; flowRight(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): (a1: A1, a2: A2, a3: A3, a4: A4) => R3; flowRight(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): (a1: A1, a2: A2, a3: A3, a4: A4) => R4; flowRight(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): (a1: A1, a2: A2, a3: A3, a4: A4) => R5; flowRight(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): (a1: A1, a2: A2, a3: A3, a4: A4) => R6; flowRight(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): (a1: A1, a2: A2, a3: A3, a4: A4) => R7; // any-argument first function flowRight(f2: (a: R1) => R2, f1: (...args: any[]) => R1): (...args: any[]) => R2; flowRight(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): (...args: any[]) => R3; flowRight(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): (...args: any[]) => R4; flowRight(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): (...args: any[]) => R5; flowRight(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): (...args: any[]) => R6; flowRight(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): (...args: any[]) => R7; flowRight(f7: (a: any) => any, f6: (a: any) => any, f5: (a: any) => any, f4: (a: any) => any, f3: (a: any) => any, f2: (a: any) => any, f1: () => any, ...funcs: Array any>>): (...args: any[]) => any; flowRight(funcs: Array any>>): (...args: any[]) => any; } interface LoDashImplicitWrapper { /** * @see _.flowRight */ // 0-argument first function flowRight(this: LoDashImplicitWrapper<(a: R1) => R2>, f1: () => R1): LoDashImplicitWrapper<() => R2>; flowRight(this: LoDashImplicitWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: () => R1): LoDashImplicitWrapper<() => R3>; flowRight(this: LoDashImplicitWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashImplicitWrapper<() => R4>; flowRight(this: LoDashImplicitWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashImplicitWrapper<() => R5>; flowRight(this: LoDashImplicitWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashImplicitWrapper<() => R6>; flowRight(this: LoDashImplicitWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashImplicitWrapper<() => R7>; // 1-argument first function flowRight(this: LoDashImplicitWrapper<(a: R1) => R2>, f1: (a1: A1) => R1): LoDashImplicitWrapper<(a1: A1) => R2>; flowRight(this: LoDashImplicitWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashImplicitWrapper<(a1: A1) => R3>; flowRight(this: LoDashImplicitWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashImplicitWrapper<(a1: A1) => R4>; flowRight(this: LoDashImplicitWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashImplicitWrapper<(a1: A1) => R5>; flowRight(this: LoDashImplicitWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashImplicitWrapper<(a1: A1) => R6>; flowRight(this: LoDashImplicitWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashImplicitWrapper<(a1: A1) => R7>; // 2-argument first function flowRight(this: LoDashImplicitWrapper<(a: R1) => R2>, f1: (a1: A1, a2: A2) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2) => R2>; flowRight(this: LoDashImplicitWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2) => R3>; flowRight(this: LoDashImplicitWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2) => R4>; flowRight(this: LoDashImplicitWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2) => R5>; flowRight(this: LoDashImplicitWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2) => R6>; flowRight(this: LoDashImplicitWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2) => R7>; // 3-argument first function flowRight(this: LoDashImplicitWrapper<(a: R1) => R2>, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R2>; flowRight(this: LoDashImplicitWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R3>; flowRight(this: LoDashImplicitWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R4>; flowRight(this: LoDashImplicitWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R5>; flowRight(this: LoDashImplicitWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R6>; flowRight(this: LoDashImplicitWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3) => R7>; // 4-argument first function flowRight(this: LoDashImplicitWrapper<(a: R1) => R2>, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R2>; flowRight(this: LoDashImplicitWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R3>; flowRight(this: LoDashImplicitWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R4>; flowRight(this: LoDashImplicitWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R5>; flowRight(this: LoDashImplicitWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R6>; flowRight(this: LoDashImplicitWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashImplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R7>; // any-argument first function flowRight(this: LoDashImplicitWrapper<(a: R1) => R2>, f1: (...args: any[]) => R1): LoDashImplicitWrapper<(...args: any[]) => R2>; flowRight(this: LoDashImplicitWrapper<(a: R1) => R2>, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashImplicitWrapper<(...args: any[]) => R3>; flowRight(this: LoDashImplicitWrapper<(a: R1) => R2>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashImplicitWrapper<(...args: any[]) => R4>; flowRight(this: LoDashImplicitWrapper<(a: R1) => R2>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashImplicitWrapper<(...args: any[]) => R5>; flowRight(this: LoDashImplicitWrapper<(a: R1) => R2>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashImplicitWrapper<(...args: any[]) => R6>; flowRight(this: LoDashImplicitWrapper<(a: R1) => R2>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashImplicitWrapper<(...args: any[]) => R7>; flowRight(this: LoDashImplicitWrapper<(a: any) => any>, f6: (a: any) => any, f5: (a: any) => any, f4: (a: any) => any, f3: (a: any) => any, f2: (a: any) => any, f1: () => any, ...funcs: Array any>>): LoDashImplicitWrapper<(...args: any[]) => any>; flowRight(this: LoDashImplicitWrapper<(a: any) => any>, funcs: Array any>>): LoDashImplicitWrapper<(...args: any[]) => any>; } interface LoDashExplicitWrapper { /** * @see _.flowRight */ // 0-argument first function flowRight(this: LoDashExplicitWrapper<(a: R1) => R2>, f1: () => R1): LoDashExplicitWrapper<() => R2>; flowRight(this: LoDashExplicitWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitWrapper<() => R3>; flowRight(this: LoDashExplicitWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitWrapper<() => R4>; flowRight(this: LoDashExplicitWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitWrapper<() => R5>; flowRight(this: LoDashExplicitWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitWrapper<() => R6>; flowRight(this: LoDashExplicitWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitWrapper<() => R7>; // 1-argument first function flowRight(this: LoDashExplicitWrapper<(a: R1) => R2>, f1: (a1: A1) => R1): LoDashExplicitWrapper<(a1: A1) => R2>; flowRight(this: LoDashExplicitWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitWrapper<(a1: A1) => R3>; flowRight(this: LoDashExplicitWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitWrapper<(a1: A1) => R4>; flowRight(this: LoDashExplicitWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitWrapper<(a1: A1) => R5>; flowRight(this: LoDashExplicitWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitWrapper<(a1: A1) => R6>; flowRight(this: LoDashExplicitWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitWrapper<(a1: A1) => R7>; // 2-argument first function flowRight(this: LoDashExplicitWrapper<(a: R1) => R2>, f1: (a1: A1, a2: A2) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2) => R2>; flowRight(this: LoDashExplicitWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2) => R3>; flowRight(this: LoDashExplicitWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2) => R4>; flowRight(this: LoDashExplicitWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2) => R5>; flowRight(this: LoDashExplicitWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2) => R6>; flowRight(this: LoDashExplicitWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2) => R7>; // 3-argument first function flowRight(this: LoDashExplicitWrapper<(a: R1) => R2>, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R2>; flowRight(this: LoDashExplicitWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R3>; flowRight(this: LoDashExplicitWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R4>; flowRight(this: LoDashExplicitWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R5>; flowRight(this: LoDashExplicitWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R6>; flowRight(this: LoDashExplicitWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3) => R7>; // 4-argument first function flowRight(this: LoDashExplicitWrapper<(a: R1) => R2>, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R2>; flowRight(this: LoDashExplicitWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R3>; flowRight(this: LoDashExplicitWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R4>; flowRight(this: LoDashExplicitWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R5>; flowRight(this: LoDashExplicitWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R6>; flowRight(this: LoDashExplicitWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R7>; // any-argument first function flowRight(this: LoDashExplicitWrapper<(a: R1) => R2>, f1: (...args: any[]) => R1): LoDashExplicitWrapper<(...args: any[]) => R2>; flowRight(this: LoDashExplicitWrapper<(a: R1) => R2>, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitWrapper<(...args: any[]) => R3>; flowRight(this: LoDashExplicitWrapper<(a: R1) => R2>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitWrapper<(...args: any[]) => R4>; flowRight(this: LoDashExplicitWrapper<(a: R1) => R2>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitWrapper<(...args: any[]) => R5>; flowRight(this: LoDashExplicitWrapper<(a: R1) => R2>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitWrapper<(...args: any[]) => R6>; flowRight(this: LoDashExplicitWrapper<(a: R1) => R2>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitWrapper<(...args: any[]) => R7>; flowRight(this: LoDashExplicitWrapper<(a: any) => any>, f6: (a: any) => any, f5: (a: any) => any, f4: (a: any) => any, f3: (a: any) => any, f2: (a: any) => any, f1: () => any, ...funcs: Array any>>): LoDashExplicitWrapper<(...args: any[]) => any>; flowRight(this: LoDashExplicitWrapper<(a: any) => any>, funcs: Array any>>): LoDashExplicitWrapper<(...args: any[]) => any>; } //_.memoize interface MemoizedFunction { 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: { any>(func: T, resolver?: (...args: any[]) => any): T & MemoizedFunction; Cache: MapCacheConstructor; }; } interface LoDashImplicitWrapper { /** * @see _.memoize */ memoize(resolver?: (...args: any[]) => any): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.memoize */ memoize(resolver?: (...args: any[]) => any): LoDashExplicitWrapper; } //_.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( func: (...args: any[]) => any, ...transforms: Array any>> ): (...args: any[]) => any; } interface LoDashImplicitWrapper { /** * @see _.overArgs */ overArgs(...transforms: Array any>>): LoDashImplicitWrapper<(...args: any[]) => any>; } interface LoDashExplicitWrapper { /** * @see _.overArgs */ overArgs(...transforms: Array any>>): LoDashExplicitWrapper<(...args: any[]) => any>; } //_.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 any>(predicate: T): T; } interface LoDashWrapper { /** * @see _.negate */ negate(): this; } //_.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 any>(func: T): T; } interface LoDashWrapper { /** * @see _.once */ once(): this; } //_.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; } interface LoDashImplicitWrapper { /** * @see _.partial */ partial: ImplicitPartial; } interface LoDashExplicitWrapper { /** * @see _.partial */ partial: ExplicitPartial; } type PH = LoDashStatic; type Function0 = () => R; type Function1 = (t1: T1) => R; type Function2 = (t1: T1, t2: T2) => R; type Function3 = (t1: T1, t2: T2, t3: T3) => R; type Function4 = (t1: T1, t2: T2, t3: T3, t4: T4) => R; interface Partial { // arity 0 (func: Function0): Function0; // arity 1 (func: Function1): Function1; (func: Function1, arg1: T1): Function0; // arity 2 (func: Function2): Function2; (func: Function2, arg1: T1): Function1< T2, R>; (func: Function2, plc1: PH, arg2: T2): Function1; (func: Function2, arg1: T1, arg2: T2): Function0< R>; // arity 3 (func: Function3): Function3; (func: Function3, arg1: T1): Function2< T2, T3, R>; (func: Function3, plc1: PH, arg2: T2): Function2; (func: Function3, arg1: T1, arg2: T2): Function1< T3, R>; (func: Function3, plc1: PH, plc2: PH, arg3: T3): Function2; (func: Function3, arg1: T1, plc2: PH, arg3: T3): Function1< T2, R>; (func: Function3, plc1: PH, arg2: T2, arg3: T3): Function1; (func: Function3, arg1: T1, arg2: T2, arg3: T3): Function0< R>; // arity 4 (func: Function4): Function4; (func: Function4, arg1: T1): Function3< T2, T3, T4, R>; (func: Function4, plc1: PH, arg2: T2): Function3; (func: Function4, arg1: T1, arg2: T2): Function2< T3, T4, R>; (func: Function4, plc1: PH, plc2: PH, arg3: T3): Function3; (func: Function4, arg1: T1, plc2: PH, arg3: T3): Function2< T2, T4, R>; (func: Function4, plc1: PH, arg2: T2, arg3: T3): Function2; (func: Function4, arg1: T1, arg2: T2, arg3: T3): Function1< T4, R>; (func: Function4, plc1: PH, plc2: PH, plc3: PH, arg4: T4): Function3; (func: Function4, arg1: T1, plc2: PH, plc3: PH, arg4: T4): Function2< T2, T3, R>; (func: Function4, plc1: PH, arg2: T2, plc3: PH, arg4: T4): Function2; (func: Function4, arg1: T1, arg2: T2, plc3: PH, arg4: T4): Function1< T3, R>; (func: Function4, plc1: PH, plc2: PH, arg3: T3, arg4: T4): Function2; (func: Function4, arg1: T1, plc2: PH, arg3: T3, arg4: T4): Function1< T2, R>; (func: Function4, plc1: PH, arg2: T2, arg3: T3, arg4: T4): Function1; (func: Function4, arg1: T1, arg2: T2, arg3: T3, arg4: T4): Function0< R>; // catch-all (func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any; } interface ImplicitPartial { // arity 0 (this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; // arity 1 (this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1): LoDashImplicitWrapper>; // arity 2 (this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, plc1: PH, arg2: T2): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2): LoDashImplicitWrapper>; // arity 3 (this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, plc1: PH, arg2: T2): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, plc1: PH, plc2: PH, arg3: T3): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, plc2: PH, arg3: T3): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, plc1: PH, arg2: T2, arg3: T3): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2, arg3: T3): LoDashImplicitWrapper>; // arity 4 (this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, plc1: PH, arg2: T2): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, plc1: PH, plc2: PH, arg3: T3): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, plc2: PH, arg3: T3): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, plc1: PH, arg2: T2, arg3: T3): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2, arg3: T3): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, plc1: PH, plc2: PH, plc3: PH, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, plc2: PH, plc3: PH, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, plc1: PH, arg2: T2, plc3: PH, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2, plc3: PH, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, plc1: PH, plc2: PH, arg3: T3, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, plc2: PH, arg3: T3, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, plc1: PH, arg2: T2, arg3: T3, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): LoDashImplicitWrapper>; // catch-all (...args: any[]): LoDashImplicitWrapper<(...args: any[]) => any>; } interface ExplicitPartial { // arity 0 (this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; // arity 1 (this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1): LoDashExplicitWrapper>; // arity 2 (this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, plc1: PH, arg2: T2): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2): LoDashExplicitWrapper>; // arity 3 (this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, plc1: PH, arg2: T2): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, plc1: PH, plc2: PH, arg3: T3): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, plc2: PH, arg3: T3): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, plc1: PH, arg2: T2, arg3: T3): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2, arg3: T3): LoDashExplicitWrapper>; // arity 4 (this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, plc1: PH, arg2: T2): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, plc1: PH, plc2: PH, arg3: T3): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, plc2: PH, arg3: T3): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, plc1: PH, arg2: T2, arg3: T3): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2, arg3: T3): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, plc1: PH, plc2: PH, plc3: PH, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, plc2: PH, plc3: PH, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, plc1: PH, arg2: T2, plc3: PH, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2, plc3: PH, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, plc1: PH, plc2: PH, arg3: T3, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, plc2: PH, arg3: T3, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, plc1: PH, arg2: T2, arg3: T3, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): LoDashExplicitWrapper>; // catch-all (...args: any[]): LoDashExplicitWrapper<(...args: any[]) => any>; } //_.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 LoDashImplicitWrapper { /** * @see _.partialRight */ partialRight: ImplicitPartialRight; } interface LoDashExplicitWrapper { /** * @see _.partialRight */ partialRight: ExplicitPartialRight; } interface PartialRight { // arity 0 (func: Function0): Function0; // arity 1 (func: Function1): Function1; (func: Function1, arg1: T1): Function0; // arity 2 (func: Function2): Function2; (func: Function2, arg1: T1, plc2: PH): Function1< T2, R>; (func: Function2, arg2: T2): Function1; (func: Function2, arg1: T1, arg2: T2): Function0< R>; // arity 3 (func: Function3): Function3; (func: Function3, arg1: T1, plc2: PH, plc3: PH): Function2< T2, T3, R>; (func: Function3, arg2: T2, plc3: PH): Function2; (func: Function3, arg1: T1, arg2: T2, plc3: PH): Function1< T3, R>; (func: Function3, arg3: T3): Function2; (func: Function3, arg1: T1, plc2: PH, arg3: T3): Function1< T2, R>; (func: Function3, arg2: T2, arg3: T3): Function1; (func: Function3, arg1: T1, arg2: T2, arg3: T3): Function0< R>; // arity 4 (func: Function4): Function4; (func: Function4, arg1: T1, plc2: PH, plc3: PH, plc4: PH): Function3< T2, T3, T4, R>; (func: Function4, arg2: T2, plc3: PH, plc4: PH): Function3; (func: Function4, arg1: T1, arg2: T2, plc3: PH, plc4: PH): Function2< T3, T4, R>; (func: Function4, arg3: T3, plc4: PH): Function3; (func: Function4, arg1: T1, plc2: PH, arg3: T3, plc4: PH): Function2< T2, T4, R>; (func: Function4, arg2: T2, arg3: T3, plc4: PH): Function2; (func: Function4, arg1: T1, arg2: T2, arg3: T3, plc4: PH): Function1< T4, R>; (func: Function4, arg4: T4): Function3; (func: Function4, arg1: T1, plc2: PH, plc3: PH, arg4: T4): Function2< T2, T3, R>; (func: Function4, arg2: T2, plc3: PH, arg4: T4): Function2; (func: Function4, arg1: T1, arg2: T2, plc3: PH, arg4: T4): Function1< T3, R>; (func: Function4, arg3: T3, arg4: T4): Function2; (func: Function4, arg1: T1, plc2: PH, arg3: T3, arg4: T4): Function1< T2, R>; (func: Function4, arg2: T2, arg3: T3, arg4: T4): Function1; (func: Function4, arg1: T1, arg2: T2, arg3: T3, arg4: T4): Function0< R>; // catch-all (func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any; } interface ImplicitPartialRight { // arity 0 (this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; // arity 1 (this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1): LoDashImplicitWrapper>; // arity 2 (this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, plc2: PH): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg2: T2): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2): LoDashImplicitWrapper>; // arity 3 (this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, plc2: PH, plc3: PH): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg2: T2, plc3: PH): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2, plc3: PH): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg3: T3): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, plc2: PH, arg3: T3): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg2: T2, arg3: T3): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2, arg3: T3): LoDashImplicitWrapper>; // arity 4 (this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, plc2: PH, plc3: PH, plc4: PH): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg2: T2, plc3: PH, plc4: PH): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2, plc3: PH, plc4: PH): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg3: T3, plc4: PH): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, plc2: PH, arg3: T3, plc4: PH): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg2: T2, arg3: T3, plc4: PH): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2, arg3: T3, plc4: PH): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, plc2: PH, plc3: PH, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg2: T2, plc3: PH, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2, plc3: PH, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg3: T3, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, plc2: PH, arg3: T3, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg2: T2, arg3: T3, arg4: T4): LoDashImplicitWrapper>; (this: LoDashImplicitWrapper>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): LoDashImplicitWrapper>; // catch-all (...args: any[]): LoDashImplicitWrapper<(...args: any[]) => any>; } interface ExplicitPartialRight { // arity 0 (this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; // arity 1 (this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1): LoDashExplicitWrapper>; // arity 2 (this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, plc2: PH): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg2: T2): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2): LoDashExplicitWrapper>; // arity 3 (this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, plc2: PH, plc3: PH): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg2: T2, plc3: PH): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2, plc3: PH): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg3: T3): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, plc2: PH, arg3: T3): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg2: T2, arg3: T3): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2, arg3: T3): LoDashExplicitWrapper>; // arity 4 (this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, plc2: PH, plc3: PH, plc4: PH): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg2: T2, plc3: PH, plc4: PH): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2, plc3: PH, plc4: PH): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg3: T3, plc4: PH): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, plc2: PH, arg3: T3, plc4: PH): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg2: T2, arg3: T3, plc4: PH): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2, arg3: T3, plc4: PH): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, plc2: PH, plc3: PH, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg2: T2, plc3: PH, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2, plc3: PH, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg3: T3, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, plc2: PH, arg3: T3, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg2: T2, arg3: T3, arg4: T4): LoDashExplicitWrapper>; (this: LoDashExplicitWrapper>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): LoDashExplicitWrapper>; // catch-all (...args: any[]): LoDashExplicitWrapper<(...args: any[]) => any>; } //_.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(func: (...args: any[]) => any, ...indexes: Array>): (...args: any[]) => any; } interface LoDashImplicitWrapper { /** * @see _.rearg */ rearg(...indexes: Array>): LoDashImplicitWrapper<(...args: any[]) => any>; } interface LoDashExplicitWrapper { /** * @see _.rearg */ rearg(...indexes: Array>): LoDashExplicitWrapper<(...args: any[]) => any>; } //_.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( func: (...args: any[]) => any, start?: number ): (...args: any[]) => any; } interface LoDashImplicitWrapper { /** * @see _.rest */ rest(start?: number): LoDashImplicitWrapper<(...args: any[]) => any>; } interface LoDashExplicitWrapper { /** * @see _.rest */ rest(start?: number): LoDashExplicitWrapper<(...args: any[]) => any>; } //_.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(func: (...args: any[]) => TResult): (...args: any[]) => TResult; /** * @see _.spread */ spread(func: (...args: any[]) => TResult, start: number): (...args: any[]) => TResult; } interface LoDashImplicitWrapper { /** * @see _.spread */ spread(this: LoDashImplicitWrapper<(...args: any[]) => TResult>): LoDashImplicitWrapper<(...args: any[]) => TResult>; /** * @see _.spread */ spread(this: LoDashImplicitWrapper<(...args: any[]) => TResult>, start: number): LoDashImplicitWrapper<(...args: any[]) => TResult>; } interface LoDashExplicitWrapper { /** * @see _.spread */ spread(this: LoDashExplicitWrapper<(...args: any[]) => TResult>): LoDashExplicitWrapper<(...args: any[]) => TResult>; /** * @see _.spread */ spread(this: LoDashExplicitWrapper<(...args: any[]) => TResult>, start: number): LoDashExplicitWrapper<(...args: any[]) => TResult>; } //_.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 any>( func: T, wait?: number, options?: ThrottleSettings ): T & Cancelable; } interface LoDashImplicitWrapper { /** * @see _.throttle */ throttle( wait?: number, options?: ThrottleSettings ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.throttle */ throttle( wait?: number, options?: ThrottleSettings ): LoDashExplicitWrapper; } //_.unary interface LoDashStatic { /** * Creates a function that accepts up to one argument, ignoring any * additional arguments. * * @category Function * @param func The function to cap arguments for. * @returns Returns the new function. * @example * * _.map(['6', '8', '10'], _.unary(parseInt)); * // => [6, 8, 10] */ unary(func: (arg1: T, ...args: any[]) => TResult): (arg1: T) => TResult; } interface LoDashImplicitWrapper { /** * @see _.unary */ unary(this: LoDashImplicitWrapper<(arg1: T, ...args: any[]) => TResult>): LoDashImplicitWrapper<(arg1: T) => TResult>; } interface LoDashExplicitWrapper { /** * @see _.unary */ unary(this: LoDashExplicitWrapper<(arg1: T, ...args: any[]) => TResult>): LoDashExplicitWrapper<(arg1: T) => TResult>; } //_.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( value: T, wrapper: (value: T, ...args: TArgs[]) => TResult ): (...args: TArgs[]) => TResult; /** * @see _.wrap */ wrap( value: T, wrapper: (value: T, ...args: any[]) => TResult ): (...args: any[]) => TResult; } interface LoDashImplicitWrapper { /** * @see _.wrap */ wrap( wrapper: (value: TValue, ...args: TArgs[]) => TResult ): LoDashImplicitWrapper<(...args: TArgs[]) => TResult>; /** * @see _.wrap */ wrap( wrapper: (value: TValue, ...args: any[]) => TResult ): LoDashImplicitWrapper<(...args: any[]) => TResult>; } interface LoDashExplicitWrapper { /** * @see _.wrap */ /** * @see _.wrap */ wrap( wrapper: (value: TValue, ...args: TArgs[]) => TResult ): LoDashExplicitWrapper<(...args: TArgs[]) => TResult>; /** * @see _.wrap */ wrap( wrapper: (value: TValue, ...args: any[]) => TResult ): LoDashExplicitWrapper<(...args: any[]) => TResult>; } /******** * 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(value?: Many): T[]; } interface LoDashImplicitWrapper { /** * @see _.castArray */ castArray(this: LoDashImplicitWrapper>): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.castArray */ castArray(this: LoDashExplicitWrapper>): LoDashExplicitWrapper; } //_.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(value: T): T; } interface LoDashImplicitWrapper { /** * @see _.clone */ clone(): TValue; } interface LoDashExplicitWrapper { /** * @see _.clone */ clone(): this; } //_.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(value: T): T; } interface LoDashImplicitWrapper { /** * @see _.cloneDeep */ cloneDeep(): TValue; } interface LoDashExplicitWrapper { /** * @see _.cloneDeep */ cloneDeep(): this; } //_.cloneDeepWith type CloneDeepWithCustomizer = (value: any, key: number | string | undefined, object: TObject | undefined, stack: any) => any; 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( value: T, customizer: CloneDeepWithCustomizer ): any; /** * @see _.cloneDeepWith */ cloneDeepWith(value: T): T; } interface LoDashImplicitWrapper { /** * @see _.cloneDeepWith */ cloneDeepWith( customizer: CloneDeepWithCustomizer ): any; /** * @see _.cloneDeepWith */ cloneDeepWith(): TValue; } interface LoDashExplicitWrapper { /** * @see _.cloneDeepWith */ cloneDeepWith( customizer: CloneDeepWithCustomizer ): LoDashExplicitWrapper; /** * @see _.cloneDeepWith */ cloneDeepWith(): this; } //_.cloneWith type CloneWithCustomizer = (value: TValue, key: number | string | undefined, object: any, stack: any) => 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( value: T, customizer: CloneWithCustomizer ): TResult; /** * @see _.cloneWith */ cloneWith( value: T, customizer: CloneWithCustomizer ): TResult | T; /** * @see _.cloneWith */ cloneWith(value: T): T; } interface LoDashImplicitWrapper { /** * @see _.cloneWith */ cloneWith( customizer: CloneWithCustomizer ): TResult; /** * @see _.cloneWith */ cloneWith( customizer: CloneWithCustomizer ): TResult | TValue; /** * @see _.cloneWith */ cloneWith(): TValue; } interface LoDashExplicitWrapper { /** * @see _.cloneWith */ cloneWith( customizer: CloneWithCustomizer ): LoDashExplicitWrapper; /** * @see _.cloneWith */ cloneWith( customizer: CloneWithCustomizer ): LoDashExplicitWrapper; /** * @see _.cloneWith */ cloneWith(): this; } /** * An object containing predicate functions for each property of T */ type ConformsPredicateObject = { [P in keyof T]?: (val: T[P]) => boolean; }; //_.conforms interface LoDashStatic { /** * Creates a function that invokes the predicate properties of `source` with the corresponding * property values of a given object, returning true if all predicates return truthy, else false. */ conforms(source: ConformsPredicateObject): (value: T) => boolean; } interface LoDashImplicitWrapper { /** * @see _.conforms */ conforms(this: LoDashImplicitWrapper>): LoDashImplicitWrapper<(value: T) => boolean>; } interface LoDashExplicitWrapper { /** * @see _.conforms */ conforms(this: LoDashExplicitWrapper>): LoDashExplicitWrapper<(value: T) => boolean>; } //_.conformsTo interface LoDashStatic { /** * Checks if object conforms to source by invoking the predicate properties of source with the * corresponding property values of object. * * Note: This method is equivalent to _.conforms when source is partially applied. */ conformsTo(object: T, source: ConformsPredicateObject): boolean; } interface LoDashImplicitWrapper { /** * @see _.conformsTo */ conformsTo(this: LoDashImplicitWrapper, source: ConformsPredicateObject): boolean; // Note: we can't use TValue here, because it generates a typescript error when strictFunctionTypes is enabled. } interface LoDashExplicitWrapper { /** * @see _.conformsTo */ conformsTo(this: LoDashImplicitWrapper, source: ConformsPredicateObject): LoDashExplicitWrapper; // Note: we can't use TValue here, because it generates a typescript error when strictFunctionTypes is enabled. } type CondPair = [(val: T) => boolean, (val: T) => R] //_.cond interface LoDashStatic { /** * Creates a function that iterates over `pairs` and invokes the corresponding * function of the first predicate to return truthy. The predicate-function * pairs are invoked with the `this` binding and arguments of the created * function. * * @since 4.0.0 * @category Util * @param pairs The predicate-function pairs. * @returns Returns the new composite function. * @example * * var func = _.cond([ * [_.matches({ 'a': 1 }), _.constant('matches A')], * [_.conforms({ 'b': _.isNumber }), _.constant('matches B')], * [_.stubTrue, _.constant('no match')] * ]); * * func({ 'a': 1, 'b': 2 }); * // => 'matches A' * * func({ 'a': 0, 'b': 1 }); * // => 'matches B' * * func({ 'a': '1', 'b': '2' }); * // => 'no match' */ cond(pairs: CondPair[]): (Target: T) => R; } //_.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. * * @category Lang * @param value The value to compare. * @param other The other value to compare. * @returns 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 LoDashImplicitWrapper { /** * @see _.eq */ eq( other: any ): boolean; } interface LoDashExplicitWrapper { /** * @see _.eq */ eq( other: any ): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.gt */ gt(other: any): boolean; } interface LoDashExplicitWrapper { /** * @see _.gt */ gt(other: any): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.gte */ gte(other: any): boolean; } interface LoDashExplicitWrapper { /** * @see _.gte */ gte(other: any): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.isArguments */ isArguments(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isArguments */ isArguments(): LoDashExplicitWrapper; } //_.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(value?: any): value is any[]; /** * DEPRECATED */ isArray(value?: any): value is any[]; } interface LoDashImplicitWrapper { /** * @see _.isArray */ isArray(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isArray */ isArray(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.isArrayBuffer */ isArrayBuffer(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isArrayBuffer */ isArrayBuffer(): LoDashExplicitWrapper; } //_.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`. * * @category Lang * @param value The value to check. * @returns 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(value: T & string & number): boolean; // should only match if T = any /** * @see _.isArrayLike */ isArrayLike(value: ((...args: any[]) => any) | Function | null | undefined): value is never; /** * @see _.isArrayLike */ isArrayLike(value: any): value is { length: number }; } interface LoDashImplicitWrapper { /** * @see _.isArrayLike */ isArrayLike(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isArrayLike */ isArrayLike(): LoDashExplicitWrapper; } //_.isArrayLikeObject interface LoDashStatic { /** * This method is like `_.isArrayLike` except that it also checks if `value` * is an object. * * @category Lang * @param value The value to check. * @returns 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(value: T & string & number): boolean; // should only match if T = any /** * @see _.isArrayLike */ isArrayLikeObject(value: ((...args: any[]) => any) | Function | string | boolean | number | null | undefined): value is never; /** * @see _.isArrayLike */ isArrayLikeObject(value: T | string | boolean | number | null | undefined): value is T & { length: number }; } interface LoDashImplicitWrapper { /** * @see _.isArrayLikeObject */ isArrayLikeObject(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isArrayLikeObject */ isArrayLikeObject(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.isBoolean */ isBoolean(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isBoolean */ isBoolean(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.isBuffer */ isBuffer(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isBuffer */ isBuffer(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.isDate */ isDate(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isDate */ isDate(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.isElement */ isElement(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isElement */ isElement(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.isEmpty */ isEmpty(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isEmpty */ isEmpty(): LoDashExplicitWrapper; } //_.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. * * @category Lang * @param value The value to compare. * @param other The other value to compare. * @returns 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 LoDashImplicitWrapper { /** * @see _.isEqual */ isEqual( other: any ): boolean; } interface LoDashExplicitWrapper { /** * @see _.isEqual */ isEqual( other: any ): LoDashExplicitWrapper; } // _.isEqualWith type IsEqualCustomizer = (value: any, other: any, indexOrKey: PropertyName | undefined, parent: any, otherParent: any, stack: any) => boolean|undefined; 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]). * * @category Lang * @param value The value to compare. * @param other The other value to compare. * @param [customizer] The function to customize comparisons. * @returns 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 LoDashImplicitWrapper { /** * @see _.isEqualWith */ isEqualWith( other: any, customizer?: IsEqualCustomizer ): boolean; } interface LoDashExplicitWrapper { /** * @see _.isEqualWith */ isEqualWith( other: any, customizer?: IsEqualCustomizer ): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.isError */ isError(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isError */ isError(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.isFinite */ isFinite(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isFinite */ isFinite(): LoDashExplicitWrapper; } //_.isFunction interface LoDashStatic { /** * Checks if value is a callable function. * * @param value The value to check. * @return Returns true if value is correctly classified, else false. */ isFunction(value: any): value is (...args: any[]) => any; } interface LoDashImplicitWrapper { /** * @see _.isFunction */ isFunction(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isFunction */ isFunction(): LoDashExplicitWrapper; } //_.isInteger interface LoDashStatic { /** * Checks if `value` is an integer. * * **Note:** This method is based on [`Number.isInteger`](https://mdn.io/Number/isInteger). * * @category Lang * @param value The value to check. * @returns 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 LoDashImplicitWrapper { /** * @see _.isInteger */ isInteger(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isInteger */ isInteger(): LoDashExplicitWrapper; } //_.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). * * @category Lang * @param value The value to check. * @returns 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 LoDashImplicitWrapper { /** * @see _.isLength */ isLength(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isLength */ isLength(): LoDashExplicitWrapper; } //_.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(value?: any): value is Map; } interface LoDashImplicitWrapper { /** * @see _.isMap */ isMap(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isMap */ isMap(): LoDashExplicitWrapper; } //_.isMatch type isMatchCustomizer = (value: any, other: any, indexOrKey?: PropertyName) => 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`. * * @category Lang * @param object The object to inspect. * @param source The object of property values to match. * @returns 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 LoDashImplicitWrapper { /** * @see _.isMatch */ isMatch(source: object): boolean; } //_.isMatchWith type isMatchWithCustomizer = (value: any, other: any, indexOrKey: PropertyName) => 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). * * @category Lang * @param object The object to inspect. * @param source The object of property values to match. * @param [customizer] The function to customize comparisons. * @returns 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 LoDashImplicitWrapper { /** * @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 LoDashImplicitWrapper { /** * @see _.isNaN */ isNaN(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isNaN */ isNaN(): LoDashExplicitWrapper; } //_.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 ((...args: any[]) => any) | Function; } interface LoDashImplicitWrapper { /** * see _.isNative */ isNative(): boolean; } interface LoDashExplicitWrapper { /** * see _.isNative */ isNative(): LoDashExplicitWrapper; } //_.isNil interface LoDashStatic { /** * Checks if `value` is `null` or `undefined`. * * @category Lang * @param value The value to check. * @returns Returns `true` if `value` is nullish, else `false`. * @example * * _.isNil(null); * // => true * * _.isNil(void 0); * // => true * * _.isNil(NaN); * // => false */ isNil(value: any): value is null | undefined; } interface LoDashImplicitWrapper { /** * see _.isNil */ isNil(): boolean; } interface LoDashExplicitWrapper { /** * see _.isNil */ isNil(): LoDashExplicitWrapper; } //_.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): value is null; } interface LoDashImplicitWrapper { /** * see _.isNull */ isNull(): boolean; } interface LoDashExplicitWrapper { /** * see _.isNull */ isNull(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * see _.isNumber */ isNumber(): boolean; } interface LoDashExplicitWrapper { /** * see _.isNumber */ isNumber(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * see _.isObject */ isObject(): boolean; } interface LoDashExplicitWrapper { /** * see _.isObject */ isObject(): LoDashExplicitWrapper; } //_.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". * * @category Lang * @param value The value to check. * @returns 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 LoDashImplicitWrapper { /** * see _.isObjectLike */ isObjectLike(): boolean; } interface LoDashExplicitWrapper { /** * see _.isObjectLike */ isObjectLike(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * see _.isPlainObject */ isPlainObject(): boolean; } interface LoDashExplicitWrapper { /** * see _.isPlainObject */ isPlainObject(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * see _.isRegExp */ isRegExp(): boolean; } interface LoDashExplicitWrapper { /** * see _.isRegExp */ isRegExp(): LoDashExplicitWrapper; } //_.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). * * @category Lang * @param value The value to check. * @returns 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 LoDashImplicitWrapper { /** * see _.isSafeInteger */ isSafeInteger(): boolean; } interface LoDashExplicitWrapper { /** * see _.isSafeInteger */ isSafeInteger(): LoDashExplicitWrapper; } //_.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(value?: any): value is Set; } interface LoDashImplicitWrapper { /** * @see _.isSet */ isSet(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isSet */ isSet(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * see _.isString */ isString(): boolean; } interface LoDashExplicitWrapper { /** * see _.isString */ isString(): LoDashExplicitWrapper; } //_.isSymbol interface LoDashStatic { /** * Checks if `value` is classified as a `Symbol` primitive or object. * * @category Lang * @param value The value to check. * @returns Returns `true` if `value` is correctly classified, else `false`. * @example * * _.isSymbol(Symbol.iterator); * // => true * * _.isSymbol('abc'); * // => false */ isSymbol(value: any): boolean; } interface LoDashImplicitWrapper { /** * see _.isSymbol */ isSymbol(): boolean; } interface LoDashExplicitWrapper { /** * see _.isSymbol */ isSymbol(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * see _.isTypedArray */ isTypedArray(): boolean; } interface LoDashExplicitWrapper { /** * see _.isTypedArray */ isTypedArray(): LoDashExplicitWrapper; } //_.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): value is undefined; } interface LoDashImplicitWrapper { /** * see _.isUndefined */ isUndefined(): boolean; } interface LoDashExplicitWrapper { /** * see _.isUndefined */ isUndefined(): LoDashExplicitWrapper; } //_.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(value?: any): value is WeakMap; } interface LoDashImplicitWrapper { /** * @see _.isSet */ isWeakMap(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isSet */ isWeakMap(): LoDashExplicitWrapper; } //_.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(value?: any): value is WeakSet; } interface LoDashImplicitWrapper { /** * @see _.isWeakSet */ isWeakSet(): boolean; } interface LoDashExplicitWrapper { /** * @see _.isWeakSet */ isWeakSet(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.lt */ lt(other: any): boolean; } interface LoDashExplicitWrapper { /** * @see _.lt */ lt(other: any): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.lte */ lte(other: any): boolean; } interface LoDashExplicitWrapper { /** * @see _.lte */ lte(other: any): LoDashExplicitWrapper; } //_.toArray interface LoDashStatic { /** * Converts value to an array. * * @param value The value to convert. * @return Returns the converted array. */ toArray(value: List | Dictionary | NumericDictionary | null | undefined): T[]; /** * @see _.toArray */ toArray(value: T): Array; /** * @see _.toArray */ toArray(): any[]; } interface LoDashImplicitWrapper { /** * @see _.toArray */ toArray(this: LoDashImplicitWrapper | Dictionary | NumericDictionary | null | undefined>): LoDashImplicitWrapper; /** * @see _.toArray */ toArray(this: LoDashImplicitWrapper): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.toArray */ toArray(this: LoDashExplicitWrapper | Dictionary | NumericDictionary | null | undefined>): LoDashExplicitWrapper; /** * @see _.toArray */ toArray(this: LoDashImplicitWrapper): LoDashExplicitWrapper>; } //_.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(value?: any): any; } interface LoDashImplicitWrapper { /** * @see _.toPlainObject */ toPlainObject(): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.toPlainObject */ toPlainObject(): LoDashExplicitWrapper; } //_.toFinite interface LoDashStatic { /** * Converts `value` to a finite number. * * @since 4.12.0 * @category Lang * @param value The value to convert. * @returns Returns the converted number. * @example * * _.toFinite(3.2); * // => 3.2 * * _.toFinite(Number.MIN_VALUE); * // => 5e-324 * * _.toFinite(Infinity); * // => 1.7976931348623157e+308 * * _.toFinite('3.2'); * // => 3.2 */ toFinite(value: any): number; } interface LoDashImplicitWrapper { /** * @see _.toFinite */ toFinite(): number; } interface LoDashExplicitWrapper { /** * @see _.toFinite */ toFinite(): LoDashExplicitWrapper; } //_.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). * * @category Lang * @param value The value to convert. * @returns 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 LoDashImplicitWrapper { /** * @see _.toInteger */ toInteger(): number; } interface LoDashExplicitWrapper { /** * @see _.toInteger */ toInteger(): LoDashExplicitWrapper; } //_.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). * * @category Lang * @param value The value to convert. * @return Returns the converted integer. * @example * * _.toLength(3); * // => 3 * * _.toLength(Number.MIN_VALUE); * // => 0 * * _.toLength(Infinity); * // => 4294967295 * * _.toLength('3'); * // => 3 */ toLength(value: any): number; } interface LoDashImplicitWrapper { /** * @see _.toLength */ toLength(): number; } interface LoDashExplicitWrapper { /** * @see _.toLength */ toLength(): LoDashExplicitWrapper; } //_.toNumber interface LoDashStatic { /** * Converts `value` to a number. * * @category Lang * @param value The value to process. * @returns Returns the number. * @example * * _.toNumber(3); * // => 3 * * _.toNumber(Number.MIN_VALUE); * // => 5e-324 * * _.toNumber(Infinity); * // => Infinity * * _.toNumber('3'); * // => 3 */ toNumber(value: any): number; } interface LoDashImplicitWrapper { /** * @see _.toNumber */ toNumber(): number; } interface LoDashExplicitWrapper { /** * @see _.toNumber */ toNumber(): LoDashExplicitWrapper; } //_.toSafeInteger interface LoDashStatic { /** * Converts `value` to a safe integer. A safe integer can be compared and * represented correctly. * * @category Lang * @param value The value to convert. * @returns Returns the converted integer. * @example * * _.toSafeInteger(3); * // => 3 * * _.toSafeInteger(Number.MIN_VALUE); * // => 0 * * _.toSafeInteger(Infinity); * // => 9007199254740991 * * _.toSafeInteger('3'); * // => 3 */ toSafeInteger(value: any): number; } interface LoDashImplicitWrapper { /** * @see _.toSafeInteger */ toSafeInteger(): number; } interface LoDashExplicitWrapper { /** * @see _.toSafeInteger */ toSafeInteger(): LoDashExplicitWrapper; } //_.toString 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. * * @category Lang * @param value The value to process. * @returns 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 { /** * @see _.add */ add(addend: number): number; } interface LoDashExplicitWrapper { /** * @see _.add */ add(addend: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.ceil */ ceil(precision?: number): number; } interface LoDashExplicitWrapper { /** * @see _.ceil */ ceil(precision?: number): LoDashExplicitWrapper; } //_.divide interface LoDashStatic { /** * Divide two numbers. * * @param dividend The first number in a division. * @param divisor The second number in a division. * @returns Returns the quotient. */ divide( dividend: number, divisor: number ): number; } interface LoDashImplicitWrapper { /** * @see _.divide */ divide(divisor: number): number; } interface LoDashExplicitWrapper { /** * @see _.divide */ divide(divisor: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.floor */ floor(precision?: number): number; } interface LoDashExplicitWrapper { /** * @see _.floor */ floor(precision?: number): LoDashExplicitWrapper; } //_.max interface LoDashStatic { /** * Computes the maximum value of `array`. If `array` is empty or falsey * `undefined` is returned. * * @category Math * @param array The array to iterate over. * @returns Returns the maximum value. */ max( collection: List | null | undefined ): T | undefined; } interface LoDashImplicitWrapper { /** * @see _.max */ max(this: LoDashImplicitWrapper | null | undefined>): T | undefined; } interface LoDashExplicitWrapper { /** * @see _.max */ max(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; } //_.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). * * @category Math * @param array The array to iterate over. * @param [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( collection: List | null | undefined, iteratee?: ListIteratee ): T | undefined; } interface LoDashImplicitWrapper { /** * @see _.maxBy */ maxBy( this: LoDashImplicitWrapper | null | undefined>, iteratee?: ListIteratee ): T | undefined; } interface LoDashExplicitWrapper { /** * @see _.maxBy */ maxBy( this: LoDashExplicitWrapper | null | undefined>, iteratee?: ListIteratee ): LoDashExplicitWrapper; } //_.mean interface LoDashStatic { /** * Computes the mean of the values in `array`. * * @category Math * @param array The array to iterate over. * @returns Returns the mean. * @example * * _.mean([4, 2, 8, 6]); * // => 5 */ mean( collection: List | null | undefined ): number; } interface LoDashImplicitWrapper { /** * @see _.mean */ mean(): number; } interface LoDashExplicitWrapper { /** * @see _.mean */ mean(): LoDashExplicitWrapper; } //_.meanBy interface LoDashStatic { /** * Computes the mean of the provided propties of the objects in the `array` * * @category Math * @param array The array to iterate over. * @param [iteratee=_.identity] The iteratee invoked per element. * @returns Returns the mean. * @example * * _.mean([{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }], 'n'); * // => 5 */ meanBy( collection: List | null | undefined, iteratee?: ListIteratee ): number; } interface LoDashImplicitWrapper { /** * @see _.meanBy */ meanBy( this: LoDashImplicitWrapper | null | undefined>, iteratee?: ListIteratee ): number; } interface LoDashExplicitWrapper { /** * @see _.meanBy */ meanBy( this: LoDashExplicitWrapper | null | undefined>, iteratee?: ListIteratee ): LoDashExplicitWrapper; } //_.min interface LoDashStatic { /** * Computes the minimum value of `array`. If `array` is empty or falsey * `undefined` is returned. * * @category Math * @param array The array to iterate over. * @returns Returns the minimum value. */ min( collection: List | null | undefined ): T | undefined; } interface LoDashImplicitWrapper { /** * @see _.min */ min(this: LoDashImplicitWrapper | null | undefined>): T | undefined; } interface LoDashExplicitWrapper { /** * @see _.min */ min(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper; } //_.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). * * @category Math * @param array The array to iterate over. * @param [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( collection: List | null | undefined, iteratee?: ListIteratee ): T | undefined; } interface LoDashImplicitWrapper { /** * @see _.minBy */ minBy( this: LoDashImplicitWrapper | null | undefined>, iteratee?: ListIteratee ): T | undefined; } interface LoDashExplicitWrapper { /** * @see _.minBy */ minBy( this: LoDashExplicitWrapper | null | undefined>, iteratee?: ListIteratee ): LoDashExplicitWrapper; } //_.multiply interface LoDashStatic { /** * Multiply two numbers. * @param multiplier The first number in a multiplication. * @param multiplicand The second number in a multiplication. * @returns Returns the product. */ multiply( multiplier: number, multiplicand: number ): number; } interface LoDashImplicitWrapper { /** * @see _.multiply */ multiply(multiplicand: number): number; } interface LoDashExplicitWrapper { /** * @see _.multiply */ multiply(multiplicand: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.round */ round(precision?: number): number; } interface LoDashExplicitWrapper { /** * @see _.round */ round(precision?: number): LoDashExplicitWrapper; } //_.sum interface LoDashStatic { /** * Computes the sum of the values in `array`. * * @category Math * @param array The array to iterate over. * @returns Returns the sum. * @example * * _.sum([4, 2, 8, 6]); * // => 20 */ sum(collection: List | null | undefined): number; } interface LoDashImplicitWrapper { /** * @see _.sum */ sum(): number; } interface LoDashExplicitWrapper { /** * @see _.sum */ sum(): LoDashExplicitWrapper; } //_.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). * * @category Math * @param array The array to iterate over. * @param [iteratee=_.identity] The iteratee invoked per element. * @returns 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( collection: List | null | undefined, iteratee?: ((value: T) => number) | string ): number; } interface LoDashImplicitWrapper { /** * @see _.sumBy */ sumBy( this: LoDashImplicitWrapper | null | undefined>, iteratee?: ((value: T) => number) | string ): number; } interface LoDashExplicitWrapper { /** * @see _.sumBy */ sumBy( this: LoDashExplicitWrapper | null | undefined>, iteratee?: ((value: T) => number) | string ): LoDashExplicitWrapper; } /********** * Number * **********/ //_.subtract interface LoDashStatic { /** * Subtract two numbers. * * @category Math * @param minuend The first number in a subtraction. * @param subtrahend The second number in a subtraction. * @returns Returns the difference. * @example * * _.subtract(6, 4); * // => 2 */ subtract( minuend: number, subtrahend: number ): number; } interface LoDashImplicitWrapper { /** * @see _.subtract */ subtract( subtrahend: number ): number; } interface LoDashExplicitWrapper { /** * @see _.subtract */ subtract( subtrahend: number ): LoDashExplicitWrapper; } //_.clamp interface LoDashStatic { /** * Clamps `number` within the inclusive `lower` and `upper` bounds. * * @category Number * @param number The number to clamp. * @param [lower] The lower bound. * @param upper The upper bound. * @returns Returns the clamped number. * @example * * _.clamp(-10, -5, 5); * // => -5 * * _.clamp(10, -5, 5); * // => 5 */ clamp( number: number, lower: number, upper: number ): number; clamp( number: number, upper: number ): number; } interface LoDashImplicitWrapper { /** * @see _.clamp */ clamp( lower: number, upper: number ): number; clamp( upper: number ): number; } interface LoDashExplicitWrapper { /** * @see _.clamp */ clamp( lower: number, upper: number ): LoDashExplicitWrapper; clamp( upper: number ): LoDashExplicitWrapper; } //_.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; } interface LoDashImplicitWrapper { /** * @see _.inRange */ inRange( start: number, end?: number ): boolean; } interface LoDashExplicitWrapper { /** * @see _.inRange */ inRange( start: number, end?: number ): LoDashExplicitWrapper; } //_.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( floating?: boolean ): number; /** * @see _.random */ random( max: number, floating?: boolean ): number; /** * @see _.random */ random( min: number, max: number, floating?: boolean ): number; /** * 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 index Not used in this overload. * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code. * @return Returns the random number. */ random( min: number, index: string | number, guard: object ): number; } interface LoDashImplicitWrapper { /** * @see _.random */ random(floating?: boolean): number; /** * @see _.random */ random( max: number, floating?: boolean ): number; } interface LoDashExplicitWrapper { /** * @see _.random */ random(floating?: boolean): LoDashExplicitWrapper; /** * @see _.random */ random( max: number, floating?: boolean ): LoDashExplicitWrapper; } /********** * 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). * * @category Object * @param object The destination object. * @param [sources] The source objects. * @returns 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( object: TObject, source: TSource ): TObject & TSource; /** * @see assign */ assign( object: TObject, source1: TSource1, source2: TSource2 ): TObject & TSource1 & TSource2; /** * @see assign */ assign( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3 ): TObject & TSource1 & TSource2 & TSource3; /** * @see assign */ assign( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): TObject & TSource1 & TSource2 & TSource3 & TSource4; /** * @see _.assign */ assign(object: TObject): TObject; /** * @see _.assign */ assign( object: any, ...otherArgs: any[] ): any; } interface LoDashImplicitWrapper { /** * @see _.assign */ assign( source: TSource ): LoDashImplicitWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2 ): LoDashImplicitWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashImplicitWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashImplicitWrapper; /** * @see _.assign */ assign(): LoDashImplicitWrapper; /** * @see _.assign */ assign(...otherArgs: any[]): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.assign */ assign( source: TSource ): LoDashExplicitWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2 ): LoDashExplicitWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashExplicitWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashExplicitWrapper; /** * @see _.assign */ assign(): LoDashExplicitWrapper; /** * @see _.assign */ assign(...otherArgs: any[]): LoDashExplicitWrapper; } 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`. * * @category Object * @param object The destination object. * @param sources The source objects. * @param [customizer] The function to customize assigned values. * @returns 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( object: TObject, source: TSource, customizer: AssignCustomizer ): TObject & TSource; /** * @see assignWith */ assignWith( object: TObject, source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): TObject & TSource1 & TSource2; /** * @see assignWith */ assignWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): TObject & TSource1 & TSource2 & TSource3; /** * @see assignWith */ assignWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): TObject & TSource1 & TSource2 & TSource3 & TSource4; /** * @see _.assignWith */ assignWith(object: TObject): TObject; /** * @see _.assignWith */ assignWith( object: any, ...otherArgs: any[] ): TResult; } interface LoDashImplicitWrapper { /** * @see _.assignWith */ assignWith( source: TSource, customizer: AssignCustomizer ): LoDashImplicitWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashImplicitWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashImplicitWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashImplicitWrapper; /** * @see _.assignWith */ assignWith(): LoDashImplicitWrapper; /** * @see _.assignWith */ assignWith(...otherArgs: any[]): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.assignWith */ assignWith( source: TSource, customizer: AssignCustomizer ): LoDashExplicitWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashExplicitWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashExplicitWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashExplicitWrapper; /** * @see _.assignWith */ assignWith(): LoDashExplicitWrapper; /** * @see _.assignWith */ assignWith(...otherArgs: any[]): LoDashExplicitWrapper; } //_.assignIn interface LoDashStatic { /** * This method is like `_.assign` except that it iterates over own and * inherited source properties. * * **Note:** This method mutates `object`. * * @alias extend * @category Object * @param object The destination object. * @param [sources] The source objects. * @returns 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( object: TObject, source: TSource ): TObject & TSource; /** * @see assignIn */ assignIn( object: TObject, source1: TSource1, source2: TSource2 ): TObject & TSource1 & TSource2; /** * @see assignIn */ assignIn( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3 ): TObject & TSource1 & TSource2 & TSource3; /** * @see assignIn */ assignIn( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): TObject & TSource1 & TSource2 & TSource3 & TSource4; /** * @see _.assignIn */ assignIn(object: TObject): TObject; /** * @see _.assignIn */ assignIn( object: any, ...otherArgs: any[] ): TResult; } interface LoDashImplicitWrapper { /** * @see _.assignIn */ assignIn( source: TSource ): LoDashImplicitWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2 ): LoDashImplicitWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashImplicitWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashImplicitWrapper; /** * @see _.assignIn */ assignIn(): LoDashImplicitWrapper; /** * @see _.assignIn */ assignIn(...otherArgs: any[]): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.assignIn */ assignIn( source: TSource ): LoDashExplicitWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2 ): LoDashExplicitWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashExplicitWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashExplicitWrapper; /** * @see _.assignIn */ assignIn(): LoDashExplicitWrapper; /** * @see _.assignIn */ assignIn(...otherArgs: any[]): LoDashExplicitWrapper; } //_.assignInWith type 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`. * * @alias extendWith * @category Object * @param object The destination object. * @param sources The source objects. * @param [customizer] The function to customize assigned values. * @returns 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( object: TObject, source: TSource, customizer: AssignCustomizer ): TObject & TSource; /** * @see assignInWith */ assignInWith( object: TObject, source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): TObject & TSource1 & TSource2; /** * @see assignInWith */ assignInWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): TObject & TSource1 & TSource2 & TSource3; /** * @see assignInWith */ assignInWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): TObject & TSource1 & TSource2 & TSource3 & TSource4; /** * @see _.assignInWith */ assignInWith(object: TObject): TObject; /** * @see _.assignInWith */ assignInWith( object: any, ...otherArgs: any[] ): TResult; } interface LoDashImplicitWrapper { /** * @see _.assignInWith */ assignInWith( source: TSource, customizer: AssignCustomizer ): LoDashImplicitWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashImplicitWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashImplicitWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashImplicitWrapper; /** * @see _.assignInWith */ assignInWith(): LoDashImplicitWrapper; /** * @see _.assignInWith */ assignInWith(...otherArgs: any[]): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.assignInWith */ assignInWith( source: TSource, customizer: AssignCustomizer ): LoDashExplicitWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashExplicitWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashExplicitWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashExplicitWrapper; /** * @see _.assignInWith */ assignInWith(): LoDashExplicitWrapper; /** * @see _.assignInWith */ assignInWith(...otherArgs: any[]): LoDashExplicitWrapper; } //_.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( prototype: T, properties?: U ): T & U; } interface LoDashImplicitWrapper { /** * @see _.create */ create(properties?: U): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.create */ create(properties?: U): LoDashExplicitWrapper; } //_.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( object: TObject, source: TSource ): TSource & TObject; /** * @see _.defaults */ defaults( object: TObject, source1: TSource1, source2: TSource2 ): TSource2 & TSource1 & TObject; /** * @see _.defaults */ defaults( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3 ): TSource3 & TSource2 & TSource1 & TObject; /** * @see _.defaults */ defaults( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): TSource4 & TSource3 & TSource2 & TSource1 & TObject; /** * @see _.defaults */ defaults(object: TObject): TObject; /** * @see _.defaults */ defaults( object: any, ...sources: any[] ): any; } interface LoDashImplicitWrapper { /** * @see _.defaults */ defaults( source: TSource ): LoDashImplicitWrapper; /** * @see _.defaults */ defaults( source1: TSource1, source2: TSource2 ): LoDashImplicitWrapper; /** * @see _.defaults */ defaults( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashImplicitWrapper; /** * @see _.defaults */ defaults( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashImplicitWrapper; /** * @see _.defaults */ defaults(): LoDashImplicitWrapper; /** * @see _.defaults */ defaults(...sources: any[]): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.defaults */ defaults( source: TSource ): LoDashExplicitWrapper; /** * @see _.defaults */ defaults( source1: TSource1, source2: TSource2 ): LoDashExplicitWrapper; /** * @see _.defaults */ defaults( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashExplicitWrapper; /** * @see _.defaults */ defaults( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashExplicitWrapper; /** * @see _.defaults */ defaults(): LoDashExplicitWrapper; /** * @see _.defaults */ defaults(...sources: any[]): LoDashExplicitWrapper; } //_.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( object: any, ...sources: any[]): any; } interface LoDashImplicitWrapper { /** * @see _.defaultsDeep **/ defaultsDeep(...sources: any[]): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.defaultsDeep **/ defaultsDeep(...sources: any[]): LoDashExplicitWrapper; } //_.entries interface LoDashStatic { /** * @see _.toPairs */ entries(object?: Dictionary): Array<[string, T]>; /** * @see _.toPairs */ entries(object?: object): Array<[string, any]>; } interface LoDashImplicitWrapper { /** * @see _.toPairs */ entries(this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; /** * @see _.toPairs */ entries(): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.toPairs */ entries(this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; /** * @see _.toPairs */ entries(): LoDashExplicitWrapper>; } //_.entriesIn interface LoDashStatic { /** * @see _.toPairsIn */ entriesIn(object?: Dictionary): Array<[string, T]>; /** * @see _.toPairsIn */ entriesIn(object?: object): Array<[string, any]>; } interface LoDashImplicitWrapper { /** * @see _.toPairsIn */ entriesIn(this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; /** * @see _.toPairsIn */ entriesIn(): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.toPairsIn */ entriesIn(this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; /** * @see _.toPairsIn */ entriesIn(): LoDashExplicitWrapper>; } // _.extend interface LoDashStatic { /** * @see _.assignIn */ extend( object: TObject, source: TSource ): TObject & TSource; /** * @see _.assignIn */ extend( object: TObject, source1: TSource1, source2: TSource2 ): TObject & TSource1 & TSource2; /** * @see _.assignIn */ extend( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3 ): TObject & TSource1 & TSource2 & TSource3; /** * @see _.assignIn */ extend( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): TObject & TSource1 & TSource2 & TSource3 & TSource4; /** * @see _.assignIn */ extend(object: TObject): TObject; /** * @see _.assignIn */ extend( object: any, ...otherArgs: any[] ): TResult; } interface LoDashImplicitWrapper { /** * @see _.assignIn */ extend( source: TSource ): LoDashImplicitWrapper; /** * @see _.assignIn */ extend( source1: TSource1, source2: TSource2 ): LoDashImplicitWrapper; /** * @see _.assignIn */ extend( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashImplicitWrapper; /** * @see _.assignIn */ extend( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashImplicitWrapper; /** * @see _.assignIn */ extend(): LoDashImplicitWrapper; /** * @see _.assignIn */ extend(...otherArgs: any[]): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.assignIn */ extend( source: TSource ): LoDashExplicitWrapper; /** * @see _.assignIn */ extend( source1: TSource1, source2: TSource2 ): LoDashExplicitWrapper; /** * @see _.assignIn */ extend( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashExplicitWrapper; /** * @see _.assignIn */ extend( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashExplicitWrapper; /** * @see _.assignIn */ extend(): LoDashExplicitWrapper; /** * @see _.assignIn */ extend(...otherArgs: any[]): LoDashExplicitWrapper; } interface LoDashStatic { /** * @see _.assignInWith */ extendWith( object: TObject, source: TSource, customizer: AssignCustomizer ): TObject & TSource; /** * @see _.assignInWith */ extendWith( object: TObject, source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): TObject & TSource1 & TSource2; /** * @see _.assignInWith */ extendWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): TObject & TSource1 & TSource2 & TSource3; /** * @see _.assignInWith */ extendWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): TObject & TSource1 & TSource2 & TSource3 & TSource4; /** * @see _.assignInWith */ extendWith(object: TObject): TObject; /** * @see _.assignInWith */ extendWith( object: any, ...otherArgs: any[] ): TResult; } interface LoDashImplicitWrapper { /** * @see _.assignInWith */ extendWith( source: TSource, customizer: AssignCustomizer ): LoDashImplicitWrapper; /** * @see _.assignInWith */ extendWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashImplicitWrapper; /** * @see _.assignInWith */ extendWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashImplicitWrapper; /** * @see _.assignInWith */ extendWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashImplicitWrapper; /** * @see _.assignInWith */ extendWith(): LoDashImplicitWrapper; /** * @see _.assignInWith */ extendWith(...otherArgs: any[]): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.assignInWith */ extendWith( source: TSource, customizer: AssignCustomizer ): LoDashExplicitWrapper; /** * @see _.assignInWith */ extendWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashExplicitWrapper; /** * @see _.assignInWith */ extendWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashExplicitWrapper; /** * @see _.assignInWith */ extendWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashExplicitWrapper; /** * @see _.assignInWith */ extendWith(): LoDashExplicitWrapper; /** * @see _.assignInWith */ extendWith(...otherArgs: any[]): LoDashExplicitWrapper; } //_.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( object: T | null | undefined, predicate?: ObjectIteratee ): string | undefined; } interface LoDashImplicitWrapper { /** * @see _.findKey */ findKey( this: LoDashImplicitWrapper, predicate?: ObjectIteratee ): string | undefined; } interface LoDashExplicitWrapper { /** * @see _.findKey */ findKey( this: LoDashExplicitWrapper, predicate?: ObjectIteratee ): LoDashExplicitWrapper; } //_.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( object: T | null | undefined, predicate?: ObjectIteratee ): string | undefined; } interface LoDashImplicitWrapper { /** * @see _.findLastKey */ findLastKey( this: LoDashImplicitWrapper, predicate?: ObjectIteratee ): string | undefined; } interface LoDashExplicitWrapper { /** * @see _.findLastKey */ findLastKey( this: LoDashExplicitWrapper, predicate?: ObjectIteratee ): LoDashExplicitWrapper; } //_.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( object: T, iteratee?: ObjectIterator ): T; /** * @see _.forIn */ forIn( object: T | null | undefined, iteratee?: ObjectIterator ): T | null | undefined; } interface LoDashWrapper { /** * @see _.forIn */ forIn( this: LoDashWrapper, iteratee?: ObjectIterator ): this; } //_.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( object: T, iteratee?: ObjectIterator ): T; /** * @see _.forInRight */ forInRight( object: T | null | undefined, iteratee?: ObjectIterator ): T | null | undefined; } interface LoDashWrapper { /** * @see _.forInRight */ forInRight( this: LoDashWrapper, iteratee?: ObjectIterator ): this; } //_.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( object: T, iteratee?: ObjectIterator ): T; /** * @see _.forOwn */ forOwn( object: T | null | undefined, iteratee?: ObjectIterator ): T | null | undefined; } interface LoDashWrapper { /** * @see _.forOwn */ forOwn( this: LoDashWrapper, iteratee?: ObjectIterator ): this; } //_.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( object: T, iteratee?: ObjectIterator ): T; /** * @see _.forOwnRight */ forOwnRight( object: T | null | undefined, iteratee?: ObjectIterator ): T | null | undefined; } interface LoDashWrapper { /** * @see _.forOwnRight */ forOwnRight( this: LoDashWrapper, iteratee?: ObjectIterator ): this; } //_.functions interface LoDashStatic { /** * Creates an array of function property names from own enumerable properties * of `object`. * * @category Object * @param object The object to inspect. * @returns 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(object: any): string[]; } interface LoDashImplicitWrapper { /** * @see _.functions */ functions(): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.functions */ functions(): LoDashExplicitWrapper; } //_.functionsIn interface LoDashStatic { /** * Creates an array of function property names from own and inherited * enumerable properties of `object`. * * @category Object * @param object The object to inspect. * @returns 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(object: any): string[]; } interface LoDashImplicitWrapper { /** * @see _.functionsIn */ functionsIn(): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.functionsIn */ functionsIn(): LoDashExplicitWrapper; } //_.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( object: TObject, path: TKey | [TKey] ): TObject[TKey]; /** * @see _.get */ get( object: TObject | null | undefined, path: TKey | [TKey] ): TObject[TKey] | undefined; /** * @see _.get */ get( object: TObject | null | undefined, path: TKey | [TKey], defaultValue: TDefault ): TObject[TKey] | TDefault; /** * @see _.get */ get( object: null | undefined, path: PropertyPath, defaultValue: TDefault ): TDefault; /** * @see _.get */ get( object: null | undefined, path: PropertyPath ): undefined; /** * @see _.get */ get( object: any, path: PropertyPath, defaultValue?: any ): any; } interface LoDashImplicitWrapper { /** * @see _.get */ get( path: TKey | [TKey] ): TValue[TKey]; /** * @see _.get */ get( this: LoDashImplicitWrapper, path: TKey | [TKey], ): TObject[TKey] | undefined; /** * @see _.get */ get( this: LoDashImplicitWrapper, path: TKey | [TKey], defaultValue: TDefault ): TObject[TKey] | TDefault; /** * @see _.get */ get( this: LoDashImplicitWrapper, path: PropertyPath, defaultValue: TDefault ): TDefault; /** * @see _.get */ get( this: LoDashImplicitWrapper, path: PropertyPath ): undefined; /** * @see _.get */ get( path: PropertyPath, defaultValue?: any ): any; } interface LoDashExplicitWrapper { /** * @see _.get */ get( path: TKey | [TKey] ): LoDashExplicitWrapper; /** * @see _.get */ get( this: LoDashExplicitWrapper, path: TKey | [TKey], ): LoDashExplicitWrapper; /** * @see _.get */ get( this: LoDashExplicitWrapper, path: TKey | [TKey], defaultValue: TDefault ): LoDashExplicitWrapper; /** * @see _.get */ get( this: LoDashExplicitWrapper, path: PropertyPath, defaultValue: TDefault ): LoDashExplicitWrapper; /** * @see _.get */ get( this: LoDashExplicitWrapper, path: PropertyPath ): LoDashExplicitWrapper; /** * @see _.get */ get( path: PropertyPath, defaultValue?: any ): LoDashExplicitWrapper; } //_.has interface LoDashStatic { /** * Checks if `path` is a direct property of `object`. * * @category Object * @param object The object to query. * @param path The path to check. * @returns 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( object: T, path: PropertyPath ): boolean; } interface LoDashImplicitWrapper { /** * @see _.has */ has(path: PropertyPath): boolean; } interface LoDashExplicitWrapper { /** * @see _.has */ has(path: PropertyPath): LoDashExplicitWrapper; } //_.hasIn interface LoDashStatic { /** * Checks if `path` is a direct or inherited property of `object`. * * @category Object * @param object The object to query. * @param path The path to check. * @returns 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( object: T, path: PropertyPath ): boolean; } interface LoDashImplicitWrapper { /** * @see _.hasIn */ hasIn(path: PropertyPath): boolean; } interface LoDashExplicitWrapper { /** * @see _.hasIn */ hasIn(path: PropertyPath): LoDashExplicitWrapper; } //_.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( object: object ): Dictionary; } interface LoDashImplicitWrapper { /** * @see _.invert */ invert(): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.invert */ invert(): LoDashExplicitWrapper>; } //_.invertBy 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: List | Dictionary | NumericDictionary | null | undefined, interatee?: ValueIteratee ): Dictionary; /** * @see _.invertBy */ invertBy( object: T | null | undefined, interatee?: ValueIteratee ): Dictionary; } interface LoDashImplicitWrapper { /** * @see _.invertBy */ invertBy( this: LoDashImplicitWrapper | Dictionary | NumericDictionary | null | undefined>, interatee?: ValueIteratee ): LoDashImplicitWrapper>; /** * @see _.invertBy */ invertBy( this: LoDashImplicitWrapper, interatee?: ValueIteratee ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.invertBy */ invertBy( this: LoDashExplicitWrapper | Dictionary | NumericDictionary | null | undefined>, interatee?: ValueIteratee ): LoDashExplicitWrapper>; /** * @see _.invertBy */ invertBy( this: LoDashExplicitWrapper, interatee?: ValueIteratee ): LoDashExplicitWrapper>; } //_.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 LoDashImplicitWrapper { /** * @see _.keys */ keys(): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.keys */ keys(): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.keysIn */ keysIn(): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.keysIn */ keysIn(): LoDashExplicitWrapper; } //_.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( object: List | null | undefined, iteratee?: ListIteratee ): Dictionary; /** * @see _.mapKeys */ mapKeys( object: Dictionary | null | undefined, iteratee?: DictionaryIteratee ): Dictionary; /** * @see _.mapKeys */ mapKeys( object: object | null | undefined, iteratee?: ObjectIteratee ): Dictionary; } interface LoDashImplicitWrapper { /** * @see _.mapKeys */ mapKeys( this: LoDashImplicitWrapper | null | undefined>, iteratee?: ListIteratee ): LoDashImplicitWrapper>; /** * @see _.mapKeys */ mapKeys( this: LoDashImplicitWrapper | null | undefined>, iteratee?: DictionaryIteratee ): LoDashImplicitWrapper>; /** * @see _.mapKeys */ mapKeys( this: LoDashImplicitWrapper, iteratee?: ObjectIteratee ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.mapKeys */ mapKeys( this: LoDashExplicitWrapper | null | undefined>, iteratee?: ListIteratee ): LoDashExplicitWrapper>; /** * @see _.mapKeys */ mapKeys( this: LoDashExplicitWrapper | null | undefined>, iteratee?: DictionaryIteratee ): LoDashExplicitWrapper>; /** * @see _.mapKeys */ mapKeys( this: LoDashExplicitWrapper, iteratee?: ObjectIteratee ): LoDashExplicitWrapper>; } //_.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 The object to iterate over. * @param [iteratee=_.identity] The function invoked per iteration. * @param [thisArg] The `this` binding of `iteratee`. * @return Returns the new mapped object. */ mapValues(obj: T | null | undefined, callback: ObjectIterator): { [P in keyof T]: TResult }; /** * @see _.mapValues */ mapValues(obj: T | null | undefined, iteratee: object): { [P in keyof T]: boolean }; /** * @see _.mapValues */ mapValues(obj: Dictionary | null | undefined, iteratee: TKey): Dictionary; /** * @see _.mapValues */ mapValues(obj: T | null | undefined, iteratee: string): { [P in keyof T]: any }; /** * @see _.mapValues */ mapValues(obj: string | null | undefined, callback: StringIterator): NumericDictionary; /** * @see _.mapValues */ mapValues(obj: Dictionary | null | undefined): Dictionary; /** * @see _.mapValues */ mapValues(obj: T): T; /** * @see _.mapValues */ mapValues(obj: T | null | undefined): T | {}; /** * @see _.mapValues */ mapValues(obj: string | null | undefined): NumericDictionary; } interface LoDashImplicitWrapper { /** * @see _.mapValues */ mapValues( this: LoDashImplicitWrapper, callback: ObjectIterator ): LoDashImplicitWrapper<{ [P in keyof T]: TResult }>; /** * @see _.mapValues */ mapValues( this: LoDashImplicitWrapper, iteratee: object ): LoDashImplicitWrapper<{ [P in keyof T]: boolean }>; /** * @see _.mapValues */ mapValues( this: LoDashImplicitWrapper | null | undefined>, iteratee: TKey ): LoDashImplicitWrapper>; /** * @see _.mapValues */ mapValues( this: LoDashImplicitWrapper, iteratee: string ): LoDashImplicitWrapper<{ [P in keyof T]: any }>; /** * @see _.mapValues */ mapValues( this: LoDashImplicitWrapper, callback: StringIterator ): LoDashImplicitWrapper>; /** * @see _.mapValues */ mapValues(this: LoDashImplicitWrapper | null | undefined>): LoDashImplicitWrapper>; /** * @see _.mapValues */ mapValues(this: LoDashImplicitWrapper): LoDashImplicitWrapper; /** * @see _.mapValues */ mapValues(this: LoDashImplicitWrapper): LoDashImplicitWrapper; /** * @see _.mapValues */ mapValues(this: LoDashImplicitWrapper): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.mapValues */ mapValues( this: LoDashExplicitWrapper, callback: ObjectIterator ): LoDashExplicitWrapper<{ [P in keyof T]: TResult }>; /** * @see _.mapValues */ mapValues( this: LoDashExplicitWrapper, iteratee: object ): LoDashExplicitWrapper<{ [P in keyof T]: boolean }>; /** * @see _.mapValues */ mapValues( this: LoDashExplicitWrapper | null | undefined>, iteratee: TKey ): LoDashExplicitWrapper>; /** * @see _.mapValues */ mapValues( this: LoDashExplicitWrapper, iteratee: string ): LoDashExplicitWrapper<{ [P in keyof T]: any }>; /** * @see _.mapValues */ mapValues( this: LoDashExplicitWrapper, callback: StringIterator ): LoDashExplicitWrapper>; /** * @see _.mapValues */ mapValues(this: LoDashExplicitWrapper | null | undefined>): LoDashExplicitWrapper>; /** * @see _.mapValues */ mapValues(this: LoDashExplicitWrapper): LoDashExplicitWrapper; /** * @see _.mapValues */ mapValues(this: LoDashExplicitWrapper): LoDashExplicitWrapper; /** * @see _.mapValues */ mapValues(this: LoDashExplicitWrapper): LoDashExplicitWrapper>; } //_.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`. * * @category Object * @param object The destination object. * @param [sources] The source objects. * @returns 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( object: TObject, source: TSource ): TObject & TSource; /** * @see _.merge */ merge( object: TObject, source1: TSource1, source2: TSource2 ): TObject & TSource1 & TSource2; /** * @see _.merge */ merge( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3 ): TObject & TSource1 & TSource2 & TSource3; /** * @see _.merge */ merge( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): TObject & TSource1 & TSource2 & TSource3 & TSource4; /** * @see _.merge */ merge( object: any, ...otherArgs: any[] ): any; } interface LoDashImplicitWrapper { /** * @see _.merge */ merge( source: TSource ): LoDashImplicitWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2 ): LoDashImplicitWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashImplicitWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashImplicitWrapper; /** * @see _.merge */ merge( ...otherArgs: any[] ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.merge */ merge( source: TSource ): LoDashExplicitWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2 ): LoDashExplicitWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashExplicitWrapper; /** * @see _.merge */ merge( ): LoDashExplicitWrapper; /** * @see _.merge */ merge( ...otherArgs: any[] ): LoDashExplicitWrapper; } //_.mergeWith type MergeWithCustomizer = { bivariantHack(value: any, srcValue: any, key: string, object: any, source: any): any; }["bivariantHack"] 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). * * @category Object * @param object The destination object. * @param sources The source objects. * @param customizer The function to customize assigned values. * @returns 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( object: TObject, source: TSource, customizer: MergeWithCustomizer ): TObject & TSource; /** * @see _.mergeWith */ mergeWith( object: TObject, source1: TSource1, source2: TSource2, customizer: MergeWithCustomizer ): TObject & TSource1 & TSource2; /** * @see _.mergeWith */ mergeWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: MergeWithCustomizer ): TObject & TSource1 & TSource2 & TSource3; /** * @see _.mergeWith */ mergeWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: MergeWithCustomizer ): TObject & TSource1 & TSource2 & TSource3 & TSource4; /** * @see _.mergeWith */ mergeWith( object: any, ...otherArgs: any[] ): any; } interface LoDashImplicitWrapper { /** * @see _.mergeWith */ mergeWith( source: TSource, customizer: MergeWithCustomizer ): LoDashImplicitWrapper; /** * @see _.mergeWith */ mergeWith( source1: TSource1, source2: TSource2, customizer: MergeWithCustomizer ): LoDashImplicitWrapper; /** * @see _.mergeWith */ mergeWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: MergeWithCustomizer ): LoDashImplicitWrapper; /** * @see _.mergeWith */ mergeWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: MergeWithCustomizer ): LoDashImplicitWrapper; /** * @see _.mergeWith */ mergeWith( ...otherArgs: any[] ): LoDashImplicitWrapper; } //_.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. * * @category Object * @param object The source object. * @param [paths] The property names to omit, specified * individually or in arrays.. * @returns Returns the new object. * @example * * var object = { 'a': 1, 'b': '2', 'c': 3 }; * * _.omit(object, ['a', 'c']); * // => { 'b': '2' } */ omit( object: Dictionary, ...paths: PropertyPath[] ): Dictionary; /** * @see _.omit */ omit( object: T | null | undefined, ...paths: PropertyPath[] ): PartialObject; } interface LoDashImplicitWrapper { /** * @see _.omit */ omit( this: LoDashImplicitWrapper>, ...paths: PropertyPath[] ): LoDashImplicitWrapper>; /** * @see _.omit */ omit( this: LoDashImplicitWrapper, ...paths: PropertyPath[] ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.omit */ omit( this: LoDashExplicitWrapper>, ...paths: PropertyPath[] ): LoDashExplicitWrapper>; /** * @see _.omit */ omit( this: LoDashExplicitWrapper, ...paths: PropertyPath[] ): LoDashExplicitWrapper>; } //_.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. * * @category Object * @param object The source object. * @param [predicate=_.identity] The function invoked per property. * @returns Returns the new object. * @example * * var object = { 'a': 1, 'b': '2', 'c': 3 }; * * _.omitBy(object, _.isNumber); * // => { 'b': '2' } */ omitBy( object: T | null | undefined, predicate: ValueKeyIteratee ): PartialObject; } interface LoDashImplicitWrapper { /** * @see _.omitBy */ omitBy( this: LoDashImplicitWrapper, predicate: ValueKeyIteratee ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.omitBy */ omitBy( this: LoDashExplicitWrapper, predicate: ValueKeyIteratee ): LoDashExplicitWrapper>; } //_.pick interface LoDashStatic { /** * Creates an object composed of the picked `object` properties. * * @category Object * @param object The source object. * @param [props] The property names to pick, specified * individually or in arrays. * @returns Returns the new object. * @example * * var object = { 'a': 1, 'b': '2', 'c': 3 }; * * _.pick(object, ['a', 'c']); * // => { 'a': 1, 'c': 3 } */ pick( object: T, ...props: Array> ): Pick; /** * @see _.pick */ pick( object: T | null | undefined, ...props: PropertyPath[] ): PartialDeep; } interface LoDashImplicitWrapper { /** * @see _.pick */ pick( this: LoDashImplicitWrapper, ...props: Array> ): LoDashImplicitWrapper>; /** * @see _.pick */ pick( this: LoDashImplicitWrapper, ...props: PropertyPath[] ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.pick */ pick( this: LoDashExplicitWrapper, ...props: Array> ): LoDashExplicitWrapper>; /** * @see _.pick */ pick( this: LoDashExplicitWrapper, ...props: PropertyPath[] ): LoDashExplicitWrapper>; } //_.pickBy interface LoDashStatic { /** * Creates an object composed of the `object` properties `predicate` returns * truthy for. The predicate is invoked with two arguments: (value, key). * * @category Object * @param object The source object. * @param [predicate=_.identity] The function invoked per property. * @returns Returns the new object. * @example * * var object = { 'a': 1, 'b': '2', 'c': 3 }; * * _.pickBy(object, _.isNumber); * // => { 'a': 1, 'c': 3 } */ pickBy( object: T | null | undefined, predicate?: ValueKeyIteratee ): PartialObject; } interface LoDashImplicitWrapper { /** * @see _.pickBy */ pickBy( this: LoDashImplicitWrapper, predicate?: ValueKeyIteratee ): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.pickBy */ pickBy( this: LoDashExplicitWrapper, predicate?: ValueKeyIteratee ): LoDashExplicitWrapper>; } //_.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( object: any, path: PropertyPath, defaultValue?: TResult|((...args: any[]) => TResult) ): TResult; } interface LoDashImplicitWrapper { /** * @see _.result */ result( path: PropertyPath, defaultValue?: TResult|((...args: any[]) => TResult) ): TResult; } interface LoDashExplicitWrapper { /** * @see _.result */ result( path: PropertyPath, defaultValue?: TResult|((...args: any[]) => TResult) ): LoDashExplicitWrapper; } //_.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( object: T, path: PropertyPath, value: any ): T; /** * @see _.set */ set( object: object, path: PropertyPath, value: any ): TResult; } interface LoDashImplicitWrapper { /** * @see _.set */ set( path: PropertyPath, value: any ): this; /** * @see _.set */ set( path: PropertyPath, value: any ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.set */ set( path: PropertyPath, value: any ): this; /** * @see _.set */ set( path: PropertyPath, value: any ): LoDashExplicitWrapper; } //_.setWith type SetWithCustomizer = (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( object: T, path: PropertyPath, value: any, customizer?: SetWithCustomizer ): T; setWith( object: T, path: PropertyPath, value: any, customizer?: SetWithCustomizer ): TResult; } interface LoDashImplicitWrapper { /** * @see _.setWith */ setWith( path: PropertyPath, value: any, customizer?: SetWithCustomizer ): this; /** * @see _.setWith */ setWith( path: PropertyPath, value: any, customizer?: SetWithCustomizer ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.setWith */ setWith( path: PropertyPath, value: any, customizer?: SetWithCustomizer ): this; /** * @see _.setWith */ setWith( path: PropertyPath, value: any, customizer?: SetWithCustomizer ): LoDashExplicitWrapper; } //_.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(object?: Dictionary): Array<[string, T]>; /** * @see _.toPairs */ toPairs(object?: object): Array<[string, any]>; } interface LoDashImplicitWrapper { /** * @see _.toPairs */ toPairs(this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; /** * @see _.toPairs */ toPairs(): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.toPairs */ toPairs(this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; /** * @see _.toPairs */ toPairs(): LoDashExplicitWrapper>; } //_.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(object?: Dictionary): Array<[string, T]>; /** * @see _.toPairsIn */ toPairsIn(object?: object): Array<[string, any]>; } interface LoDashImplicitWrapper { /** * @see _.toPairsIn */ toPairsIn(this: LoDashImplicitWrapper>): LoDashImplicitWrapper>; /** * @see _.toPairsIn */ toPairsIn(): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.toPairsIn */ toPairsIn(this: LoDashExplicitWrapper>): LoDashExplicitWrapper>; /** * @see _.toPairsIn */ toPairsIn(): LoDashExplicitWrapper>; } //_.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( object: T[], iteratee: MemoVoidArrayIterator, accumulator?: TResult[] ): TResult[]; /** * @see _.transform */ transform( object: T[], iteratee: MemoVoidArrayIterator>, accumulator: Dictionary ): Dictionary; /** * @see _.transform */ transform( object: Dictionary, iteratee: MemoVoidDictionaryIterator>, accumulator?: Dictionary ): Dictionary; /** * @see _.transform */ transform( object: Dictionary, iteratee: MemoVoidDictionaryIterator, accumulator: TResult[] ): TResult[]; /** * @see _.transform */ transform( object: any[], ): any[]; /** * @see _.transform */ transform( object: object, ): Dictionary; } interface LoDashImplicitWrapper { /** * @see _.transform */ transform( this: LoDashImplicitWrapper, iteratee: MemoVoidArrayIterator, accumulator?: TResult[] ): LoDashImplicitWrapper; /** * @see _.transform */ transform( this: LoDashImplicitWrapper, iteratee: MemoVoidArrayIterator>, accumulator: Dictionary ): LoDashImplicitWrapper>; /** * @see _.transform */ transform( this: LoDashImplicitWrapper>, iteratee: MemoVoidDictionaryIterator>, accumulator?: Dictionary ): LoDashImplicitWrapper>; /** * @see _.transform */ transform( this: LoDashImplicitWrapper>, iteratee: MemoVoidDictionaryIterator, accumulator: TResult[] ): LoDashImplicitWrapper; /** * @see _.transform */ transform( this: LoDashImplicitWrapper, ): LoDashImplicitWrapper; /** * @see _.transform */ transform(): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.transform */ transform( this: LoDashExplicitWrapper, iteratee: MemoVoidArrayIterator, accumulator?: TResult[] ): LoDashExplicitWrapper; /** * @see _.transform */ transform( this: LoDashExplicitWrapper, iteratee: MemoVoidArrayIterator>, accumulator?: Dictionary ): LoDashExplicitWrapper>; /** * @see _.transform */ transform( this: LoDashExplicitWrapper>, iteratee: MemoVoidDictionaryIterator>, accumulator?: Dictionary ): LoDashExplicitWrapper>; /** * @see _.transform */ transform( this: LoDashExplicitWrapper>, iteratee: MemoVoidDictionaryIterator, accumulator?: TResult[] ): LoDashExplicitWrapper; /** * @see _.transform */ transform( this: LoDashExplicitWrapper, ): LoDashExplicitWrapper; /** * @see _.transform */ transform(): LoDashExplicitWrapper>; } //_.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( object: any, path: PropertyPath ): boolean; } interface LoDashImplicitWrapper { /** * @see _.unset */ unset(path: PropertyPath): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.unset */ unset(path: PropertyPath): LoDashExplicitWrapper; } //_.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( object: object, path: PropertyPath, updater: (value: any) => any ): any; } interface LoDashImplicitWrapper { /** * @see _.update */ update( path: PropertyPath, updater: (value: any) => any ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.update */ update( path: PropertyPath, updater: (value: any) => any ): LoDashExplicitWrapper; } //_.updateWith interface LoDashStatic { /** * This method is like `_.update` 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). * * **Note:** This method mutates `object`. * * @since 4.6.0 * @category Object * @param object The object to modify. * @param path The path of the property to set. * @param updater The function to produce the updated value. * @param [customizer] The function to customize assigned values. * @returns Returns `object`. * @example * * var object = {}; * * _.updateWith(object, '[0][1]', _.constant('a'), Object); * // => { '0': { '1': 'a' } } */ updateWith( object: T, path: PropertyPath, updater: (oldValue: any) => any, customizer?: SetWithCustomizer ): T; /** * @see _.updateWith */ updateWith( object: T, path: PropertyPath, updater: (oldValue: any) => any, customizer?: SetWithCustomizer ): TResult; } interface LoDashImplicitWrapper { /** * @see _.updateWith */ updateWith( path: PropertyPath, updater: (oldValue: any) => any, customizer?: SetWithCustomizer ): this; /** * @see _.updateWith */ updateWith( path: PropertyPath, updater: (oldValue: any) => any, customizer?: SetWithCustomizer ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.updateWith */ updateWith( path: PropertyPath, updater: (oldValue: any) => any, customizer?: SetWithCustomizer ): this; /** * @see _.updateWith */ updateWith( path: PropertyPath, updater: (oldValue: any) => any, customizer?: SetWithCustomizer ): LoDashExplicitWrapper; } //_.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(object: Dictionary|NumericDictionary|List | null | undefined): T[]; /** * @see _.values */ values(object: T | null | undefined): Array; /** * @see _.values */ values(object: any): any[]; } interface LoDashImplicitWrapper { /** * @see _.values */ values(this: LoDashImplicitWrapper | NumericDictionary | List | null | undefined>): LoDashImplicitWrapper; /** * @see _.values */ values(this: LoDashImplicitWrapper): LoDashImplicitWrapper>; /** * @see _.values */ values(): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.values */ values(this: LoDashExplicitWrapper | NumericDictionary | List | null | undefined>): LoDashExplicitWrapper; /** * @see _.values */ values(this: LoDashExplicitWrapper): LoDashExplicitWrapper>; /** * @see _.values */ values(): LoDashExplicitWrapper; } //_.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(object: Dictionary|NumericDictionary|List | null | undefined): T[]; /** * @see _.valuesIn */ valuesIn(object: T | null | undefined): Array; } interface LoDashImplicitWrapper { /** * @see _.valuesIn */ valuesIn(this: LoDashImplicitWrapper | NumericDictionary | List | null | undefined>): LoDashImplicitWrapper; /** * @see _.valuesIn */ valuesIn(this: LoDashImplicitWrapper): LoDashImplicitWrapper>; } interface LoDashExplicitWrapper { /** * @see _.valuesIn */ valuesIn(this: LoDashExplicitWrapper | NumericDictionary | List | null | undefined>): LoDashExplicitWrapper; /** * @see _.valuesIn */ valuesIn(this: LoDashExplicitWrapper): LoDashExplicitWrapper>; } /********** * 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 { /** * @see _.camelCase */ camelCase(): string; } interface LoDashExplicitWrapper { /** * @see _.camelCase */ camelCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.capitalize */ capitalize(): string; } interface LoDashExplicitWrapper { /** * @see _.capitalize */ capitalize(): LoDashExplicitWrapper; } //_.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 { /** * @see _.deburr */ deburr(): string; } interface LoDashExplicitWrapper { /** * @see _.deburr */ deburr(): LoDashExplicitWrapper; } //_.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 { /** * @see _.endsWith */ endsWith( target?: string, position?: number ): boolean; } interface LoDashExplicitWrapper { /** * @see _.endsWith */ endsWith( target?: string, position?: number ): LoDashExplicitWrapper; } // _.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 { /** * @see _.escape */ escape(): string; } interface LoDashExplicitWrapper { /** * @see _.escape */ escape(): LoDashExplicitWrapper; } // _.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 { /** * @see _.escapeRegExp */ escapeRegExp(): string; } interface LoDashExplicitWrapper { /** * @see _.escapeRegExp */ escapeRegExp(): LoDashExplicitWrapper; } //_.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 { /** * @see _.kebabCase */ kebabCase(): string; } interface LoDashExplicitWrapper { /** * @see _.kebabCase */ kebabCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.lowerCase */ lowerCase(): string; } interface LoDashExplicitWrapper { /** * @see _.lowerCase */ lowerCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.lowerFirst */ lowerFirst(): string; } interface LoDashExplicitWrapper { /** * @see _.lowerFirst */ lowerFirst(): LoDashExplicitWrapper; } //_.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 { /** * @see _.pad */ pad( length?: number, chars?: string ): string; } interface LoDashExplicitWrapper { /** * @see _.pad */ pad( length?: number, chars?: string ): LoDashExplicitWrapper; } //_.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 { /** * @see _.padEnd */ padEnd( length?: number, chars?: string ): string; } interface LoDashExplicitWrapper { /** * @see _.padEnd */ padEnd( length?: number, chars?: string ): LoDashExplicitWrapper; } //_.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 { /** * @see _.padStart */ padStart( length?: number, chars?: string ): string; } interface LoDashExplicitWrapper { /** * @see _.padStart */ padStart( length?: number, chars?: string ): LoDashExplicitWrapper; } //_.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 { /** * @see _.parseInt */ parseInt(radix?: number): number; } interface LoDashExplicitWrapper { /** * @see _.parseInt */ parseInt(radix?: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.repeat */ repeat(n?: number): string; } interface LoDashExplicitWrapper { /** * @see _.repeat */ repeat(n?: number): LoDashExplicitWrapper; } type ReplaceFunction = (match: string, ...args: any[]) => string; //_.replace interface LoDashStatic { /** * Replaces matches for pattern in string with replacement. * * Note: This method is based on String#replace. * * @return Returns the modified string. */ replace( string: string, pattern: RegExp | string, replacement: ReplaceFunction | string ): string; /** * @see _.replace */ replace( pattern: RegExp | string, replacement: ReplaceFunction | string ): string; } interface LoDashImplicitWrapper { /** * @see _.replace */ replace( pattern: RegExp|string, replacement: ReplaceFunction | string ): string; /** * @see _.replace */ replace( replacement: ReplaceFunction | string ): string; } interface LoDashExplicitWrapper { /** * @see _.replace */ replace( pattern: RegExp | string, replacement: ReplaceFunction | string ): LoDashExplicitWrapper; /** * @see _.replace */ replace( replacement: ReplaceFunction | string ): LoDashExplicitWrapper; } //_.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 { /** * @see _.snakeCase */ snakeCase(): string; } interface LoDashExplicitWrapper { /** * @see _.snakeCase */ snakeCase(): LoDashExplicitWrapper; } //_.split interface LoDashStatic { /** * Splits string by separator. * * Note: This method is based on String#split. * * @param string The string to trim. * @param separator The separator pattern to split by. * @param limit The length to truncate results to. * @return Returns the new array of string segments. */ split( string: string, separator?: RegExp|string, limit?: number ): string[]; /** * Splits string by separator. * * Note: This method is based on String#split. * * @param string The string to trim. * @param index Not used in this overload. * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code. * @return Returns the new array of string segments. */ split( string: string, index: string | number, guard: object ): string[]; } interface LoDashImplicitWrapper { /** * @see _.split */ split( separator?: RegExp|string, limit?: number ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.split */ split( separator?: RegExp|string, limit?: number ): LoDashExplicitWrapper; } //_.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 { /** * @see _.startCase */ startCase(): string; } interface LoDashExplicitWrapper { /** * @see _.startCase */ startCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.startsWith */ startsWith( target?: string, position?: number ): boolean; } interface LoDashExplicitWrapper { /** * @see _.startsWith */ startsWith( target?: string, position?: number ): LoDashExplicitWrapper; } //_.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 { /** * @see _.template */ template(options?: TemplateOptions): TemplateExecutor; } interface LoDashExplicitWrapper { /** * @see _.template */ template(options?: TemplateOptions): LoDashExplicitWrapper; } //_.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 { /** * @see _.toLower */ toLower(): string; } interface LoDashExplicitWrapper { /** * @see _.toLower */ toLower(): LoDashExplicitWrapper; } //_.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 { /** * @see _.toUpper */ toUpper(): string; } interface LoDashExplicitWrapper { /** * @see _.toUpper */ toUpper(): LoDashExplicitWrapper; } //_.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; /** * Removes leading and trailing whitespace or specified characters from string. * * @param string The string to trim. * @param index Not used in this overload. * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code. * @return Returns the trimmed string. */ trim( string: string, index: string | number, guard: object ): string; } interface LoDashImplicitWrapper { /** * @see _.trim */ trim(chars?: string): string; } interface LoDashExplicitWrapper { /** * @see _.trim */ trim(chars?: string): LoDashExplicitWrapper; } //_.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; /** * Removes trailing whitespace or specified characters from string. * * @param string The string to trim. * @param index Not used in this overload. * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code. * @return Returns the trimmed string. */ trimEnd( string: string, index: string | number, guard: object ): string; } interface LoDashImplicitWrapper { /** * @see _.trimEnd */ trimEnd(chars?: string): string; } interface LoDashExplicitWrapper { /** * @see _.trimEnd */ trimEnd(chars?: string): LoDashExplicitWrapper; } //_.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; /** * Removes leading whitespace or specified characters from string. * * @param string The string to trim. * @param index Not used in this overload. * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code. * @return Returns the trimmed string. */ trimStart( string: string, index: string | number, guard: object ): string; } interface LoDashImplicitWrapper { /** * @see _.trimStart */ trimStart(chars?: string): string; } interface LoDashExplicitWrapper { /** * @see _.trimStart */ trimStart(chars?: string): LoDashExplicitWrapper; } //_.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 { /** * @see _.truncate */ truncate(options?: TruncateOptions): string; } interface LoDashExplicitWrapper { /** * @see _.truncate */ truncate(options?: TruncateOptions): LoDashExplicitWrapper; } //_.unescape interface LoDashStatic { /** * The inverse of _.escape; this method converts the HTML entities &, <, >, ", ', and ` * 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 { /** * @see _.unescape */ unescape(): string; } interface LoDashExplicitWrapper { /** * @see _.unescape */ unescape(): LoDashExplicitWrapper; } //_.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 { /** * @see _.upperCase */ upperCase(): string; } interface LoDashExplicitWrapper { /** * @see _.upperCase */ upperCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.upperFirst */ upperFirst(): string; } interface LoDashExplicitWrapper { /** * @see _.upperFirst */ upperFirst(): LoDashExplicitWrapper; } //_.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[]; /** * Splits `string` into an array of its words. * * @param string The string to inspect. * @param index Not used in this overload. * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code. * @return Returns the words of `string`. */ words( string: string, index: string | number, guard: object ): string[]; } interface LoDashImplicitWrapper { /** * @see _.words */ words(pattern?: string|RegExp): string[]; } interface LoDashExplicitWrapper { /** * @see _.words */ words(pattern?: string|RegExp): LoDashExplicitWrapper; } /*********** * 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(func: (...args: any[]) => TResult, ...args: any[]): TResult|Error; } interface LoDashImplicitWrapper { /** * @see _.attempt */ attempt(...args: any[]): TResult|Error; } interface LoDashExplicitWrapper { /** * @see _.attempt */ attempt(...args: any[]): LoDashExplicitWrapper; } //_.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(value: T): () => T; } interface LoDashImplicitWrapper { /** * @see _.constant */ constant(): LoDashImplicitWrapper<() => TValue>; } interface LoDashExplicitWrapper { /** * @see _.constant */ constant(): LoDashExplicitWrapper<() => TValue>; } //_.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(value: T | null | undefined, defaultValue: T): T; /** * @see _.defaultTo */ defaultTo( value: T | null | undefined, defaultValue: TDefault ): T | TDefault; } interface LoDashImplicitWrapper { /** * @see _.defaultTo */ defaultTo(this: LoDashImplicitWrapper, defaultValue: T): T; /** * @see _.defaultTo */ defaultTo( this: LoDashImplicitWrapper, defaultValue: TDefault ): T | TDefault; } interface LoDashExplicitWrapper { /** * @see _.defaultTo */ defaultTo(this: LoDashExplicitWrapper, defaultValue: T): LoDashExplicitWrapper; /** * @see _.defaultTo */ defaultTo( this: LoDashExplicitWrapper, defaultValue: TDefault ): LoDashExplicitWrapper; } //_.identity interface LoDashStatic { /** * This method returns the first argument provided to it. * * @param value Any value. * @return Returns value. */ identity(value: T): T; /** * @see _.identity */ identity(): undefined; } interface LoDashImplicitWrapper { /** * @see _.identity */ identity(): TValue; } interface LoDashExplicitWrapper { /** * @see _.identity */ identity(): this; } //_.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`. * * @category Util * @param [func=_.identity] The value to convert to a callback. * @returns 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 any>( func: TFunction | string | object ): TFunction; /** * @see _.iteratee */ iteratee(): typeof _.identity; // tslint:disable-line:no-unnecessary-qualifier } interface LoDashImplicitWrapper { /** * @see _.iteratee */ iteratee any>( this: LoDashImplicitWrapper ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.iteratee */ iteratee any>( this: LoDashExplicitWrapper ): LoDashExplicitWrapper; } //_.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(source: T): (value: any) => boolean; /** * @see _.matches */ matches(source: T): (value: V) => boolean; } interface LoDashImplicitWrapper { /** * @see _.matches */ matches(): LoDashImplicitWrapper<(value: V) => boolean>; } interface LoDashExplicitWrapper { /** * @see _.matches */ matches(): LoDashExplicitWrapper<(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( path: PropertyPath, srcValue: T ): (value: any) => boolean; /** * @see _.matchesProperty */ matchesProperty( path: PropertyPath, srcValue: T ): (value: V) => boolean; } interface LoDashImplicitWrapper { /** * @see _.matchesProperty */ matchesProperty( srcValue: SrcValue ): LoDashImplicitWrapper<(value: any) => boolean>; /** * @see _.matchesProperty */ matchesProperty( srcValue: SrcValue ): LoDashImplicitWrapper<(value: Value) => boolean>; } interface LoDashExplicitWrapper { /** * @see _.matchesProperty */ matchesProperty( srcValue: SrcValue ): LoDashExplicitWrapper<(value: any) => boolean>; /** * @see _.matchesProperty */ matchesProperty( srcValue: SrcValue ): LoDashExplicitWrapper<(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( path: PropertyPath, ...args: any[] ): (object: any) => any; } interface LoDashImplicitWrapper { /** * @see _.method */ method(...args: any[]): LoDashImplicitWrapper<(object: any) => any>; } interface LoDashExplicitWrapper { /** * @see _.method */ method(...args: any[]): LoDashExplicitWrapper<(object: any) => any>; } //_.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( object: object, ...args: any[] ): (path: PropertyPath) => any; } interface LoDashImplicitWrapper { /** * @see _.methodOf */ methodOf( ...args: any[] ): LoDashImplicitWrapper<(path: PropertyPath) => any>; } interface LoDashExplicitWrapper { /** * @see _.methodOf */ methodOf( ...args: any[] ): LoDashExplicitWrapper<(path: PropertyPath) => any>; } //_.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( object: TObject, source: Dictionary<(...args: any[]) => any>, options?: MixinOptions ): TObject; /** * @see _.mixin */ mixin( source: Dictionary<(...args: any[]) => any>, options?: MixinOptions ): LoDashStatic; } interface LoDashImplicitWrapper { /** * @see _.mixin */ mixin( source: Dictionary<(...args: any[]) => any>, options?: MixinOptions ): this; /** * @see _.mixin */ mixin( options?: MixinOptions ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.mixin */ mixin( source: Dictionary<(...args: any[]) => any>, options?: MixinOptions ): this; /** * @see _.mixin */ mixin( options?: MixinOptions ): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.noConflict */ noConflict(): typeof _; } interface LoDashExplicitWrapper { /** * @see _.noConflict */ noConflict(): LoDashExplicitWrapper; } //_.noop interface LoDashStatic { /** * A no-operation function that returns undefined regardless of the arguments it receives. * * @return undefined */ noop(...args: any[]): void; } interface LoDashImplicitWrapper { /** * @see _.noop */ noop(...args: any[]): void; } interface LoDashExplicitWrapper { /** * @see _.noop */ noop(...args: any[]): LoDashExplicitWrapper; } //_.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(n?: number): (...args: any[]) => any; } interface LoDashImplicitWrapper { /** * @see _.nthArg */ nthArg(): LoDashImplicitWrapper<(...args: any[]) => any>; } interface LoDashExplicitWrapper { /** * @see _.nthArg */ nthArg(): LoDashExplicitWrapper<(...args: any[]) => any>; } //_.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(...iteratees: Array TResult>>): (...args: any[]) => TResult[]; } interface LoDashImplicitWrapper { /** * @see _.over */ over( this: LoDashImplicitWrapper TResult>>, ...iteratees: Array TResult>> ): LoDashImplicitWrapper<(...args: any[]) => TResult[]>; } interface LoDashExplicitWrapper { /** * @see _.over */ over( this: LoDashExplicitWrapper TResult>>, ...iteratees: Array TResult>> ): LoDashExplicitWrapper<(...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: Array boolean>>): (...args: T[]) => boolean; } interface LoDashImplicitWrapper { /** * @see _.overEvery */ overEvery(...predicates: Array boolean>>): LoDashImplicitWrapper<(...args: T[]) => boolean>; } interface LoDashExplicitWrapper { /** * @see _.overEvery */ overEvery(...predicates: Array boolean>>): LoDashExplicitWrapper<(...args: T[]) => 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: Array boolean>>): (...args: T[]) => boolean; } interface LoDashImplicitWrapper { /** * @see _.overSome */ overSome(...predicates: Array boolean>>): LoDashImplicitWrapper<(...args: T[]) => boolean>; } interface LoDashExplicitWrapper { /** * @see _.overSome */ overSome(...predicates: Array boolean>>): LoDashExplicitWrapper<(...args: T[]) => 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(path: PropertyPath): (obj: TObj) => TResult; } interface LoDashImplicitWrapper { /** * @see _.property */ property(): LoDashImplicitWrapper<(obj: TObj) => TResult>; } interface LoDashExplicitWrapper { /** * @see _.property */ property(): LoDashExplicitWrapper<(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(object: T): (path: PropertyPath) => any; } interface LoDashImplicitWrapper { /** * @see _.propertyOf */ propertyOf(): LoDashImplicitWrapper<(path: PropertyPath) => any>; } interface LoDashExplicitWrapper { /** * @see _.propertyOf */ propertyOf(): LoDashExplicitWrapper<(path: PropertyPath) => 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[]; /** * 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 index Not used in this overload. * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code. * @return Returns a new range array. */ range( end: number, index: string | number, guard: object ): number[]; } interface LoDashImplicitWrapper { /** * @see _.range */ range( end?: number, step?: number ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.range */ range( end?: number, step?: number ): LoDashExplicitWrapper; } //_.rangeRight interface LoDashStatic { /** * This method is like `_.range` except that it populates values in * descending order. * * @category Util * @param start The start of the range. * @param end The end of the range. * @param step The value to increment or decrement by. * @returns 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[]; /** * This method is like _.range except that it populates values in * descending order. * * @param start The start of the range. * @param index Not used in this overload. * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code. * @return Returns a new range array. */ rangeRight( end: number, index: string | number, guard: object ): number[]; } interface LoDashImplicitWrapper { /** * @see _.rangeRight */ rangeRight( end?: number, step?: number ): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.rangeRight */ rangeRight( end?: number, step?: number ): LoDashExplicitWrapper; } //_.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 LoDashImplicitWrapper { /** * @see _.runInContext */ runInContext(): typeof _; } // _.stubArray interface LoDashStatic { /** * This method returns a new empty array. * * @returns Returns the new empty array. */ stubArray(): any[]; } interface LoDashImplicitWrapper { /** * @see _.stubArray */ stubArray(): any[]; } interface LoDashExplicitWrapper { /** * @see _.stubArray */ stubArray(): LoDashExplicitWrapper; } // _.stubFalse interface LoDashStatic { /** * This method returns `false`. * * @returns Returns `false`. */ stubFalse(): boolean; } interface LoDashImplicitWrapper { /** * @see _.stubFalse */ stubFalse(): boolean; } interface LoDashExplicitWrapper { /** * @see _.stubFalse */ stubFalse(): LoDashExplicitWrapper; } interface LoDashStatic { /** * This method returns a new empty object. * * @returns Returns the new empty object. */ stubObject(): any; } interface LoDashImplicitWrapper { /** * @see _.stubObject */ stubObject(): any; } interface LoDashExplicitWrapper { /** * @see _.stubObject */ stubObject(): LoDashExplicitWrapper; } interface LoDashStatic { /** * This method returns an empty string. * * @returns Returns the empty string. */ stubString(): string; } interface LoDashImplicitWrapper { /** * @see _.stubString */ stubString(): string; } interface LoDashExplicitWrapper { /** * @see _.stubString */ stubString(): LoDashExplicitWrapper; } interface LoDashStatic { /** * This method returns `true`. * * @returns Returns `true`. */ stubTrue(): boolean; } interface LoDashImplicitWrapper { /** * @see _.stubTrue */ stubTrue(): boolean; } interface LoDashExplicitWrapper { /** * @see _.stubTrue */ stubTrue(): LoDashExplicitWrapper; } //_.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( n: number, iteratee: (num: number) => TResult ): TResult[]; /** * @see _.times */ times(n: number): number[]; } interface LoDashImplicitWrapper { /** * @see _.times */ times( iteratee: (num: number) => TResult ): TResult[]; /** * @see _.times */ times(): number[]; } interface LoDashExplicitWrapper { /** * @see _.times */ times( iteratee: (num: number) => TResult ): LoDashExplicitWrapper; /** * @see _.times */ times(): LoDashExplicitWrapper; } //_.toPath interface LoDashStatic { /** * Converts `value` to a property path array. * * @category Util * @param value The value to convert. * @returns 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 LoDashImplicitWrapper { /** * @see _.toPath */ toPath(): LoDashImplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.toPath */ toPath(): LoDashExplicitWrapper; } //_.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 { /** * @see _.uniqueId */ uniqueId(): string; } interface LoDashExplicitWrapper { /** * @see _.uniqueId */ uniqueId(): LoDashExplicitWrapper; } type NotVoid = {} | null | undefined; type ArrayIterator = (value: T, index: number, collection: T[]) => TResult; type ListIterator = (value: T, index: number, collection: List) => TResult; type ListIteratee = ListIterator | string | [string, any] | PartialDeep; type ListIterateeCustom = ListIterator | string | object | [string, any] | PartialDeep; type ListIteratorTypeGuard = (value: T, index: number, collection: List) => value is S; // Note: key should be string, not keyof T, because the actual object may contain extra properties that were not specified in the type. type ObjectIterator = (value: TObject[keyof TObject], key: string, collection: TObject) => TResult; type ObjectIteratee = ObjectIterator | string | [string, any] | PartialDeep; type ObjectIterateeCustom = ObjectIterator | string | object | [string, any] | PartialDeep; type ObjectIteratorTypeGuard = (value: TObject[keyof TObject], key: string, collection: TObject) => value is S; type DictionaryIterator = ObjectIterator, TResult>; type DictionaryIteratee = ObjectIteratee>; type DictionaryIteratorTypeGuard = ObjectIteratorTypeGuard, S>; type NumericDictionaryIterator = (value: T, key: number, collection: NumericDictionary) => TResult; type NumericDictionaryIteratee = NumericDictionaryIterator | string | [string, any] | PartialDeep; type NumericDictionaryIterateeCustom = NumericDictionaryIterator | string | [string, any] | PartialDeep; type StringIterator = (char: string, index: number, string: string) => TResult; type MemoVoidIterator = (prev: TResult, curr: T, indexOrKey: any, list: T[]) => void; /** @deprecated Use MemoListIterator or MemoObjectIterator instead. */ type MemoIterator = (prev: TResult, curr: T, indexOrKey: any, list: T[]) => TResult; type MemoListIterator = (prev: TResult, curr: T, index: number, list: TList) => TResult; type MemoObjectIterator = (prev: TResult, curr: T, key: string, list: TList) => TResult; type MemoVoidArrayIterator = (acc: TResult, curr: T, index: number, arr: T[]) => void; type MemoVoidDictionaryIterator = (acc: TResult, curr: T, key: string, dict: Dictionary) => void; type ValueIteratee = ((value: T) => NotVoid) | string | [string, any] | PartialDeep; type ValueKeyIteratee = ((value: T, key: string) => NotVoid) | string | [string, any] | PartialDeep; type Comparator = (a: T, b: T) => boolean; type Comparator2 = (a: T1, b: T2) => boolean; type PropertyName = string | number | symbol; type PropertyPath = Many; /** Common interface between Arrays and jQuery objects */ type List = ArrayLike; interface Dictionary { [index: string]: T; } interface NumericDictionary { [index: number]: T; } interface Cancelable { cancel(): void; flush(): void; } type PartialDeep = { [P in keyof T]?: PartialDeep; }; // For backwards compatibility type LoDashImplicitArrayWrapper = LoDashImplicitWrapper; type LoDashImplicitNillableArrayWrapper = LoDashImplicitWrapper; type LoDashImplicitObjectWrapper = LoDashImplicitWrapper; type LoDashImplicitNillableObjectWrapper = LoDashImplicitWrapper; type LoDashImplicitNumberArrayWrapper = LoDashImplicitWrapper; type LoDashImplicitStringWrapper = LoDashImplicitWrapper; type LoDashExplicitArrayWrapper = LoDashExplicitWrapper; type LoDashExplicitNillableArrayWrapper = LoDashExplicitWrapper; type LoDashExplicitObjectWrapper = LoDashExplicitWrapper; type LoDashExplicitNillableObjectWrapper = LoDashExplicitWrapper; type LoDashExplicitNumberArrayWrapper = LoDashExplicitWrapper; type LoDashExplicitStringWrapper = LoDashExplicitWrapper; } // Backward compatibility with --target es5 declare global { interface Set { } interface Map { } interface WeakSet { } interface WeakMap { } }