import _ = require("../index"); declare module "../index" { 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[]): ExpChain; } 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 LoDashImplicitWrapper { /** * @see _.bindAll */ bindAll(...methodNames: Array>): this; } interface LoDashExplicitWrapper { /** * @see _.bindAll */ bindAll(...methodNames: Array>): this; } 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: Array>): (Target: T) => R; } type ConformsPredicateObject = { [P in keyof T]: T[P] extends (arg: infer A) => any ? A : any }; 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(): Function<(value: ConformsPredicateObject) => boolean>; } interface LoDashExplicitWrapper { /** * @see _.conforms */ conforms(): FunctionChain<(value: ConformsPredicateObject) => boolean>; } 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(): Function<() => TValue>; } interface LoDashExplicitWrapper { /** * @see _.constant */ constant(): FunctionChain<() => TValue>; } 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(defaultValue: TValue): TValue; /** * @see _.defaultTo */ defaultTo(defaultValue: TDefault): TValue extends null | undefined ? TDefault : TValue | TDefault; } interface LoDashExplicitWrapper { /** * @see _.defaultTo */ defaultTo(defaultValue: TValue): ExpChain; /** * @see _.defaultTo */ defaultTo(defaultValue: TDefault): ExpChain; } interface LoDashStatic { /** * Creates a function that returns the result of invoking the provided functions with the this binding of the * created function, where each successive invocation is supplied the return value of the previous. * * @param funcs Functions to invoke. * @return Returns the new function. */ flow(f1: (...args: A) => 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): (...args: A) => R7; /** * @see _.flow */ flow(f1: (...args: A) => 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, ...func: Array any>>): (...args: A) => any; /** * @see _.flow */ flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (...args: A) => R6; /** * @see _.flow */ flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5; /** * @see _.flow */ flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4; /** * @see _.flow */ flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3; /** * @see _.flow */ flow(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2; /** * @see _.flow */ flow(...func: Array any>>): (...args: any[]) => any; } interface Function any> { /** * @see _.flow */ flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): Function<(...args: Parameters) => R7>; /** * @see _.flow */ flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array any>>): Function<(...args: Parameters) => any>; /** * @see _.flow */ flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): Function<(...args: Parameters) => R6>; /** * @see _.flow */ flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): Function<(...args: Parameters) => R5>; /** * @see _.flow */ flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): Function<(...args: Parameters) => R4>; /** * @see _.flow */ flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3): Function<(...args: Parameters) => R3>; /** * @see _.flow */ flow(f2: (a: ReturnType) => R2): Function<(...args: Parameters) => R2>; /** * @see _.flow */ flow(...func: Array any>>): Function<(...args: any[]) => any>; } interface FunctionChain { /** * @see _.flow */ flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): FunctionChain<(...args: Parameters) => R7>; /** * @see _.flow */ flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array any>>): FunctionChain<(...args: Parameters) => any>; /** * @see _.flow */ flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): FunctionChain<(...args: Parameters) => R6>; /** * @see _.flow */ flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): FunctionChain<(...args: Parameters) => R5>; /** * @see _.flow */ flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): FunctionChain<(...args: Parameters) => R4>; /** * @see _.flow */ flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3): FunctionChain<(...args: Parameters) => R3>; /** * @see _.flow */ flow(f2: (a: ReturnType) => R2): FunctionChain<(...args: Parameters) => R2>; /** * @see _.flow */ flow(...func: Array any>>): FunctionChain<(...args: any[]) => any>; } interface LoDashStatic { /** * This method is like _.flow except that it creates a function that invokes the provided functions from right * to left. * * @param funcs Functions to invoke. * @return Returns the new function. */ flowRight(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: A) => R1): (...args: A) => R7; /** * @see _.flowRight */ flowRight(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R6; /** * @see _.flowRight */ flowRight(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R5; /** * @see _.flowRight */ flowRight(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R4; /** * @see _.flowRight */ flowRight(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R3; /** * @see _.flowRight */ flowRight(f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R2; /** * @see _.flowRight */ flowRight(...func: Array any>>): (...args: any[]) => any; } interface Function { /** * @see _.flowRight */ flowRight(f6: (a: R5) => Parameters["0"], f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): Function<(...args: A) => ReturnType>; /** * @see _.flowRight */ flowRight(f5: (a: R4) => Parameters["0"], f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): Function<(...args: A) => ReturnType>; /** * @see _.flowRight */ flowRight(f4: (a: R3) => Parameters["0"], f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): Function<(...args: A) => ReturnType>; /** * @see _.flowRight */ flowRight(f3: (a: R2) => Parameters["0"], f2: (a: R1) => R2, f1: (...args: A) => R1): Function<(...args: A) => ReturnType>; /** * @see _.flowRight */ flowRight(f2: (a: R1) => Parameters["0"], f1: (...args: A) => R1): Function<(...args: A) => ReturnType>; /** * @see _.flowRight */ flowRight(f1: (...args: A) => Parameters["0"]): Function<(...args: A) => ReturnType>; /** * @see _.flowRight */ flowRight(...func: Array any>>): Function<(...args: any[]) => any>; } interface FunctionChain { /** * @see _.flowRight */ flowRight(f6: (a: R5) => Parameters["0"], f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType>; /** * @see _.flowRight */ flowRight(f5: (a: R4) => Parameters["0"], f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType>; /** * @see _.flowRight */ flowRight(f4: (a: R3) => Parameters["0"], f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType>; /** * @see _.flowRight */ flowRight(f3: (a: R2) => Parameters["0"], f2: (a: R1) => R2, f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType>; /** * @see _.flowRight */ flowRight(f2: (a: R1) => Parameters["0"], f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType>; /** * @see _.flowRight */ flowRight(f1: (...args: A) => Parameters["0"]): FunctionChain<(...args: A) => ReturnType>; /** * @see _.flowRight */ flowRight(...func: Array any>>): FunctionChain<(...args: any[]) => any>; } 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; } 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): TFunction; /** * @see _.iteratee */ iteratee(func: string | object): (...args: any[]) => any; } interface Function any> { /** * @see _.iteratee */ iteratee(): Function; } interface Collection { /** * @see _.iteratee */ iteratee(): Function<(o: object) => boolean>; } interface Object { /** * @see _.iteratee */ iteratee(): Function<(o: T) => boolean>; } interface String { /** * @see _.iteratee */ iteratee(): Function<(o: object) => any>; } interface FunctionChain any> { /** * @see _.iteratee */ iteratee(): FunctionChain; } interface CollectionChain { /** * @see _.iteratee */ iteratee(): FunctionChain<(o: object) => boolean>; } interface ObjectChain { /** * @see _.iteratee */ iteratee(): FunctionChain<(o: T) => boolean>; } interface StringChain { /** * @see _.iteratee */ iteratee(): FunctionChain<(o: object) => any>; } interface StringNullableChain { /** * @see _.iteratee */ iteratee(): FunctionChain<(o: object) => any>; } 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(): Function<(value: V) => boolean>; } interface LoDashExplicitWrapper { /** * @see _.matches */ matches(): FunctionChain<(value: V) => boolean>; } 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): Function<(value: any) => boolean>; /** * @see _.matchesProperty */ matchesProperty(srcValue: SrcValue): Function<(value: Value) => boolean>; } interface LoDashExplicitWrapper { /** * @see _.matchesProperty */ matchesProperty(srcValue: SrcValue): FunctionChain<(value: any) => boolean>; /** * @see _.matchesProperty */ matchesProperty(srcValue: SrcValue): FunctionChain<(value: Value) => boolean>; } 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[]): Function<(object: any) => any>; } interface LoDashExplicitWrapper { /** * @see _.method */ method(...args: any[]): FunctionChain<(object: any) => any>; } 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>; } interface MixinOptions { /** * @see _.chain */ 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; } 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; } 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[]): PrimitiveChain; } 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(): Function<(...args: any[]) => any>; } interface LoDashExplicitWrapper { /** * @see _.nthArg */ nthArg(): FunctionChain<(...args: any[]) => any>; } 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 Collection { /** * @see _.over */ over(...iteratees: Array TResult>>): Function<(...args: any[]) => TResult[]>; } interface Function { /** * @see _.over */ over(...iteratees: Array TResult>>): Function<(...args: any[]) => Array | TResult>>; } interface CollectionChain { /** * @see _.over */ over(...iteratees: Array TResult>>): FunctionChain<(...args: any[]) => TResult[]>; } interface FunctionChain { /** * @see _.over */ over(...iteratees: Array TResult>>): FunctionChain<(...args: any[]) => Array | TResult>>; } 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 Collection { /** * @see _.overEvery */ overEvery(...iteratees: Array boolean>>): Function<(...args: TArgs[]) => boolean>; } interface Function { /** * @see _.overEvery */ overEvery(...iteratees: Array boolean>>): Function<(...args: Parameters | TArgs[]) => boolean>; } interface CollectionChain { /** * @see _.overEvery */ overEvery(...iteratees: Array boolean>>): FunctionChain<(...args: TArgs[]) => boolean>; } interface FunctionChain { /** * @see _.overEvery */ overEvery(...iteratees: Array boolean>>): FunctionChain<(...args: Parameters | TArgs[]) => boolean>; } 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 Collection { /** * @see _.overSome */ overSome(...iteratees: Array boolean>>): Function<(...args: TArgs[]) => boolean>; } interface Function { /** * @see _.overSome */ overSome(...iteratees: Array boolean>>): Function<(...args: Parameters | TArgs[]) => boolean>; } interface CollectionChain { /** * @see _.overSome */ overSome(...iteratees: Array boolean>>): FunctionChain<(...args: TArgs[]) => boolean>; } interface FunctionChain { /** * @see _.overSome */ overSome(...iteratees: Array boolean>>): FunctionChain<(...args: Parameters | TArgs[]) => boolean>; } 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(): Function<(obj: TObj) => TResult>; } interface LoDashExplicitWrapper { /** * @see _.property */ property(): FunctionChain<(obj: TObj) => TResult>; } 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>; } interface LoDashStatic { /** * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end. * If end is not specified it’s set to start with start then set to 0. If end is less than start a zero-length * range is created unless a negative step is specified. * * @param start The start of the range. * @param end The end of the range. * @param step The value to increment or decrement by. * @return Returns a new range array. */ range(start: number, end?: number, step?: number): number[]; /** * @see _.range */ range(end: number, index: string | number, guard: object): number[]; } interface LoDashImplicitWrapper { /** * @see _.range */ range(end?: number, step?: number): Collection; } interface LoDashExplicitWrapper { /** * @see _.range */ range(end?: number, step?: number): CollectionChain; } 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[]; /** * @see _.rangeRight */ rangeRight(end: number, index: string | number, guard: object): number[]; } interface LoDashImplicitWrapper { /** * @see _.rangeRight */ rangeRight(end?: number, step?: number): Collection; } interface LoDashExplicitWrapper { /** * @see _.rangeRight */ rangeRight(end?: number, step?: number): CollectionChain; } 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): LoDashStatic; } interface LoDashImplicitWrapper { /** * @see _.runInContext */ runInContext(): LoDashStatic; } 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(): CollectionChain; } interface LoDashStatic { /** * This method returns `false`. * * @returns Returns `false`. */ stubFalse(): false; } interface LoDashImplicitWrapper { /** * @see _.stubFalse */ stubFalse(): false; } interface LoDashExplicitWrapper { /** * @see _.stubFalse */ stubFalse(): PrimitiveChain; } 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(): StringChain; } interface LoDashStatic { /** * This method returns `true`. * * @returns Returns `true`. */ stubTrue(): true; } interface LoDashImplicitWrapper { /** * @see _.stubTrue */ stubTrue(): true; } interface LoDashExplicitWrapper { /** * @see _.stubTrue */ stubTrue(): PrimitiveChain; } 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): CollectionChain; /** * @see _.times */ times(): CollectionChain; } 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(): Collection; } interface LoDashExplicitWrapper { /** * @see _.toPath */ toPath(): CollectionChain; } 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(): StringChain; } }