declare const _default: "\ntype GlobalPartial<T> = Partial<T>;\n\ntype EmptyObject<T> = { [K in keyof T]?: never };\ntype EmptyObjectOf<T> = EmptyObject<T> extends T ? EmptyObject<T> : never;\ntype GlobalFunction = Function;\ndeclare module lodash {\n    type FunctionBase = GlobalFunction;\n    interface LoDashStatic {\n        /**\n         * Casts value as an array if it’s not one.\n         *\n         * @param value The value to inspect.\n         * @return Returns the cast array.\n         */\n        castArray<T>(value?: Many<T>): T[];\n    }\n    interface Collection<T> {\n        /**\n         * @see _.castArray\n         */\n        castArray(): Collection<T>;\n    }\n    interface String {\n        /**\n         * @see _.castArray\n         */\n        castArray(): Collection<string>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.castArray\n         */\n        castArray(): Collection<T>;\n    }\n    interface Function<T extends (...args: any) => any> {\n        /**\n         * @see _.castArray\n         */\n        castArray(): Collection<T>;\n    }\n    interface Primitive<T> {\n        /**\n         * @see _.castArray\n         */\n        castArray(): Collection<T>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.castArray\n         */\n        castArray(): CollectionChain<T>;\n    }\n    interface StringChain {\n        /**\n         * @see _.castArray\n         */\n        castArray(): CollectionChain<string>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.castArray\n         */\n        castArray(): CollectionChain<string | undefined>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.castArray\n         */\n        castArray(): CollectionChain<T>;\n    }\n    interface FunctionChain<T extends (...args: any) => any> {\n        /**\n         * @see _.castArray\n         */\n        castArray(): CollectionChain<T>;\n    }\n    interface PrimitiveChain<T> {\n        /**\n         * @see _.castArray\n         */\n        castArray(): CollectionChain<T>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a shallow clone of value.\n         *\n         * Note: This method is loosely based on the structured clone algorithm and supports cloning arrays,\n         * array buffers, booleans, date objects, maps, numbers, Object objects, regexes, sets, strings, symbols,\n         * and typed arrays. The own enumerable properties of arguments objects are cloned as plain objects. An empty\n         * object is returned for uncloneable values such as error objects, functions, DOM nodes, and WeakMaps.\n         *\n         * @param value The value to clone.\n         * @return Returns the cloned value.\n         */\n        clone<T>(value: T): T;\n    }\n\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.clone\n         */\n        clone(): TValue;\n        /**\n         * @see _.cloneDeep\n         */\n        cloneDeep(): TValue;\n        /**\n         * @see _.cloneDeepWith\n         */\n        cloneDeepWith(customizer: CloneDeepWithCustomizer<TValue>): any;\n        /**\n         * @see _.cloneDeepWith\n         */\n        cloneDeepWith(): TValue;\n        /**\n         * @see _.cloneWith\n         */\n        cloneWith<TResult extends object | string | number | boolean | null>(customizer: CloneWithCustomizer<TValue, TResult>): TResult;\n        /**\n         * @see _.cloneWith\n         */\n        cloneWith<TResult>(customizer: CloneWithCustomizer<TValue, TResult | undefined>): TResult | TValue;\n        /**\n         * @see _.cloneWith\n         */\n        cloneWith(): TValue;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.clone\n         */\n        clone(): this;\n        /**\n         * @see _.cloneDeep\n         */\n        cloneDeep(): this;\n        /**\n         * @see _.cloneDeepWith\n         */\n        cloneDeepWith(customizer: CloneDeepWithCustomizer<TValue>): LoDashExplicitWrapper<any>;\n        /**\n         * @see _.cloneDeepWith\n         */\n        cloneDeepWith(): this;\n        /**\n         * @see _.cloneWith\n         */\n        cloneWith<TResult extends object | string | number | boolean | null>(customizer: CloneWithCustomizer<TValue, TResult>): ExpChain<TResult>;\n        /**\n         * @see _.cloneWith\n         */\n        cloneWith<TResult>(customizer: CloneWithCustomizer<TValue, TResult | undefined>): ExpChain<TResult | TValue>;\n        /**\n         * @see _.cloneWith\n         */\n        cloneWith(): this;\n    }\n\n    interface LoDashStatic {\n        /**\n         * This method is like _.clone except that it recursively clones value.\n         *\n         * @param value The value to recursively clone.\n         * @return Returns the deep cloned value.\n         */\n        cloneDeep<T>(value: T): T;\n    }\n    type CloneDeepWithCustomizer<TObject> = (value: any, key: number | string | undefined, object: TObject | undefined, stack: any) => any;\n    interface LoDashStatic {\n        /**\n         * This method is like _.cloneWith except that it recursively clones value.\n         *\n         * @param value The value to recursively clone.\n         * @param customizer The function to customize cloning.\n         * @return Returns the deep cloned value.\n         */\n        cloneDeepWith<T>(value: T, customizer: CloneDeepWithCustomizer<T>): any;\n        /**\n         * @see _.cloneDeepWith\n         */\n        cloneDeepWith<T>(value: T): T;\n    }\n    type CloneWithCustomizer<TValue, TResult> = (value: TValue, key: number | string | undefined, object: any, stack: any) => TResult;\n    interface LoDashStatic {\n        /**\n         * This method is like _.clone except that it accepts customizer which is invoked to produce the cloned value.\n         * If customizer returns undefined cloning is handled by the method instead.\n         *\n         * @param value The value to clone.\n         * @param customizer The function to customize cloning.\n         * @return Returns the cloned value.\n         */\n        cloneWith<T, TResult extends object | string | number | boolean | null>(value: T, customizer: CloneWithCustomizer<T, TResult>): TResult;\n        /**\n         * @see _.cloneWith\n         */\n        cloneWith<T, TResult>(value: T, customizer: CloneWithCustomizer<T, TResult | undefined>): TResult | T;\n        /**\n         * @see _.cloneWith\n         */\n        cloneWith<T>(value: T): T;\n    }\n    interface LoDashStatic {\n        /**\n         * Checks if object conforms to source by invoking the predicate properties of source with the\n         * corresponding property values of object.\n         *\n         * Note: This method is equivalent to _.conforms when source is partially applied.\n         */\n        conformsTo<T>(object: T, source: ConformsPredicateObject<T>): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.conformsTo\n         */\n        conformsTo(source: ConformsPredicateObject<TValue>): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.conformsTo\n         */\n        conformsTo(source: ConformsPredicateObject<TValue>): PrimitiveChain<boolean>;\n    }\n    interface LoDashStatic {\n        /**\n         * Performs a [SameValueZero](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n         * comparison between two values to determine if they are equivalent.\n         *\n         * @category Lang\n         * @param value The value to compare.\n         * @param other The other value to compare.\n         * @returns Returns true if the values are equivalent, else false.\n         * @example\n         *\n         * var object = { 'user': 'fred' };\n         * var other = { 'user': 'fred' };\n         *\n         * _.eq(object, object);\n         * // => true\n         *\n         * _.eq(object, other);\n         * // => false\n         *\n         * _.eq('a', 'a');\n         * // => true\n         *\n         * _.eq('a', Object('a'));\n         * // => false\n         *\n         * _.eq(NaN, NaN);\n         * // => true\n         */\n        eq(value: any, other: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.eq\n         */\n        eq(other: any): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.eq\n         */\n        eq(other: any): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is greater than other.\n         *\n         * @param value The value to compare.\n         * @param other The other value to compare.\n         * @return Returns true if value is greater than other, else false.\n         */\n        gt(value: any, other: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.gt\n         */\n        gt(other: any): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.gt\n         */\n        gt(other: any): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is greater than or equal to other.\n         *\n         * @param value The value to compare.\n         * @param other The other value to compare.\n         * @return Returns true if value is greater than or equal to other, else false.\n         */\n        gte(value: any, other: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.gte\n         */\n        gte(other: any): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.gte\n         */\n        gte(other: any): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as an arguments object.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is correctly classified, else false.\n         */\n        isArguments(value?: any): value is IArguments;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isArguments\n         */\n        isArguments(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isArguments\n         */\n        isArguments(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as an Array object.\n         * @param value The value to check.\n         *\n         * @return Returns true if value is correctly classified, else false.\n         */\n        isArray(value?: any): value is any[];\n        /**\n         * @see _.isArray\n         */\n        isArray<T>(value?: any): value is any[];\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isArray\n         */\n        isArray(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isArray\n         */\n        isArray(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as an ArrayBuffer object.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is correctly classified, else false.\n         */\n        isArrayBuffer(value?: any): value is ArrayBuffer;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isArrayBuffer\n         */\n        isArrayBuffer(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isArrayBuffer\n         */\n        isArrayBuffer(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is array-like. A value is considered array-like if it's\n         * not a function and has a value.length that's an integer greater than or\n         * equal to 0 and less than or equal to Number.MAX_SAFE_INTEGER.\n         *\n         * @category Lang\n         * @param value The value to check.\n         * @returns Returns true if value is array-like, else false.\n         * @example\n         *\n         * _.isArrayLike([1, 2, 3]);\n         * // => true\n         *\n         * _.isArrayLike(document.body.children);\n         * // => true\n         *\n         * _.isArrayLike('abc');\n         * // => true\n         *\n         * _.isArrayLike(_.noop);\n         * // => false\n         */\n        isArrayLike<T extends { __lodashAnyHack: any }>(t: T): boolean;\n        /**\n         * @see _.isArrayLike\n         */\n        isArrayLike(value: ((...args: any[]) => any) | null | undefined): value is never;\n        /**\n         * @see _.isArrayLike\n         */\n        isArrayLike(value: any): value is { length: number };\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isArrayLike\n         */\n        isArrayLike(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isArrayLike\n         */\n        isArrayLike(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * This method is like _.isArrayLike except that it also checks if value\n         * is an object.\n         *\n         * @category Lang\n         * @param value The value to check.\n         * @returns Returns true if value is an array-like object, else false.\n         * @example\n         *\n         * _.isArrayLikeObject([1, 2, 3]);\n         * // => true\n         *\n         * _.isArrayLikeObject(document.body.children);\n         * // => true\n         *\n         * _.isArrayLikeObject('abc');\n         * // => false\n         *\n         * _.isArrayLikeObject(_.noop);\n         * // => false\n         */\n        isArrayLikeObject<T extends { __lodashAnyHack: any }>(value: T): boolean;\n        /**\n         * @see _.isArrayLikeObject\n         */\n        isArrayLikeObject(value: ((...args: any[]) => any) | FunctionBase | string | boolean | number | null | undefined): value is never;\n        /**\n         * @see _.isArrayLikeObject\n         */\n        isArrayLikeObject(value: any): value is object & { length: number };\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isArrayLikeObject\n         */\n        isArrayLikeObject(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isArrayLikeObject\n         */\n        isArrayLikeObject(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as a boolean primitive or object.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is correctly classified, else false.\n         */\n        isBoolean(value?: any): value is boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isBoolean\n         */\n        isBoolean(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isBoolean\n         */\n        isBoolean(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is a buffer.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is a buffer, else false.\n         */\n        isBuffer(value?: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isBuffer\n         */\n        isBuffer(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isBuffer\n         */\n        isBuffer(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as a Date object.\n         * @param value The value to check.\n         *\n         * @return Returns true if value is correctly classified, else false.\n         */\n        isDate(value?: any): value is Date;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isDate\n         */\n        isDate(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isDate\n         */\n        isDate(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is a DOM element.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is a DOM element, else false.\n         */\n        isElement(value?: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isElement\n         */\n        isElement(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isElement\n         */\n        isElement(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is empty. A value is considered empty unless it’s an arguments object, array, string, or\n         * jQuery-like collection with a length greater than 0 or an object with own enumerable properties.\n         *\n         * @param value The value to inspect.\n         * @return Returns true if value is empty, else false.\n         */\n        isEmpty<T extends { __trapAny: any }>(value?: T): boolean;\n        isEmpty(value: string): value is '';\n        isEmpty(value: Map<any, any> | Set<any> | List<any> | null | undefined): boolean;\n        isEmpty(value: object): boolean;\n        isEmpty<T extends object>(value: T | null | undefined): value is EmptyObjectOf<T> | null | undefined;\n        isEmpty(value?: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isEmpty\n         */\n        isEmpty(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isEmpty\n         */\n        isEmpty(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Performs a deep comparison between two values to determine if they are\n         * equivalent.\n         *\n         * **Note:** This method supports comparing arrays, array buffers, booleans,\n         * date objects, error objects, maps, numbers, Object objects, regexes,\n         * sets, strings, symbols, and typed arrays. Object objects are compared\n         * by their own, not inherited, enumerable properties. Functions and DOM\n         * nodes are **not** supported.\n         *\n         * @category Lang\n         * @param value The value to compare.\n         * @param other The other value to compare.\n         * @returns Returns true if the values are equivalent, else false.\n         * @example\n         *\n         * var object = { 'user': 'fred' };\n         * var other = { 'user': 'fred' };\n         *\n         * _.isEqual(object, other);\n         * // => true\n         *\n         * object === other;\n         * // => false\n         */\n        isEqual(value: any, other: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isEqual\n         */\n        isEqual(other: any): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isEqual\n         */\n        isEqual(other: any): PrimitiveChain<boolean>;\n    }\n\n    type IsEqualCustomizer = (value: any, other: any, indexOrKey: PropertyName | undefined, parent: any, otherParent: any, stack: any) => boolean | undefined;\n    interface LoDashStatic {\n        /**\n         * This method is like _.isEqual except that it accepts customizer which is\n         * invoked to compare values. If customizer returns undefined comparisons are\n         * handled by the method instead. The customizer is invoked with up to seven arguments:\n         * (objValue, othValue [, index|key, object, other, stack]).\n         *\n         * @category Lang\n         * @param value The value to compare.\n         * @param other The other value to compare.\n         * @param [customizer] The function to customize comparisons.\n         * @returns Returns true if the values are equivalent, else false.\n         * @example\n         *\n         * function isGreeting(value) {\n         *   return /^h(?:i|ello)$/.test(value);\n         * }\n         *\n         * function customizer(objValue, othValue) {\n         *   if (isGreeting(objValue) && isGreeting(othValue)) {\n         *     return true;\n         *   }\n         * }\n         *\n         * var array = ['hello', 'goodbye'];\n         * var other = ['hi', 'goodbye'];\n         *\n         * _.isEqualWith(array, other, customizer);\n         * // => true\n         */\n        isEqualWith(value: any, other: any, customizer?: IsEqualCustomizer): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isEqualWith\n         */\n        isEqualWith(other: any, customizer?: IsEqualCustomizer): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isEqualWith\n         */\n        isEqualWith(other: any, customizer?: IsEqualCustomizer): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is an Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, or URIError\n         * object.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is an error object, else false.\n         */\n        isError(value: any): value is Error;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isError\n         */\n        isError(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isError\n         */\n        isError(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is a finite primitive number.\n         *\n         * Note: This method is based on Number.isFinite.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is a finite number, else false.\n         */\n        isFinite(value?: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isFinite\n         */\n        isFinite(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isFinite\n         */\n        isFinite(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is a callable function.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is correctly classified, else false.\n         */\n        isFunction(value: any): value is (...args: any[]) => any;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isFunction\n         */\n        isFunction(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isFunction\n         */\n        isFunction(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is an integer.\n         *\n         * **Note:** This method is based on [Number.isInteger](https://mdn.io/Number/isInteger).\n         *\n         * @category Lang\n         * @param value The value to check.\n         * @returns Returns true if value is an integer, else false.\n         * @example\n         *\n         * _.isInteger(3);\n         * // => true\n         *\n         * _.isInteger(Number.MIN_VALUE);\n         * // => false\n         *\n         * _.isInteger(Infinity);\n         * // => false\n         *\n         * _.isInteger('3');\n         * // => false\n         */\n        isInteger(value?: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isInteger\n         */\n        isInteger(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isInteger\n         */\n        isInteger(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is a valid array-like length.\n         *\n         * **Note:** This function is loosely based on [ToLength](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n         *\n         * @category Lang\n         * @param value The value to check.\n         * @returns Returns true if value is a valid length, else false.\n         * @example\n         *\n         * _.isLength(3);\n         * // => true\n         *\n         * _.isLength(Number.MIN_VALUE);\n         * // => false\n         *\n         * _.isLength(Infinity);\n         * // => false\n         *\n         * _.isLength('3');\n         * // => false\n         */\n        isLength(value?: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isLength\n         */\n        isLength(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isLength\n         */\n        isLength(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as a Map object.\n         *\n         * @param value The value to check.\n         * @returns Returns true if value is correctly classified, else false.\n         */\n        isMap(value?: any): value is Map<any, any>;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isMap\n         */\n        isMap(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isMap\n         */\n        isMap(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Performs a deep comparison between object and source to determine if\n         * object contains equivalent property values.\n         *\n         * **Note:** This method supports comparing the same values as _.isEqual.\n         *\n         * @category Lang\n         * @param object The object to inspect.\n         * @param source The object of property values to match.\n         * @returns Returns true if object is a match, else false.\n         * @example\n         *\n         * var object = { 'user': 'fred', 'age': 40 };\n         *\n         * _.isMatch(object, { 'age': 40 });\n         * // => true\n         *\n         * _.isMatch(object, { 'age': 36 });\n         * // => false\n         */\n        isMatch(object: object, source: object): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isMatch\n         */\n        isMatch(source: object): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isMatch\n         */\n        isMatch(source: object): PrimitiveChain<boolean>;\n    }\n\n    type isMatchWithCustomizer = (value: any, other: any, indexOrKey: PropertyName, object: object, source: object) => boolean | undefined;\n    interface LoDashStatic {\n        /**\n         * This method is like _.isMatch except that it accepts customizer which\n         * is invoked to compare values. If customizer returns undefined comparisons\n         * are handled by the method instead. The customizer is invoked with three\n         * arguments: (objValue, srcValue, index|key, object, source).\n         *\n         * @category Lang\n         * @param object The object to inspect.\n         * @param source The object of property values to match.\n         * @param [customizer] The function to customize comparisons.\n         * @returns Returns true if object is a match, else false.\n         * @example\n         *\n         * function isGreeting(value) {\n         *   return /^h(?:i|ello)$/.test(value);\n         * }\n         *\n         * function customizer(objValue, srcValue) {\n         *   if (isGreeting(objValue) && isGreeting(srcValue)) {\n         *     return true;\n         *   }\n         * }\n         *\n         * var object = { 'greeting': 'hello' };\n         * var source = { 'greeting': 'hi' };\n         *\n         * _.isMatchWith(object, source, customizer);\n         * // => true\n         */\n        isMatchWith(object: object, source: object, customizer: isMatchWithCustomizer): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isMatchWith\n         */\n        isMatchWith(source: object, customizer: isMatchWithCustomizer): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isMatchWith\n         */\n        isMatchWith(source: object, customizer: isMatchWithCustomizer): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is NaN.\n         *\n         * Note: This method is not the same as isNaN which returns true for undefined and other non-numeric values.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is NaN, else false.\n         */\n        isNaN(value?: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isNaN\n         */\n        isNaN(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isNaN\n         */\n        isNaN(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is a native function.\n         * @param value The value to check.\n         *\n         * @return Returns true if value is a native function, else false.\n         */\n        isNative(value: any): value is (...args: any[]) => any;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isNative\n         */\n        isNative(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isNative\n         */\n        isNative(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is null or undefined.\n         *\n         * @category Lang\n         * @param value The value to check.\n         * @returns Returns true if value is nullish, else false.\n         * @example\n         *\n         * _.isNil(null);\n         * // => true\n         *\n         * _.isNil(void 0);\n         * // => true\n         *\n         * _.isNil(NaN);\n         * // => false\n         */\n        isNil(value: any): value is null | undefined;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isNil\n         */\n        isNil(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isNil\n         */\n        isNil(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is null.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is null, else false.\n         */\n        isNull(value: any): value is null;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isNull\n         */\n        isNull(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isNull\n         */\n        isNull(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as a Number primitive or object.\n         *\n         * Note: To exclude Infinity, -Infinity, and NaN, which are classified as numbers, use the _.isFinite method.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is correctly classified, else false.\n         */\n        isNumber(value?: any): value is number;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isNumber\n         */\n        isNumber(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isNumber\n         */\n        isNumber(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is the language type of Object. (e.g. arrays, functions, objects, regexes, new Number(0),\n         * and new String(''))\n         *\n         * @param value The value to check.\n         * @return Returns true if value is an object, else false.\n         */\n        isObject(value?: any): value is object;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isObject\n         */\n        isObject(): this is LoDashImplicitWrapper<object>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isObject\n         */\n        isObject(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is object-like. A value is object-like if it's not null\n         * and has a typeof result of \"object\".\n         *\n         * @category Lang\n         * @param value The value to check.\n         * @returns Returns true if value is object-like, else false.\n         * @example\n         *\n         * _.isObjectLike({});\n         * // => true\n         *\n         * _.isObjectLike([1, 2, 3]);\n         * // => true\n         *\n         * _.isObjectLike(_.noop);\n         * // => false\n         *\n         * _.isObjectLike(null);\n         * // => false\n         */\n        isObjectLike(value?: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isObjectLike\n         */\n        isObjectLike(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isObjectLike\n         */\n        isObjectLike(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is a plain object, that is, an object created by the Object constructor or one with a\n         * [[Prototype]] of null.\n         *\n         * Note: This method assumes objects created by the Object constructor have no inherited enumerable properties.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is a plain object, else false.\n         */\n        isPlainObject(value?: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isPlainObject\n         */\n        isPlainObject(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isPlainObject\n         */\n        isPlainObject(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as a RegExp object.\n         * @param value The value to check.\n         *\n         * @return Returns true if value is correctly classified, else false.\n         */\n        isRegExp(value?: any): value is RegExp;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isRegExp\n         */\n        isRegExp(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isRegExp\n         */\n        isRegExp(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is a safe integer. An integer is safe if it's an IEEE-754\n         * double precision number which isn't the result of a rounded unsafe integer.\n         *\n         * **Note:** This method is based on [Number.isSafeInteger](https://mdn.io/Number/isSafeInteger).\n         *\n         * @category Lang\n         * @param value The value to check.\n         * @returns Returns true if value is a safe integer, else false.\n         * @example\n         *\n         * _.isSafeInteger(3);\n         * // => true\n         *\n         * _.isSafeInteger(Number.MIN_VALUE);\n         * // => false\n         *\n         * _.isSafeInteger(Infinity);\n         * // => false\n         *\n         * _.isSafeInteger('3');\n         * // => false\n         */\n        isSafeInteger(value: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isSafeInteger\n         */\n        isSafeInteger(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isSafeInteger\n         */\n        isSafeInteger(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as a Set object.\n         *\n         * @param value The value to check.\n         * @returns Returns true if value is correctly classified, else false.\n         */\n        isSet(value?: any): value is Set<any>;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isSet\n         */\n        isSet(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isSet\n         */\n        isSet(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as a String primitive or object.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is correctly classified, else false.\n         */\n        isString(value?: any): value is string;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isString\n         */\n        isString(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isString\n         */\n        isString(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as a Symbol primitive or object.\n         *\n         * @category Lang\n         * @param value The value to check.\n         * @returns Returns true if value is correctly classified, else false.\n         * @example\n         *\n         * _.isSymbol(Symbol.iterator);\n         * // => true\n         *\n         * _.isSymbol('abc');\n         * // => false\n         */\n        isSymbol(value: any): value is symbol;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isSymbol\n         */\n        isSymbol(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isSymbol\n         */\n        isSymbol(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as a typed array.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is correctly classified, else false.\n         */\n        isTypedArray(value: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isTypedArray\n         */\n        isTypedArray(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isTypedArray\n         */\n        isTypedArray(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is undefined.\n         *\n         * @param value The value to check.\n         * @return Returns true if value is undefined, else false.\n         */\n        isUndefined(value: any): value is undefined;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isUndefined\n         */\n        isUndefined(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isUndefined\n         */\n        isUndefined(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as a WeakMap object.\n         *\n         * @param value The value to check.\n         * @returns Returns true if value is correctly classified, else false.\n         */\n        isWeakMap(value?: any): value is WeakMap<object, any>;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isWeakMap\n         */\n        isWeakMap(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isWeakMap\n         */\n        isWeakMap(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is classified as a WeakSet object.\n         *\n         * @param value The value to check.\n         * @returns Returns true if value is correctly classified, else false.\n         */\n        isWeakSet(value?: any): value is WeakSet<object>;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.isWeakSet\n         */\n        isWeakSet(): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.isWeakSet\n         */\n        isWeakSet(): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is less than other.\n         *\n         * @param value The value to compare.\n         * @param other The other value to compare.\n         * @return Returns true if value is less than other, else false.\n         */\n        lt(value: any, other: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.lt\n         */\n        lt(other: any): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.lt\n         */\n        lt(other: any): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks if value is less than or equal to other.\n         *\n         * @param value The value to compare.\n         * @param other The other value to compare.\n         * @return Returns true if value is less than or equal to other, else false.\n         */\n        lte(value: any, other: any): boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.lte\n         */\n        lte(other: any): boolean;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.lte\n         */\n        lte(other: any): PrimitiveChain<boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Converts value to an array.\n         *\n         * @param value The value to convert.\n         * @return Returns the converted array.\n         */\n        toArray<T>(value:  Dictionary<T> | NumericDictionary<T> | null | undefined): T[];\n        /**\n         * @see _.toArray\n         */\n        toArray<T>(value: T): Array<T[keyof T]>;\n        /**\n         * @see _.toArray\n         */\n        toArray(): any[];\n    }\n    interface String {\n        /**\n         * @see _.toArray\n         */\n        toArray(): Collection<string>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.toArray\n         */\n        toArray(): Collection<T>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.toArray\n         */\n        toArray(): Collection<T[keyof T]>;\n    }\n    interface StringChain {\n        /**\n         * @see _.toArray\n         */\n        toArray(): CollectionChain<string>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.toArray\n         */\n        toArray(): CollectionChain<string>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.toArray\n         */\n        toArray(): CollectionChain<T>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.toArray\n         */\n        toArray(): CollectionChain<T[keyof T]>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Converts value to a finite number.\n         *\n         * @since 4.12.0\n         * @category Lang\n         * @param value The value to convert.\n         * @returns Returns the converted number.\n         * @example\n         *\n         * _.toFinite(3.2);\n         * // => 3.2\n         *\n         * _.toFinite(Number.MIN_VALUE);\n         * // => 5e-324\n         *\n         * _.toFinite(Infinity);\n         * // => 1.7976931348623157e+308\n         *\n         * _.toFinite('3.2');\n         * // => 3.2\n         */\n        toFinite(value: any): number;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.toFinite\n         */\n        toFinite(): number;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.toFinite\n         */\n        toFinite(): PrimitiveChain<number>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Converts value to an integer.\n         *\n         * **Note:** This function is loosely based on [ToInteger](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger).\n         *\n         * @category Lang\n         * @param value The value to convert.\n         * @returns Returns the converted integer.\n         * @example\n         *\n         * _.toInteger(3);\n         * // => 3\n         *\n         * _.toInteger(Number.MIN_VALUE);\n         * // => 0\n         *\n         * _.toInteger(Infinity);\n         * // => 1.7976931348623157e+308\n         *\n         * _.toInteger('3');\n         * // => 3\n         */\n        toInteger(value: any): number;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.toInteger\n         */\n        toInteger(): number;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.toInteger\n         */\n        toInteger(): PrimitiveChain<number>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Converts value to an integer suitable for use as the length of an\n         * array-like object.\n         *\n         * **Note:** This method is based on [ToLength](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n         *\n         * @category Lang\n         * @param value The value to convert.\n         * @return Returns the converted integer.\n         * @example\n         *\n         * _.toLength(3);\n         * // => 3\n         *\n         * _.toLength(Number.MIN_VALUE);\n         * // => 0\n         *\n         * _.toLength(Infinity);\n         * // => 4294967295\n         *\n         * _.toLength('3');\n         * // => 3\n         */\n        toLength(value: any): number;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.toLength\n         */\n        toLength(): number;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.toLength\n         */\n        toLength(): PrimitiveChain<number>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Converts value to a number.\n         *\n         * @category Lang\n         * @param value The value to process.\n         * @returns Returns the number.\n         * @example\n         *\n         * _.toNumber(3);\n         * // => 3\n         *\n         * _.toNumber(Number.MIN_VALUE);\n         * // => 5e-324\n         *\n         * _.toNumber(Infinity);\n         * // => Infinity\n         *\n         * _.toNumber('3');\n         * // => 3\n         */\n        toNumber(value: any): number;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.toNumber\n         */\n        toNumber(): number;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.toNumber\n         */\n        toNumber(): PrimitiveChain<number>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Converts value to a plain object flattening inherited enumerable properties of value to own properties\n         * of the plain object.\n         *\n         * @param value The value to convert.\n         * @return Returns the converted plain object.\n         */\n        toPlainObject(value?: any): any;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.toPlainObject\n         */\n        toPlainObject(): Object<any>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.toPlainObject\n         */\n        toPlainObject(): ObjectChain<any>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Converts value to a safe integer. A safe integer can be compared and\n         * represented correctly.\n         *\n         * @category Lang\n         * @param value The value to convert.\n         * @returns Returns the converted integer.\n         * @example\n         *\n         * _.toSafeInteger(3);\n         * // => 3\n         *\n         * _.toSafeInteger(Number.MIN_VALUE);\n         * // => 0\n         *\n         * _.toSafeInteger(Infinity);\n         * // => 9007199254740991\n         *\n         * _.toSafeInteger('3');\n         * // => 3\n         */\n        toSafeInteger(value: any): number;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.toSafeInteger\n         */\n        toSafeInteger(): number;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.toSafeInteger\n         */\n        toSafeInteger(): PrimitiveChain<number>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Converts value to a string if it's not one. An empty string is returned\n         * for null and undefined values. The sign of -0 is preserved.\n         *\n         * @category Lang\n         * @param value The value to process.\n         * @returns Returns the string.\n         * @example\n         *\n         * _.toString(null);\n         * // => ''\n         *\n         * _.toString(-0);\n         * // => '-0'\n         *\n         * _.toString([1, 2, 3]);\n         * // => '1,2,3'\n         */\n        toString(value: any): string;\n    }\n}\n\n\ndeclare module lodash {\n    type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;\n    type PartialObject<T> = GlobalPartial<T>;\n    type Many<T> = T | ReadonlyArray<T>;\n    type ImpChain<T> =\n        T extends { __trapAny: any } ? Collection<any> & Function<any> & Object<any> & Primitive<any> & String :\n        T extends null | undefined ? never :\n        T extends string | null | undefined ? String :\n        T extends (...args: any) => any ? Function<T> :\n        T extends List<infer U> | null | undefined ? Collection<U> :\n        T extends object | null | undefined ? Object<T> :\n        Primitive<T>;\n    type ExpChain<T> =\n        T extends { __trapAny: any } ? CollectionChain<any> & FunctionChain<any> & ObjectChain<any> & PrimitiveChain<any> & StringChain :\n        T extends null | undefined ? never :\n        T extends string ? StringChain :\n        T extends string | null | undefined ? StringNullableChain :\n        T extends (...args: any) => any ? FunctionChain<T> :\n        T extends List<infer U> | null | undefined ? CollectionChain<U> :\n        T extends object | null | undefined ? ObjectChain<T> :\n        PrimitiveChain<T>;\n    interface LoDashStatic {\n        /**\n        * Creates a lodash object which wraps value to enable implicit method chain sequences.\n        * Methods that operate on and return arrays, collections, and functions can be chained together.\n        * Methods that retrieve a single value or may return a primitive value will automatically end the\n        * chain sequence and return the unwrapped value. Otherwise, the value must be unwrapped with value().\n        *\n        * Explicit chain sequences, which must be unwrapped with value(), may be enabled using _.chain.\n        *\n        * The execution of chained methods is lazy, that is, it's deferred until value() is\n        * implicitly or explicitly called.\n        *\n        * Lazy evaluation allows several methods to support shortcut fusion. Shortcut fusion\n        * is an optimization to merge iteratee calls; this avoids the creation of intermediate\n        * arrays and can greatly reduce the number of iteratee executions. Sections of a chain\n        * sequence qualify for shortcut fusion if the section is applied to an array and iteratees\n        * accept only one argument. The heuristic for whether a section qualifies for shortcut\n        * fusion is subject to change.\n        *\n        * Chaining is supported in custom builds as long as the value() method is directly or\n        * indirectly included in the build.\n        *\n        * In addition to lodash methods, wrappers have Array and String methods.\n        * The wrapper Array methods are:\n        * concat, join, pop, push, shift, sort, splice, and unshift.\n        * The wrapper String methods are:\n        * replace and split.\n        *\n        * The wrapper methods that support shortcut fusion are:\n        * at, compact, drop, dropRight, dropWhile, filter, find, findLast, head, initial, last,\n        * map, reject, reverse, slice, tail, take, takeRight, takeRightWhile, takeWhile, and toArray\n        *\n        * The chainable wrapper methods are:\n        * after, ary, assign, assignIn, assignInWith, assignWith, at, before, bind, bindAll, bindKey,\n        * castArray, chain, chunk, commit, compact, concat, conforms, constant, countBy, create,\n        * curry, debounce, defaults, defaultsDeep, defer, delay, difference, differenceBy, differenceWith,\n        * drop, dropRight, dropRightWhile, dropWhile, extend, extendWith, fill, filter, flatMap,\n        * flatMapDeep, flatMapDepth, flatten, flattenDeep, flattenDepth, flip, flow, flowRight,\n        * fromPairs, functions, functionsIn, groupBy, initial, intersection, intersectionBy, intersectionWith,\n        * invert, invertBy, invokeMap, iteratee, keyBy, keys, keysIn, map, mapKeys, mapValues,\n        * matches, matchesProperty, memoize, merge, mergeWith, method, methodOf, mixin, negate,\n        * nthArg, omit, omitBy, once, orderBy, over, overArgs, overEvery, overSome, partial, partialRight,\n        * partition, pick, pickBy, plant, property, propertyOf, pull, pullAll, pullAllBy, pullAllWith, pullAt,\n        * push, range, rangeRight, rearg, reject, remove, rest, reverse, sampleSize, set, setWith,\n        * shuffle, slice, sort, sortBy, sortedUniq, sortedUniqBy, splice, spread, tail, take,\n        * takeRight, takeRightWhile, takeWhile, tap, throttle, thru, toArray, toPairs, toPairsIn,\n        * toPath, toPlainObject, transform, unary, union, unionBy, unionWith, uniq, uniqBy, uniqWith,\n        * unset, unshift, unzip, unzipWith, update, updateWith, values, valuesIn, without, wrap,\n        * xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, and zipWith.\n        *\n        * The wrapper methods that are not chainable by default are:\n        * add, attempt, camelCase, capitalize, ceil, clamp, clone, cloneDeep, cloneDeepWith, cloneWith,\n        * conformsTo, deburr, defaultTo, divide, each, eachRight, endsWith, eq, escape, escapeRegExp,\n        * every, find, findIndex, findKey, findLast, findLastIndex, findLastKey, first, floor, forEach,\n        * forEachRight, forIn, forInRight, forOwn, forOwnRight, get, gt, gte, has, hasIn, head,\n        * identity, includes, indexOf, inRange, invoke, isArguments, isArray, isArrayBuffer,\n        * isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isElement, isEmpty, isEqual, isEqualWith,\n        * isError, isFinite, isFunction, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN,\n        * isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isRegExp,\n        * isSafeInteger, isSet, isString, isUndefined, isTypedArray, isWeakMap, isWeakSet, join,\n        * kebabCase, last, lastIndexOf, lowerCase, lowerFirst, lt, lte, max, maxBy, mean, meanBy,\n        * min, minBy, multiply, noConflict, noop, now, nth, pad, padEnd, padStart, parseInt, pop,\n        * random, reduce, reduceRight, repeat, result, round, runInContext, sample, shift, size,\n        * snakeCase, some, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy, startCase,\n        * startsWith, stubArray, stubFalse, stubObject, stubString, stubTrue, subtract, sum, sumBy,\n        * template, times, toFinite, toInteger, toJSON, toLength, toLower, toNumber, toSafeInteger,\n        * toString, toUpper, trim, trimEnd, trimStart, truncate, unescape, uniqueId, upperCase,\n        * upperFirst, value, and words.\n        **/\n        <TrapAny extends { __trapAny: any }>(value: TrapAny): Collection<any> & Function<any> & Object<any> & Primitive<any> & String;\n        <T extends null | undefined>(value: T): Primitive<T>;\n        (value: string | null | undefined): String;\n        <T extends (...args: any) => any>(value: T): Function<T>;\n        <T = any>(value: List<T> | null | undefined): Collection<T>;\n        <T extends object>(value: T | null | undefined): Object<T>;\n        <T>(value: T): Primitive<T>;\n        /**\n        * The semantic version number.\n        **/\n        VERSION: string;\n        /**\n        * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby\n        * (ERB). Change the following template settings to use alternative delimiters.\n        **/\n        templateSettings: TemplateSettings;\n    }\n    /**\n    * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby\n    * (ERB). Change the following template settings to use alternative delimiters.\n    **/\n    interface TemplateSettings {\n        /**\n        * The \"escape\" delimiter.\n        **/\n        escape?: RegExp | undefined;\n        /**\n        * The \"evaluate\" delimiter.\n        **/\n        evaluate?: RegExp | undefined;\n        /**\n        * An object to import into the template as local variables.\n        */\n        imports?: Dictionary<any> | undefined;\n        /**\n        * The \"interpolate\" delimiter.\n        */\n        interpolate?: RegExp | undefined;\n        /**\n        * Used to reference the data object in the template text.\n        */\n        variable?: string | undefined;\n    }\n    /**\n     * Creates a cache object to store key/value pairs.\n     */\n    interface MapCache {\n        /**\n         * Removes key and its value from the cache.\n         * @param key The key of the value to remove.\n         * @return Returns true if the entry was removed successfully, else false.\n         */\n        delete(key: any): boolean;\n        /**\n         * Gets the cached value for key.\n         * @param key The key of the value to get.\n         * @return Returns the cached value.\n         */\n        get(key: any): any;\n        /**\n         * Checks if a cached value for key exists.\n         * @param key The key of the entry to check.\n         * @return Returns true if an entry for key exists, else false.\n         */\n        has(key: any): boolean;\n        /**\n         * Sets value to key of the cache.\n         * @param key The key of the value to cache.\n         * @param value The value to cache.\n         * @return Returns the cache object.\n         */\n        set(key: any, value: any): this;\n        /**\n         * Removes all key-value entries from the map.\n         */\n        clear?: (() => void) | undefined;\n    }\n    interface MapCacheConstructor {\n        new (): MapCache;\n    }\n    interface Collection<T> {\n        pop(): T | undefined;\n        push(...items: T[]): this;\n        shift(): T | undefined;\n        sort(compareFn?: (a: T, b: T) => number): this;\n        splice(start: number, deleteCount?: number, ...items: T[]): this;\n        unshift(...items: T[]): this;\n    }\n    interface CollectionChain<T> {\n        pop(): ExpChain<T | undefined>;\n        push(...items: T[]): this;\n        shift(): ExpChain<T | undefined>;\n        sort(compareFn?: (a: T, b: T) => number): this;\n        splice(start: number, deleteCount?: number, ...items: T[]): this;\n        unshift(...items: T[]): this;\n    }\n\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.invokeMap\n         */\n        invokeMap(methodName: string, ...args: any[]): Collection<any>;\n        /**\n         * @see _.invokeMap\n         */\n        invokeMap<TResult>(method: (...args: any[]) => TResult, ...args: any[]): Collection<TResult>;\n    }\n\ninterface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.invokeMap\n         */\n        invokeMap(methodName: string, ...args: any[]): CollectionChain<any>;\n        /**\n         * @see _.invokeMap\n         */\n        invokeMap<TResult>(method: (...args: any[]) => TResult, ...args: any[]): CollectionChain<TResult>;\n    }\n\n    interface Function<T extends (...args: any) => any> extends LoDashImplicitWrapper<T> {\n    }\n    interface String extends LoDashImplicitWrapper<string> {\n    }\n    interface Object<T> extends LoDashImplicitWrapper<T> {\n    }\n    interface Collection<T> extends LoDashImplicitWrapper<T[]> {\n    }\n    interface Primitive<T> extends LoDashImplicitWrapper<T> {\n    }\n    interface FunctionChain<T extends (...args: any) => any> extends LoDashExplicitWrapper<T> {\n    }\n    interface StringChain extends LoDashExplicitWrapper<string> {\n    }\n    interface StringNullableChain extends LoDashExplicitWrapper<string | undefined> {\n    }\n    interface ObjectChain<T> extends LoDashExplicitWrapper<T> {\n    }\n    interface CollectionChain<T> extends LoDashExplicitWrapper<T[]> {\n    }\n    interface PrimitiveChain<T> extends LoDashExplicitWrapper<T> {\n    }\n    type NotVoid = unknown;\n    type IterateeShorthand<T> = PropertyName | [PropertyName, any] | PartialShallow<T>;\n    type ArrayIterator<T, TResult> = (value: T, index: number, collection: T[]) => TResult;\n    type ListIterator<T, TResult> = (value: T, index: number, collection: List<T>) => TResult;\n    type ListIteratee<T> = ListIterator<T, NotVoid> | IterateeShorthand<T>;\n    type ListIterateeCustom<T, TResult> = ListIterator<T, TResult> | IterateeShorthand<T>;\n    type ListIteratorTypeGuard<T, S extends T> = (value: T, index: number, collection: List<T>) => value is S;\n    // Note: key should be string, not keyof T, because the actual object may contain extra properties that were not specified in the type.\n    type ObjectIterator<TObject, TResult> = (value: TObject[keyof TObject], key: string, collection: TObject) => TResult;\n    type ObjectIteratee<TObject> = ObjectIterator<TObject, NotVoid> | IterateeShorthand<TObject[keyof TObject]>;\n    type ObjectIterateeCustom<TObject, TResult> = ObjectIterator<TObject, TResult> | IterateeShorthand<TObject[keyof TObject]>;\n    type ObjectIteratorTypeGuard<TObject, S extends TObject[keyof TObject]> = (value: TObject[keyof TObject], key: string, collection: TObject) => value is S;\n    type StringIterator<TResult> = (char: string, index: number, string: string) => TResult;\n    /** @deprecated Use MemoVoidArrayIterator or MemoVoidDictionaryIterator instead. */\n    type MemoVoidIterator<T, TResult> = (prev: TResult, curr: T, indexOrKey: any, list: T[]) => void;\n    /** @deprecated Use MemoListIterator or MemoObjectIterator instead. */\n    type MemoIterator<T, TResult> = (prev: TResult, curr: T, indexOrKey: any, list: T[]) => TResult;\n    type MemoListIterator<T, TResult, TList> = (prev: TResult, curr: T, index: number, list: TList) => TResult;\n    type MemoObjectIterator<T, TResult, TList> = (prev: TResult, curr: T, key: string, list: TList) => TResult;\n    type MemoIteratorCapped<T, TResult> = (prev: TResult, curr: T) => TResult;\n    type MemoIteratorCappedRight<T, TResult> = (curr: T, prev: TResult) => TResult;\n    type MemoVoidArrayIterator<T, TResult> = (acc: TResult, curr: T, index: number, arr: T[]) => void;\n    type MemoVoidDictionaryIterator<T, K extends string | number | symbol, TResult> = (acc: TResult, curr: T, key: K, dict: Record<K, T>) => void;\n    type MemoVoidIteratorCapped<T, TResult> = (acc: TResult, curr: T) => void;\n    type ValueIteratee<T> = ((value: T) => NotVoid) | IterateeShorthand<T>;\n    type ValueIterateeCustom<T, TResult> = ((value: T) => TResult) | IterateeShorthand<T>;\n    type ValueIteratorTypeGuard<T, S extends T> = (value: T) => value is S;\n    type ValueKeyIteratee<T> = ((value: T, key: string) => NotVoid) | IterateeShorthand<T>;\n    type ValueKeyIterateeTypeGuard<T, S extends T> = (value: T, key: string) => value is S;\n    type Comparator<T> = (a: T, b: T) => boolean;\n    type Comparator2<T1, T2> = (a: T1, b: T2) => boolean;\n    type PropertyName = string | number | symbol;\n    type PropertyPath = Many<PropertyName>;\n    /** Common interface between Arrays and jQuery objects */\n    type List<T> = ArrayLike<T>;\n    interface Dictionary<T> {\n        [index: string]: T;\n    }\n    interface NumericDictionary<T> {\n        [index: number]: T;\n    }\n    // Crazy typedef needed get _.omit to work properly with Dictionary and NumericDictionary\n    type AnyKindOfDictionary =\n        | Dictionary<unknown>\n        | NumericDictionary<unknown>;\n    type PartialShallow<T> = {\n        [P in keyof T]?: T[P] extends object ? object : T[P]\n    };\n    // For backwards compatibility\n    type LoDashImplicitArrayWrapper<T> = LoDashImplicitWrapper<T[]>;\n    type LoDashImplicitNillableArrayWrapper<T> = LoDashImplicitWrapper<T[] | null | undefined>;\n    type LoDashImplicitObjectWrapper<T> = LoDashImplicitWrapper<T>;\n    type LoDashImplicitNillableObjectWrapper<T> = LoDashImplicitWrapper<T | null | undefined>;\n    type LoDashImplicitNumberArrayWrapper = LoDashImplicitWrapper<number[]>;\n    type LoDashImplicitStringWrapper = LoDashImplicitWrapper<string>;\n    type LoDashExplicitArrayWrapper<T> = LoDashExplicitWrapper<T[]>;\n    type LoDashExplicitNillableArrayWrapper<T> = LoDashExplicitWrapper<T[] | null | undefined>;\n    type LoDashExplicitObjectWrapper<T> = LoDashExplicitWrapper<T>;\n    type LoDashExplicitNillableObjectWrapper<T> = LoDashExplicitWrapper<T | null | undefined>;\n    type LoDashExplicitNumberArrayWrapper = LoDashExplicitWrapper<number[]>;\n    type LoDashExplicitStringWrapper = LoDashExplicitWrapper<string>;\n    type DictionaryIterator<T, TResult> = ObjectIterator<Dictionary<T>, TResult>;\n    type DictionaryIteratee<T> = ObjectIteratee<Dictionary<T>>;\n    type DictionaryIteratorTypeGuard<T, S extends T> = ObjectIteratorTypeGuard<Dictionary<T>, S>;\n    // NOTE: keys of objects at run time are always strings, even when a NumericDictionary is being iterated.\n    type NumericDictionaryIterator<T, TResult> = (value: T, key: string, collection: NumericDictionary<T>) => TResult;\n    type NumericDictionaryIteratee<T> = NumericDictionaryIterator<T, NotVoid> | IterateeShorthand<T>;\n    type NumericDictionaryIterateeCustom<T, TResult> = NumericDictionaryIterator<T, TResult> | IterateeShorthand<T>;\n    interface RecursiveArray<T> extends Array<T|RecursiveArray<T>> {}\n    interface ListOfRecursiveArraysOrValues<T> extends List<T|RecursiveArray<T>> {}\n}\n\ndeclare module lodash {\n    interface LoDashStatic {\n        /**\n         * Creates an object composed of keys generated from the results of running each element of collection through\n         * iteratee. The corresponding value of each key is the number of times the key was returned by iteratee. The\n         * iteratee is invoked with one argument: (value).\n         *\n         * @param collection The collection to iterate over.\n         * @param iteratee The function invoked per iteration.\n         * @return Returns the composed aggregate object.\n         */\n        countBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): Dictionary<number>;\n        /**\n         * @see _.countBy\n         */\n        countBy<T extends object>(collection: T | null | undefined, iteratee?: ValueIteratee<T[keyof T]>): Dictionary<number>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.countBy\n         */\n        countBy(iteratee?: ValueIteratee<T[keyof T]>): Object<Dictionary<number>>;\n    }\n    interface String {\n        /**\n         * @see _.countBy\n         */\n        countBy(iteratee?: ValueIteratee<string>): Object<Dictionary<number>>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.countBy\n         */\n        countBy(iteratee?: ValueIteratee<T>): Object<Dictionary<number>>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.countBy\n         */\n        countBy(iteratee?: ValueIteratee<T[keyof T]>): ObjectChain<Dictionary<number>>;\n    }\n    interface StringChain {\n        /**\n         * @see _.countBy\n         */\n        countBy(iteratee?: ValueIteratee<string>): ObjectChain<Dictionary<number>>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.countBy\n         */\n        countBy(iteratee?: ValueIteratee<string>): ObjectChain<Dictionary<number>>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.countBy\n         */\n        countBy(iteratee?: ValueIteratee<T>): ObjectChain<Dictionary<number>>;\n    }\n    interface LoDashStatic {\n        /**\n         * @see _.forEach\n         */\n        each: LoDashStatic['forEach'];\n    }\n    interface String {\n        /**\n         * @see _.each\n         */\n        each: String['forEach'];\n    }\n    interface Collection<T> {\n        /**\n         * @see _.each\n         */\n        each: Collection<T>['forEach'];\n    }\n    interface Object<T> {\n        /**\n         * @see _.each\n         */\n        each: Object<T>['forEach'];\n    }\n    interface StringChain {\n        /**\n         * @see _.each\n         */\n        each: StringChain['forEach'];\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.each\n         */\n        each: StringNullableChain['forEach'];\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.each\n         */\n        each: CollectionChain<T>['forEach'];\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.each\n         */\n        each: ObjectChain<T>['forEach'];\n    }\n    interface LoDashStatic {\n        /**\n         * @see _.forEachRight\n         */\n        eachRight: LoDashStatic[\"forEachRight\"];\n    }\n    interface String {\n        /**\n         * @see _.eachRight\n         */\n        eachRight: String['forEachRight'];\n    }\n    interface Collection<T> {\n        /**\n         * @see _.eachRight\n         */\n        eachRight: Collection<T>['forEachRight'];\n    }\n    interface Object<T> {\n        /**\n         * @see _.eachRight\n         */\n        eachRight: Object<T>['forEachRight'];\n    }\n    interface StringChain {\n        /**\n         * @see _.eachRight\n         */\n        eachRight: StringChain['forEachRight'];\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.eachRight\n         */\n        eachRight: StringNullableChain['forEachRight'];\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.eachRight\n         */\n        eachRight: CollectionChain<T>['forEachRight'];\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.eachRight\n         */\n        eachRight: ObjectChain<T>['forEachRight'];\n    }\n    interface LoDashStatic {\n        /**\n         * Checks if predicate returns truthy for all elements of collection. Iteration is stopped once predicate\n         * returns falsey. The predicate is invoked with three arguments: (value, index|key, collection).\n         *\n         * @param collection The collection to iterate over.\n         * @param predicate The function invoked per iteration.\n         * @return Returns true if all elements pass the predicate check, else false.\n         */\n        every<T>(collection: List<T> | null | undefined, predicate?: ListIterateeCustom<T, boolean>): boolean;\n        /**\n         * @see _.every\n         */\n        every<T extends object>(collection: T | null | undefined, predicate?: ObjectIterateeCustom<T, boolean>): boolean;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.every\n         */\n        every(predicate?: ListIterateeCustom<T, boolean>): boolean;\n    }\n    interface Object<T> {\n        /**\n         * @see _.every\n         */\n        every(predicate?: ObjectIterateeCustom<T, boolean>): boolean;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.every\n         */\n        every(predicate?: ListIterateeCustom<T, boolean>): PrimitiveChain<boolean>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.every\n         */\n        every(predicate?: ObjectIterateeCustom<T, boolean>): PrimitiveChain<boolean>;\n    }\n    interface LoDashStatic {\n        /**\n         * Iterates over elements of collection, returning an array of all elements predicate returns truthy for. The\n         * predicate is invoked with three arguments: (value, index|key, collection).\n         *\n         * @param collection The collection to iterate over.\n         * @param predicate The function invoked per iteration.\n         * @return Returns the new filtered array.\n         */\n        filter(collection: string | null | undefined, predicate?: StringIterator<boolean>): string[];\n        /**\n         * @see _.filter\n         */\n        filter<T, S extends T>(collection: List<T> | null | undefined, predicate: ListIteratorTypeGuard<T, S>): S[];\n        /**\n         * @see _.filter\n         */\n        filter<T>(collection: List<T> | null | undefined, predicate?: ListIterateeCustom<T, boolean>): T[];\n        /**\n         * @see _.filter\n         */\n        filter<T extends object, S extends T[keyof T]>(collection: T | null | undefined, predicate: ObjectIteratorTypeGuard<T, S>): S[];\n        /**\n         * @see _.filter\n         */\n        filter<T extends object>(collection: T | null | undefined, predicate?: ObjectIterateeCustom<T, boolean>): Array<T[keyof T]>;\n    }\n    interface String {\n        /**\n         * @see _.filter\n         */\n        filter(predicate?: StringIterator<boolean>): Collection<string>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.filter\n         */\n        filter<S extends T>(predicate: ListIteratorTypeGuard<T, S>): Collection<S>;\n        /**\n         * @see _.filter\n         */\n        filter(predicate?: ListIterateeCustom<T, boolean>): Collection<T>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.filter\n         */\n        filter<S extends T[keyof T]>(predicate: ObjectIteratorTypeGuard<T, S>): Collection<S>;\n        /**\n         * @see _.filter\n         */\n        filter(predicate?: ObjectIterateeCustom<T, boolean>): Collection<T[keyof T]>;\n    }\n    interface StringChain {\n        /**\n         * @see _.filter\n         */\n        filter(predicate?: StringIterator<boolean>): CollectionChain<string>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.filter\n         */\n        filter(predicate?: StringIterator<boolean>): CollectionChain<string>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.filter\n         */\n        filter<S extends T>(predicate: ListIteratorTypeGuard<T, S>): CollectionChain<S>;\n        /**\n         * @see _.filter\n         */\n        filter(predicate?: ListIterateeCustom<T, boolean>): CollectionChain<T>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.filter\n         */\n        filter<S extends T[keyof T]>(predicate: ObjectIteratorTypeGuard<T, S>): CollectionChain<S>;\n        /**\n         * @see _.filter\n         */\n        filter(predicate?: ObjectIterateeCustom<T, boolean>): CollectionChain<T[keyof T]>;\n    }\n    interface LoDashStatic {\n        /**\n         * Iterates over elements of collection, returning the first element predicate returns truthy for.\n         * The predicate is invoked with three arguments: (value, index|key, collection).\n         *\n         * @param collection The collection to search.\n         * @param predicate The function invoked per iteration.\n         * @param fromIndex The index to search from.\n         * @return Returns the matched element, else undefined.\n         */\n        find<T, S extends T>(collection: List<T> | null | undefined, predicate: ListIteratorTypeGuard<T, S>, fromIndex?: number): S|undefined;\n        /**\n         * @see _.find\n         */\n        find<T>(collection: List<T> | null | undefined, predicate?: ListIterateeCustom<T, boolean>, fromIndex?: number): T|undefined;\n        /**\n         * @see _.find\n         */\n        find<T extends object, S extends T[keyof T]>(collection: T | null | undefined, predicate: ObjectIteratorTypeGuard<T, S>, fromIndex?: number): S|undefined;\n        /**\n         * @see _.find\n         */\n        find<T extends object>(collection: T | null | undefined, predicate?: ObjectIterateeCustom<T, boolean>, fromIndex?: number): T[keyof T]|undefined;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.find\n         */\n        find<S extends T>(predicate: ListIteratorTypeGuard<T, S>, fromIndex?: number): S|undefined;\n        /**\n         * @see _.find\n         */\n        find(predicate?: ListIterateeCustom<T, boolean>, fromIndex?: number): T|undefined;\n    }\n    interface Object<T> {\n        /**\n         * @see _.find\n         */\n        find< S extends T[keyof T]>(predicate: ObjectIteratorTypeGuard<T, S>, fromIndex?: number): S|undefined;\n        /**\n         * @see _.find\n         */\n        find(predicate?: ObjectIterateeCustom<T, boolean>, fromIndex?: number): T[keyof T]|undefined;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.find\n         */\n        find< S extends T>(predicate: ListIteratorTypeGuard<T, S>, fromIndex?: number): ExpChain<S|undefined>;\n        /**\n         * @see _.find\n         */\n        find(predicate?: ListIterateeCustom<T, boolean>, fromIndex?: number): ExpChain<T|undefined>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.find\n         */\n        find< S extends T[keyof T]>(predicate: ObjectIteratorTypeGuard<T, S>, fromIndex?: number): ExpChain<S|undefined>;\n        /**\n         * @see _.find\n         */\n        find(predicate?: ObjectIterateeCustom<T, boolean>, fromIndex?: number): ExpChain<T[keyof T]|undefined>;\n    }\n    interface LoDashStatic {\n        /**\n         * This method is like _.find except that it iterates over elements of a collection from\n         * right to left.\n         * @param collection Searches for a value in this list.\n         * @param predicate The function called per iteration.\n         * @param fromIndex The index to search from.\n         * @return The found element, else undefined.\n         */\n        findLast<T, S extends T>(collection: List<T> | null | undefined, predicate: ListIteratorTypeGuard<T, S>, fromIndex?: number): S|undefined;\n        /**\n         * @see _.findLast\n         */\n        findLast<T>(collection: List<T> | null | undefined, predicate?: ListIterateeCustom<T, boolean>, fromIndex?: number): T|undefined;\n        /**\n         * @see _.findLast\n         */\n        findLast<T extends object, S extends T[keyof T]>(collection: T | null | undefined, predicate: ObjectIteratorTypeGuard<T, S>, fromIndex?: number): S|undefined;\n        /**\n         * @see _.findLast\n         */\n        findLast<T extends object>(collection: T | null | undefined, predicate?: ObjectIterateeCustom<T, boolean>, fromIndex?: number): T[keyof T]|undefined;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.findLast\n         */\n        findLast<S extends T>(predicate: ListIteratorTypeGuard<T, S>, fromIndex?: number): S|undefined;\n        /**\n         * @see _.findLast\n         */\n        findLast(predicate?: ListIterateeCustom<T, boolean>, fromIndex?: number): T|undefined;\n    }\n    interface Object<T> {\n        /**\n         * @see _.findLast\n         */\n        findLast< S extends T[keyof T]>(predicate: ObjectIteratorTypeGuard<T, S>, fromIndex?: number): S|undefined;\n        /**\n         * @see _.findLast\n         */\n        findLast(predicate?: ObjectIterateeCustom<T, boolean>, fromIndex?: number): T[keyof T]|undefined;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.findLast\n         */\n        findLast< S extends T>(predicate: ListIteratorTypeGuard<T, S>, fromIndex?: number): ExpChain<S|undefined>;\n        /**\n         * @see _.findLast\n         */\n        findLast(predicate?: ListIterateeCustom<T, boolean>, fromIndex?: number): ExpChain<T|undefined>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.findLast\n         */\n        findLast< S extends T[keyof T]>(predicate: ObjectIteratorTypeGuard<T, S>, fromIndex?: number): ExpChain<S|undefined>;\n        /**\n         * @see _.findLast\n         */\n        findLast(predicate?: ObjectIterateeCustom<T, boolean>, fromIndex?: number): ExpChain<T[keyof T]|undefined>;\n    }\n    interface LoDashStatic {\n        /**\n         * Creates an array of flattened values by running each element in collection through iteratee\n         * and concating its result to the other mapped values. The iteratee is invoked with three arguments:\n         * (value, index|key, collection).\n         *\n         * @param collection The collection to iterate over.\n         * @param iteratee The function invoked per iteration.\n         * @return Returns the new flattened array.\n         */\n        flatMap<T>(collection: Dictionary<Many<T>> | NumericDictionary<Many<T>> | null | undefined): T[];\n        /**\n         * @see _.flatMap\n         */\n        flatMap(collection: object | null | undefined): any[];\n        /**\n         * @see _.flatMap\n         */\n        flatMap<T, TResult>(collection: List<T> | null | undefined, iteratee: ListIterator<T, Many<TResult>>): TResult[];\n        /**\n         * @see _.flatMap\n         */\n        flatMap<T extends object, TResult>(collection: T | null | undefined, iteratee: ObjectIterator<T, Many<TResult>>): TResult[];\n        /**\n         * @see _.flatMap\n         */\n        flatMap(collection: object | null | undefined, iteratee: string): any[];\n        /**\n         * @see _.flatMap\n         */\n        flatMap(collection: object | null | undefined, iteratee: object): boolean[];\n    }\n    interface String {\n        /**\n         * @see _.flatMap\n         */\n        flatMap<TResult>(iteratee: StringIterator<Many<TResult>>): Collection<TResult>;\n        /**\n         * @see _.flatMap\n         */\n        flatMap(): Collection<string>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.flatMap\n         */\n        flatMap<TResult = any>(iteratee: ListIterator<T, Many<TResult>> | PropertyName): Collection<TResult>;\n        /**\n         * @see _.flatMap\n         */\n        flatMap(iteratee: [PropertyName, any] | object): Collection<boolean>;\n        /**\n         * @see _.flatMap\n         */\n        flatMap(): T extends Many<infer U> ? Collection<U> : Collection<T>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.flatMap\n         */\n        flatMap<TResult = any>(iteratee: ObjectIterator<T, Many<TResult>> | PropertyName): Collection<TResult>;\n        /**\n         * @see _.flatMap\n         */\n        flatMap(iteratee: [PropertyName, any] | object): Collection<boolean>;\n        /**\n         * @see _.flatMap\n         */\n        flatMap(): Collection<T[keyof T]>;\n    }\n    interface StringChain {\n        /**\n         * @see _.flatMap\n         */\n        flatMap<TResult>(iteratee: StringIterator<Many<TResult>>): CollectionChain<TResult>;\n        /**\n         * @see _.flatMap\n         */\n        flatMap(): CollectionChain<string>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.flatMap\n         */\n        flatMap<TResult>(iteratee: StringIterator<Many<TResult>>): CollectionChain<TResult>;\n        /**\n         * @see _.flatMap\n         */\n        flatMap(): CollectionChain<string>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.flatMap\n         */\n        flatMap<TResult = any>(iteratee: ListIterator<T, Many<TResult>> | PropertyName): CollectionChain<TResult>;\n        /**\n         * @see _.flatMap\n         */\n        flatMap(iteratee: [PropertyName, any] | object): CollectionChain<boolean>;\n        /**\n         * @see _.flatMap\n         */\n        flatMap(): T extends Many<infer U> ? CollectionChain<U> : CollectionChain<T>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.flatMap\n         */\n        flatMap<TResult = any>(iteratee: ObjectIterator<T, Many<TResult>> | PropertyName): CollectionChain<TResult>;\n        /**\n         * @see _.flatMap\n         */\n        flatMap(iteratee: [PropertyName, any] | object): CollectionChain<boolean>;\n        /**\n         * @see _.flatMap\n         */\n        flatMap(): CollectionChain<T[keyof T]>;\n    }\n    interface LoDashStatic {\n        /**\n         * This method is like _.flatMap except that it recursively flattens the\n         * mapped results.\n         *\n         * @since 4.7.0\n         * @category Collection\n         * @param collection The collection to iterate over.\n         * @param [iteratee=_.identity] The function invoked per iteration.\n         * @returns Returns the new flattened array.\n         * @example\n         *\n         * function duplicate(n) {\n         *   return [[[n, n]]];\n         * }\n         *\n         * _.flatMapDeep([1, 2], duplicate);\n         * // => [1, 1, 2, 2]\n         */\n        flatMapDeep<T>(collection: Dictionary<ListOfRecursiveArraysOrValues<T> | T> | NumericDictionary<ListOfRecursiveArraysOrValues<T> | T> | null | undefined): T[];\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep<T, TResult>(collection: List<T> | null | undefined, iteratee: ListIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult>): TResult[];\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep<T extends object, TResult>(collection: T | null | undefined, iteratee: ObjectIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult>): TResult[];\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(collection: object | null | undefined, iteratee: string): any[];\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(collection: object | null | undefined, iteratee: object): boolean[];\n    }\n    interface String {\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep<TResult>(iteratee: StringIterator<ListOfRecursiveArraysOrValues<TResult> | TResult>): Collection<TResult>;\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(): Collection<string>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep<TResult = any>(iteratee: ListIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult> | PropertyName): Collection<TResult>;\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(iteratee: [PropertyName, any] | object): Collection<boolean>;\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(): Collection<T>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep<TResult = any>(iteratee: ObjectIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult> | PropertyName): Collection<TResult>;\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(iteratee: [PropertyName, any] | object): Collection<boolean>;\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(): Collection<T[keyof T]>;\n    }\n    interface StringChain {\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep<TResult>(iteratee: StringIterator<ListOfRecursiveArraysOrValues<TResult> | TResult>): CollectionChain<TResult>;\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(): CollectionChain<string>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep<TResult>(iteratee: StringIterator<ListOfRecursiveArraysOrValues<TResult> | TResult>): CollectionChain<TResult>;\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(): CollectionChain<string>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep<TResult = any>(iteratee: ListIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult> | PropertyName): CollectionChain<TResult>;\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(iteratee: [PropertyName, any] | object): CollectionChain<boolean>;\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(): CollectionChain<T>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep<TResult = any>(iteratee: ObjectIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult> | PropertyName): CollectionChain<TResult>;\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(iteratee: [PropertyName, any] | object): CollectionChain<boolean>;\n        /**\n         * @see _.flatMapDeep\n         */\n        flatMapDeep(): CollectionChain<T[keyof T]>;\n    }\n    interface LoDashStatic {\n        /**\n         * This method is like _.flatMap except that it recursively flattens the\n         * mapped results up to depth times.\n         *\n         * @since 4.7.0\n         * @category Collection\n         * @param collection The collection to iterate over.\n         * @param [iteratee=_.identity] The function invoked per iteration.\n         * @param [depth=1] The maximum recursion depth.\n         * @returns Returns the new flattened array.\n         * @example\n         *\n         * function duplicate(n) {\n         *   return [[[n, n]]];\n         * }\n         *\n         * _.flatMapDepth([1, 2], duplicate, 2);\n         * // => [[1, 1], [2, 2]]\n         */\n        flatMapDepth<T>(collection: Dictionary<ListOfRecursiveArraysOrValues<T> | T> | NumericDictionary<ListOfRecursiveArraysOrValues<T> | T> | null | undefined): T[];\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth<T, TResult>(collection: List<T> | null | undefined, iteratee: ListIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult>, depth?: number): TResult[];\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth<T extends object, TResult>(collection: T | null | undefined, iteratee: ObjectIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult>, depth?: number): TResult[];\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(collection: object | null | undefined, iteratee: string, depth?: number): any[];\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(collection: object | null | undefined, iteratee: object, depth?: number): boolean[];\n    }\n    interface String {\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth<TResult>(iteratee: StringIterator<ListOfRecursiveArraysOrValues<TResult> | TResult>, depth?: number): Collection<TResult>;\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(depth?: number): Collection<string>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth<TResult = any>(iteratee: ListIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult> | PropertyName, depth?: number): Collection<TResult>;\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(iteratee: [PropertyName, any] | object, depth?: number): Collection<boolean>;\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(depth?: number): Collection<T>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth<TResult = any>(iteratee: ObjectIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult> | PropertyName, depth?: number): Collection<TResult>;\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(iteratee: [PropertyName, any] | object, depth?: number): Collection<boolean>;\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(depth?: number): Collection<T[keyof T]>;\n    }\n    interface StringChain {\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth<TResult>(iteratee: StringIterator<ListOfRecursiveArraysOrValues<TResult> | TResult>, depth?: number): CollectionChain<TResult>;\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(depth?: number): CollectionChain<string>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth<TResult>(iteratee: StringIterator<ListOfRecursiveArraysOrValues<TResult> | TResult>, depth?: number): CollectionChain<TResult>;\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(depth?: number): CollectionChain<string>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth<TResult = any>(iteratee: ListIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult> | PropertyName, depth?: number): CollectionChain<TResult>;\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(iteratee: [PropertyName, any] | object, depth?: number): CollectionChain<boolean>;\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(depth?: number): CollectionChain<T>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth<TResult = any>(iteratee: ObjectIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult> | PropertyName, depth?: number): CollectionChain<TResult>;\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(iteratee: [PropertyName, any] | object, depth?: number): CollectionChain<boolean>;\n        /**\n         * @see _.flatMapDepth\n         */\n        flatMapDepth(depth?: number): CollectionChain<T[keyof T]>;\n    }\n    interface LoDashStatic {\n        /**\n         * Iterates over elements of collection invoking iteratee for each element. The iteratee is invoked with three arguments:\n         * (value, index|key, collection). Iteratee functions may exit iteration early by explicitly returning false.\n         *\n         * Note: As with other \"Collections\" methods, objects with a \"length\" property are iterated like arrays. To\n         * avoid this behavior _.forIn or _.forOwn may be used for object iteration.\n         *\n         * @alias _.each\n         *\n         * @param collection The collection to iterate over.\n         * @param iteratee The function invoked per iteration.\n         */\n        forEach<T>(collection: T[], iteratee?: ArrayIterator<T, any>): T[];\n        /**\n         * @see _.forEach\n         */\n        forEach(collection: string, iteratee?: StringIterator<any>): string;\n        /**\n         * @see _.forEach\n         */\n        forEach<T>(collection: List<T>, iteratee?: ListIterator<T, any>): List<T>;\n        /**\n         * @see _.forEach\n         */\n        forEach<T extends object>(collection: T, iteratee?: ObjectIterator<T, any>): T;\n        /**\n         * @see _.forEach\n         */\n        forEach<T, TArray extends T[] | null | undefined>(collection: TArray & (T[] | null | undefined), iteratee?: ArrayIterator<T, any>): TArray;\n        /**\n         * @see _.forEach\n         */\n        forEach<TString extends string | null | undefined>(collection: TString, iteratee?: StringIterator<any>): TString;\n        /**\n         * @see _.forEach\n         */\n        forEach<T, TList extends List<T> | null | undefined>(collection: TList & (List<T> | null | undefined), iteratee?: ListIterator<T, any>): TList;\n        /**\n         * @see _.forEach\n         */\n        forEach<T extends object>(collection: T | null | undefined, iteratee?: ObjectIterator<T, any>): T | null | undefined;\n    }\n    interface String {\n        /**\n         * @see _.forEach\n         */\n        forEach(iteratee?: StringIterator<any>): String;\n    }\n    interface Object<T> {\n        /**\n         * @see _.forEach\n         */\n        forEach(iteratee?: ObjectIterator<T, any>): Object<T>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.forEach\n         */\n        forEach(iteratee?: ListIterator<T, any>): Collection<T>;\n    }\n    interface StringChain {\n        /**\n         * @see _.forEach\n         */\n        forEach(iteratee?: StringIterator<any>): StringChain;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.forEach\n         */\n        forEach(iteratee?: StringIterator<any>): StringNullableChain;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.forEach\n         */\n        forEach(iteratee?: ObjectIterator<T, any>): ObjectChain<T>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.forEach\n         */\n        forEach(iteratee?: ListIterator<T, any>): CollectionChain<T>;\n    }\n    interface LoDashStatic {\n        /**\n         * This method is like _.forEach except that it iterates over elements of collection from right to left.\n         *\n         * @alias _.eachRight\n         *\n         * @param collection The collection to iterate over.\n         * @param iteratee The function called per iteration.\n         */\n        forEachRight<T>(collection: T[], iteratee?: ArrayIterator<T, any>): T[];\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight(collection: string, iteratee?: StringIterator<any>): string;\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight<T>(collection: List<T>, iteratee?: ListIterator<T, any>): List<T>;\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight<T extends object>(collection: T, iteratee?: ObjectIterator<T, any>): T;\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight<T, TArray extends T[] | null | undefined>(collection: TArray & (T[] | null | undefined), iteratee?: ArrayIterator<T, any>): TArray;\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight<TString extends string | null | undefined>(collection: TString, iteratee?: StringIterator<any>): TString;\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight<T, TList extends List<T> | null | undefined>(collection: TList & (List<T> | null | undefined), iteratee?: ListIterator<T, any>): TList;\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight<T extends object>(collection: T | null | undefined, iteratee?: ObjectIterator<T, any>): T | null | undefined;\n    }\n    interface String {\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight(iteratee?: StringIterator<any>): String;\n    }\n    interface Object<T> {\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight(iteratee?: ObjectIterator<T, any>): Object<T>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight(iteratee?: ListIterator<T, any>): Collection<T>;\n    }\n    interface StringChain {\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight(iteratee?: StringIterator<any>): StringChain;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight(iteratee?: StringIterator<any>): StringNullableChain;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight(iteratee?: ObjectIterator<T, any>): ObjectChain<T>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.forEachRight\n         */\n        forEachRight(iteratee?: ListIterator<T, any>): CollectionChain<T>;\n    }\n    interface LoDashStatic {\n        /**\n         * Creates an object composed of keys generated from the results of running each element of collection through\n         * iteratee. The corresponding value of each key is an array of the elements responsible for generating the\n         * key. The iteratee is invoked with one argument: (value).\n         *\n         * @param collection The collection to iterate over.\n         * @param iteratee The function invoked per iteration.\n         * @return Returns the composed aggregate object.\n         */\n        groupBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIteratee<T>): Dictionary<T[]>;\n        /**\n         * @see _.groupBy\n         */\n        groupBy<T extends object>(collection: T | null | undefined, iteratee?: ValueIteratee<T[keyof T]>): Dictionary<Array<T[keyof T]>>;\n    }\n    interface String {\n        /**\n         * @see _.groupBy\n         */\n        groupBy(iteratee?: ValueIteratee<string>): Object<Dictionary<string[]>>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.groupBy\n         */\n        groupBy(iteratee?: ValueIteratee<T>): Object<Dictionary<T[]>>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.groupBy\n         */\n        groupBy(iteratee?: ValueIteratee<T[keyof T]>): Object<Dictionary<Array<T[keyof T]>>>;\n    }\n    interface StringChain {\n        /**\n         * @see _.groupBy\n         */\n        groupBy(iteratee?: ValueIteratee<string>): ObjectChain<Dictionary<string[]>>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.groupBy\n         */\n        groupBy(iteratee?: ValueIteratee<string>): ObjectChain<Dictionary<string[]>>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.groupBy\n         */\n        groupBy(iteratee?: ValueIteratee<T>): ObjectChain<Dictionary<T[]>>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.groupBy\n         */\n        groupBy(iteratee?: ValueIteratee<T[keyof T]>): ObjectChain<Dictionary<Array<T[keyof T]>>>;\n    }\n    interface LoDashStatic {\n        /**\n         * Checks if target is in collection using SameValueZero for equality comparisons. If fromIndex is negative,\n         * it’s used as the offset from the end of collection.\n         *\n         * @param collection The collection to search.\n         * @param target The value to search for.\n         * @param fromIndex The index to search from.\n         * @return True if the target element is found, else false.\n         */\n        includes<T>(collection: Dictionary<T> | NumericDictionary<T> | null | undefined, target: T, fromIndex?: number): boolean;\n    }\n    interface Object<T> {\n        /**\n         * @see _.includes\n         */\n        includes(target: T[keyof T], fromIndex?: number): boolean;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.includes\n         */\n        includes(target: T, fromIndex?: number): boolean;\n    }\n    interface String {\n        /**\n         * @see _.includes\n         */\n        includes(target: string, fromIndex?: number): boolean;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.includes\n         */\n        includes(target: T[keyof T], fromIndex?: number): PrimitiveChain<boolean>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.includes\n         */\n        includes(target: T, fromIndex?: number): PrimitiveChain<boolean>;\n    }\n    interface StringChain {\n        /**\n         * @see _.includes\n         */\n        includes(target: string, fromIndex?: number): PrimitiveChain<boolean>;\n    }\n    interface LoDashStatic {\n        /**\n        * Invokes the method named by methodName on each element in the collection returning\n        * an array of the results of each invoked method. Additional arguments will be provided\n        * to each invoked method. If methodName is a function it will be invoked for, and this\n        * bound to, each element in the collection.\n        * @param collection The collection to iterate over.\n        * @param methodName The name of the method to invoke.\n        * @param args Arguments to invoke the method with.\n         */\n        invokeMap(collection: object | null | undefined, methodName: string, ...args: any[]): any[];\n        /**\n         * @see _.invokeMap\n         */\n        invokeMap<TResult>(collection: object | null | undefined, method: (...args: any[]) => TResult, ...args: any[]): TResult[];\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.invokeMap\n         */\n        invokeMap(methodName: string, ...args: any[]): Collection<any>;\n        /**\n         * @see _.invokeMap\n         */\n        invokeMap<TResult>(method: (...args: any[]) => TResult, ...args: any[]): Collection<TResult>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.invokeMap\n         */\n        invokeMap(methodName: string, ...args: any[]): CollectionChain<any>;\n        /**\n         * @see _.invokeMap\n         */\n        invokeMap<TResult>(method: (...args: any[]) => TResult, ...args: any[]): CollectionChain<TResult>;\n    }\n    interface LoDashStatic {\n        /**\n         * Creates an object composed of keys generated from the results of running each element of collection through\n         * iteratee. The corresponding value of each key is the last element responsible for generating the key. The\n         * iteratee function is invoked with one argument: (value).\n         *\n         * @param collection The collection to iterate over.\n         * @param iteratee The function invoked per iteration.\n         * @return Returns the composed aggregate object.\n         */\n        keyBy<T>(collection: List<T> | null | undefined, iteratee?: ValueIterateeCustom<T, PropertyName>): Dictionary<T>;\n        /**\n         * @see _.keyBy\n         */\n        keyBy<T extends object>(collection: T | null | undefined, iteratee?: ValueIterateeCustom<T[keyof T], PropertyName>): Dictionary<T[keyof T]>;\n    }\n    interface String {\n        /**\n         * @see _.keyBy\n         */\n        keyBy(iteratee?: ValueIterateeCustom<string, PropertyName>): Object<Dictionary<string>>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.keyBy\n         */\n        keyBy(iteratee?: ValueIterateeCustom<T, PropertyName>): Object<Dictionary<T>>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.keyBy\n         */\n        keyBy(iteratee?: ValueIterateeCustom<T[keyof T], PropertyName>): Object<Dictionary<T[keyof T]>>;\n    }\n    interface StringChain {\n        /**\n         * @see _.keyBy\n         */\n        keyBy(iteratee?: ValueIterateeCustom<string, PropertyName>): ObjectChain<Dictionary<string>>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.keyBy\n         */\n        keyBy(iteratee?: ValueIterateeCustom<string, PropertyName>): ObjectChain<Dictionary<string>>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.keyBy\n         */\n        keyBy(iteratee?: ValueIterateeCustom<T, PropertyName>): ObjectChain<Dictionary<T>>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.keyBy\n         */\n        keyBy(iteratee?: ValueIterateeCustom<T[keyof T], PropertyName>): ObjectChain<Dictionary<T[keyof T]>>;\n    }\n    interface LoDashStatic {\n        /**\n         * Creates an array of values by running each element in collection through iteratee. The iteratee is\n         * invoked with three arguments: (value, index|key, collection).\n         *\n         * Many lodash methods are guarded to work as iteratees for methods like _.every, _.filter, _.map, _.mapValues,\n         * _.reject, and _.some.\n         *\n         * The guarded methods are:\n         * ary, callback, chunk, clone, create, curry, curryRight, drop, dropRight, every, fill, flatten, invert, max,\n         * min, parseInt, slice, sortBy, take, takeRight, template, trim, trimLeft, trimRight, trunc, random, range,\n         * sample, some, sum, uniq, and words\n         *\n         * @param collection The collection to iterate over.\n         * @param iteratee The function invoked per iteration.\n         * @return Returns the new mapped array.\n         */\n        map<T, TResult>(collection: T[] | null | undefined, iteratee: ArrayIterator<T, TResult>): TResult[];\n        /**\n         * @see _.map\n         */\n        map<T, TResult>(collection: List<T> | null | undefined, iteratee: ListIterator<T, TResult>): TResult[];\n        /**\n         * @see _.map\n         */\n        map<T>(collection: Dictionary<T> | NumericDictionary<T> | null | undefined): T[];\n        /**\n         * @see _.map\n         */\n        map<T extends object, TResult>(collection: T | null | undefined, iteratee: ObjectIterator<T, TResult>): TResult[];\n        /**\n         * @see _.map\n         */\n        map<T, K extends keyof T>(collection: Dictionary<T> | NumericDictionary<T> | null | undefined, iteratee: K): Array<T[K]>;\n        /**\n         * @see _.map\n         */\n        map<T>(collection: Dictionary<T> | NumericDictionary<T> | null | undefined, iteratee?: string): any[];\n        /**\n         * @see _.map\n         */\n        map<T>(collection: Dictionary<T> | NumericDictionary<T> | null | undefined, iteratee?: object): boolean[];\n    }\n\n    interface String {\n        /**\n         * @see _.map\n         */\n        map<TResult>(iteratee: StringIterator<TResult>): Collection<TResult>;\n        /**\n         * @see _.map\n         */\n        map(): Collection<string>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.map\n         */\n        map<K extends keyof T>(key: K): Collection<T[K]>;\n        /**\n         * @see _.map\n         */\n        map<TResult>(iteratee: ListIterator<T, TResult>): Collection<TResult>;\n        /**\n         * @see _.map\n         */\n        map(iteratee: PropertyName): Collection<any>;\n        /**\n         * @see _.map\n         */\n        map(iteratee: [PropertyName, any] | object): Collection<boolean>;\n        /**\n         * @see _.map\n         */\n        map(): Collection<T>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.map\n         */\n        map<K extends keyof T[keyof T]>(key: K): Collection<T[keyof T][K]>;\n        /**\n         * @see _.map\n         */\n        map<TResult>(iteratee: ObjectIterator<T, TResult>): Collection<TResult>;\n        /**\n         * @see _.map\n         */\n        map(iteratee: PropertyName): Collection<any>;\n        /**\n         * @see _.map\n         */\n        map(iteratee: [PropertyName, any] | object): Collection<boolean>;\n        /**\n         * @see _.map\n         */\n        map(): Collection<T[keyof T]>;\n    }\n    interface StringChain {\n        /**\n         * @see _.map\n         */\n        map<TResult>(iteratee: StringIterator<TResult>): CollectionChain<TResult>;\n        /**\n         * @see _.map\n         */\n        map(): CollectionChain<string>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.map\n         */\n        map<TResult>(iteratee: StringIterator<TResult>): CollectionChain<TResult>;\n        /**\n         * @see _.map\n         */\n        map(): CollectionChain<string>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.map\n         */\n        map<K extends keyof T>(key: K): CollectionChain<T[K]>;\n        /**\n         * @see _.map\n         */\n        map<TResult>(iteratee: ListIterator<T, TResult>): CollectionChain<TResult>;\n        /**\n         * @see _.map\n         */\n        map(iteratee: PropertyName): CollectionChain<any>;\n        /**\n         * @see _.map\n         */\n        map(iteratee: [PropertyName, any] | object): CollectionChain<boolean>;\n        /**\n         * @see _.map\n         */\n        map(): CollectionChain<T>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.map\n         */\n        map<K extends keyof T[keyof T]>(key: K): CollectionChain<T[keyof T][K]>;\n        /**\n         * @see _.map\n         */\n        map<TResult>(iteratee: ObjectIterator<T, TResult>): CollectionChain<TResult>;\n        /**\n         * @see _.map\n         */\n        map(iteratee: PropertyName): CollectionChain<any>;\n        /**\n         * @see _.map\n         */\n        map(iteratee: [PropertyName, any] | object): CollectionChain<boolean>;\n        /**\n         * @see _.map\n         */\n        map(): CollectionChain<T[keyof T]>;\n    }\n    interface LoDashStatic {\n        /**\n         * This method is like _.sortBy except that it allows specifying the sort\n         * orders of the iteratees to sort by. If orders is unspecified, all values\n         * are sorted in ascending order. Otherwise, specify an order of \"desc\" for\n         * descending or \"asc\" for ascending sort order of corresponding values.\n         *\n         * @category Collection\n         * @param collection The collection to iterate over.\n         * @param [iteratees=[_.identity]] The iteratees to sort by.\n         * @param [orders] The sort orders of iteratees.\n         * @param- {Object} [guard] Enables use as an iteratee for functions like _.reduce.\n         * @returns Returns the new sorted array.\n         * @example\n         *\n         * var users = [\n         *   { 'user': 'fred',   'age': 48 },\n         *   { 'user': 'barney', 'age': 34 },\n         *   { 'user': 'fred',   'age': 42 },\n         *   { 'user': 'barney', 'age': 36 }\n         * ];\n         *\n         * // sort by user in ascending order and by age in descending order\n         * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);\n         * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]\n         */\n        orderBy<T>(collection: List<T> | null | undefined, iteratees?: Many<ListIterator<T, NotVoid>>, orders?: Many<boolean|\"asc\"|\"desc\">): T[];\n        /**\n         * @see _.orderBy\n         */\n        orderBy<T>(collection: List<T> | null | undefined, iteratees?: Many<ListIteratee<T>>, orders?: Many<boolean|\"asc\"|\"desc\">): T[];\n        /**\n         * @see _.orderBy\n         */\n        orderBy<T extends object>(collection: T | null | undefined, iteratees?: Many<ObjectIterator<T, NotVoid>>, orders?: Many<boolean|\"asc\"|\"desc\">): Array<T[keyof T]>;\n        /**\n         * @see _.orderBy\n         */\n        orderBy<T extends object>(collection: T | null | undefined, iteratees?: Many<ObjectIteratee<T>>, orders?: Many<boolean|\"asc\"|\"desc\">): Array<T[keyof T]>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.orderBy\n         */\n        orderBy(iteratees?: Many<ListIterator<T, NotVoid> | PropertyName | PartialShallow<T>>, orders?: Many<boolean|\"asc\"|\"desc\">): Collection<T>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.orderBy\n         */\n        orderBy(iteratees?: Many<ObjectIterator<T, NotVoid>>, orders?: Many<boolean|\"asc\"|\"desc\">): Collection<T[keyof T]>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.orderBy\n         */\n        orderBy(iteratees?: Many<ListIterator<T, NotVoid> | PropertyName | PartialShallow<T>>, orders?: Many<boolean|\"asc\"|\"desc\">): CollectionChain<T>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.orderBy\n         */\n        orderBy(iteratees?: Many<ObjectIterator<T, NotVoid>>, orders?: Many<boolean|\"asc\"|\"desc\">): CollectionChain<T[keyof T]>;\n    }\n    interface LoDashStatic {\n        /**\n        * Creates an array of elements split into two groups, the first of which contains elements predicate returns truthy for,\n        * while the second of which contains elements predicate returns falsey for.\n        * The predicate is invoked with three arguments: (value, index|key, collection).\n        *\n        * @param collection The collection to iterate over.\n        * @param callback The function called per iteration.\n        * @return Returns the array of grouped elements.\n         */\n        partition<T, U extends T>(collection: List<T> | null | undefined, callback: ValueIteratorTypeGuard<T, U>): [U[], Array<Exclude<T, U>>];\n        /**\n         * @see _.partition\n         */\n        partition<T>(collection: List<T> | null | undefined, callback: ValueIteratee<T>): [T[], T[]];\n        /**\n         * @see _.partition\n         */\n        partition<T extends object>(collection: T | null | undefined, callback: ValueIteratee<T[keyof T]>): [Array<T[keyof T]>, Array<T[keyof T]>];\n    }\n    interface String {\n        /**\n         * @see _.partition\n         */\n        partition(callback: StringIterator<NotVoid>): LoDashImplicitWrapper<[string[], string[]]>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.partition\n         */\n        partition<U extends T>(callback: ValueIteratorTypeGuard<T, U>): LoDashImplicitWrapper<[U[], Array<Exclude<T, U>>]>;\n        /**\n         * @see _.partition\n         */\n        partition(callback: ValueIteratee<T>): LoDashImplicitWrapper<[T[], T[]]>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.partition\n         */\n        partition(callback: ValueIteratee<T[keyof T]>): LoDashImplicitWrapper<[Array<T[keyof T]>, Array<T[keyof T]>]>;\n    }\n    interface StringChain {\n        /**\n         * @see _.partition\n         */\n        partition(callback: StringIterator<NotVoid>): LoDashExplicitWrapper<[string[], string[]]>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.partition\n         */\n        partition(callback: StringIterator<NotVoid>): LoDashExplicitWrapper<[string[], string[]]>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.partition\n         */\n        partition<U extends T>(callback: ValueIteratorTypeGuard<T, U>): LoDashExplicitWrapper<[U[], Array<Exclude<T, U>>]>;\n        /**\n         * @see _.partition\n         */\n        partition(callback: ValueIteratee<T>): LoDashExplicitWrapper<[T[], T[]]>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.partition\n         */\n        partition(callback: ValueIteratee<T[keyof T]>): LoDashExplicitWrapper<[Array<T[keyof T]>, Array<T[keyof T]>]>;\n    }\n    interface LoDashStatic {\n        /**\n        * Reduces a collection to a value which is the accumulated result of running each\n        * element in the collection through the callback, where each successive callback execution\n        * consumes the return value of the previous execution. If accumulator is not provided the\n        * first element of the collection will be used as the initial accumulator value. The callback\n        * is invoked with four arguments: (accumulator, value, index|key, collection).\n        * @param collection The collection to iterate over.\n        * @param callback The function called per iteration.\n        * @param accumulator Initial value of the accumulator.\n        * @return Returns the accumulated value.\n         */\n        reduce<T, TResult>(collection: T[] | null | undefined, callback: MemoListIterator<T, TResult, T[]>, accumulator: TResult): TResult;\n        /**\n         * @see _.reduce\n         */\n        reduce<T, TResult>(collection: List<T> | null | undefined, callback: MemoListIterator<T, TResult, List<T>>, accumulator: TResult): TResult;\n        /**\n         * @see _.reduce\n         */\n        reduce<T extends object, TResult>(collection: T | null | undefined, callback: MemoObjectIterator<T[keyof T], TResult, T>, accumulator: TResult): TResult;\n        /**\n         * @see _.reduce\n         */\n        reduce<T>(collection: T[] | null | undefined, callback: MemoListIterator<T, T, T[]>): T | undefined;\n        /**\n         * @see _.reduce\n         */\n        reduce<T>(collection: List<T> | null | undefined, callback: MemoListIterator<T, T, List<T>>): T | undefined;\n        /**\n         * @see _.reduce\n         */\n        reduce<T extends object>(collection: T | null | undefined, callback: MemoObjectIterator<T[keyof T], T[keyof T], T>): T[keyof T] | undefined;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.reduce\n         */\n        reduce<TResult>(callback: MemoListIterator<T, TResult, List<T>>, accumulator: TResult): TResult;\n        /**\n         * @see _.reduce\n         */\n        reduce(callback: MemoListIterator<T, T, List<T>>): T | undefined;\n    }\n    interface Object<T> {\n        /**\n         * @see _.reduce\n         */\n        reduce<TResult>(callback: MemoObjectIterator<T[keyof T], TResult, T>, accumulator: TResult): TResult;\n        /**\n         * @see _.reduce\n         */\n        reduce(callback: MemoObjectIterator<T[keyof T], T[keyof T], T>): T[keyof T] | undefined;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.reduce\n         */\n        reduce<TResult>(callback: MemoListIterator<T, TResult, List<T>>, accumulator: TResult): ExpChain<TResult>;\n        /**\n         * @see _.reduce\n         */\n        reduce(callback: MemoListIterator<T, T, List<T>>): ExpChain<T | undefined>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.reduce\n         */\n        reduce<TResult>(callback: MemoObjectIterator<T[keyof T], TResult, T>, accumulator: TResult): ExpChain<TResult>;\n        /**\n         * @see _.reduce\n         */\n        reduce(callback: MemoObjectIterator<T[keyof T], T[keyof T], T>): ExpChain<T[keyof T] | undefined>;\n    }\n    interface LoDashStatic {\n        /**\n        * This method is like _.reduce except that it iterates over elements of a collection from\n        * right to left.\n        * @param collection The collection to iterate over.\n        * @param callback The function called per iteration.\n        * @param accumulator Initial value of the accumulator.\n        * @return The accumulated value.\n         */\n        reduceRight<T, TResult>(collection: T[] | null | undefined, callback: MemoListIterator<T, TResult, T[]>, accumulator: TResult): TResult;\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight<T, TResult>(collection: List<T> | null | undefined, callback: MemoListIterator<T, TResult, List<T>>, accumulator: TResult): TResult;\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight<T extends object, TResult>(collection: T | null | undefined, callback: MemoObjectIterator<T[keyof T], TResult, T>, accumulator: TResult): TResult;\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight<T>(collection: T[] | null | undefined, callback: MemoListIterator<T, T, T[]>): T | undefined;\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight<T>(collection: List<T> | null | undefined, callback: MemoListIterator<T, T, List<T>>): T | undefined;\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight<T extends object>(collection: T | null | undefined, callback: MemoObjectIterator<T[keyof T], T[keyof T], T>): T[keyof T] | undefined;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight<TResult>(callback: MemoListIterator<T, TResult, List<T>>, accumulator: TResult): TResult;\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight(callback: MemoListIterator<T, T, List<T>>): T | undefined;\n    }\n    interface Object<T> {\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight<TResult>(callback: MemoObjectIterator<T[keyof T], TResult, T>, accumulator: TResult): TResult;\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight(callback: MemoObjectIterator<T[keyof T], T[keyof T], T>): T[keyof T] | undefined;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight<TResult>(callback: MemoListIterator<T, TResult, List<T>>, accumulator: TResult): ExpChain<TResult>;\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight(callback: MemoListIterator<T, T, List<T>>): ExpChain<T | undefined>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight<TResult>(callback: MemoObjectIterator<T[keyof T], TResult, T>, accumulator: TResult): ExpChain<TResult>;\n        /**\n         * @see _.reduceRight\n         */\n        reduceRight(callback: MemoObjectIterator<T[keyof T], T[keyof T], T>): ExpChain<T[keyof T] | undefined>;\n    }\n    interface LoDashStatic {\n        /**\n         * The opposite of _.filter; this method returns the elements of collection that predicate does not return\n         * truthy for.\n         *\n         * @param collection The collection to iterate over.\n         * @param predicate The function invoked per iteration.\n         * @return Returns the new filtered array.\n         */\n        reject(collection: string | null | undefined, predicate?: StringIterator<boolean>): string[];\n        /**\n         * @see _.reject\n         */\n        reject<T>(collection: List<T> | null | undefined, predicate?: ListIterateeCustom<T, boolean>): T[];\n        /**\n         * @see _.reject\n         */\n        reject<T extends object>(collection: T | null | undefined, predicate?: ObjectIterateeCustom<T, boolean>): Array<T[keyof T]>;\n    }\n    interface String {\n        /**\n         * @see _.reject\n         */\n        reject(predicate?: StringIterator<boolean>): Collection<string>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.reject\n         */\n        reject(predicate?: ListIterateeCustom<T, boolean>): Collection<T>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.reject\n         */\n        reject(predicate?: ObjectIterateeCustom<T, boolean>): Collection<T[keyof T]>;\n    }\n    interface StringChain {\n        /**\n         * @see _.reject\n         */\n        reject(predicate?: StringIterator<boolean>): CollectionChain<string>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.reject\n         */\n        reject(predicate?: StringIterator<boolean>): CollectionChain<string>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.reject\n         */\n        reject(predicate?: ListIterateeCustom<T, boolean>): CollectionChain<T>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.reject\n         */\n        reject(predicate?: ObjectIterateeCustom<T, boolean>): CollectionChain<T[keyof T]>;\n    }\n    interface LoDashStatic {\n        /**\n         * Gets a random element from collection.\n         *\n         * @param collection The collection to sample.\n         * @return Returns the random element.\n         */\n        sample<T>(collection: Dictionary<T> | NumericDictionary<T> | null | undefined): T | undefined;\n        /**\n         * @see _.sample\n         */\n        sample<T extends object>(collection: T | null | undefined): T[keyof T] | undefined;\n    }\n    interface String {\n        /**\n         * @see _.sample\n         */\n        sample(): string | undefined;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.sample\n         */\n        sample(): T | undefined;\n    }\n    interface Object<T> {\n        /**\n         * @see _.sample\n         */\n        sample(): T[keyof T] | undefined;\n    }\n    interface StringChain {\n        /**\n         * @see _.sample\n         */\n        sample(): StringNullableChain;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.sample\n         */\n        sample(): StringNullableChain;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.sample\n         */\n        sample(): ExpChain<T | undefined>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.sample\n         */\n        sample(): ExpChain<T[keyof T] | undefined>;\n    }\n    interface LoDashStatic {\n        /**\n         * Gets n random elements at unique keys from collection up to the size of collection.\n         *\n         * @param collection The collection to sample.\n         * @param n The number of elements to sample.\n         * @return Returns the random elements.\n         */\n        sampleSize<T>(collection: Dictionary<T> | NumericDictionary<T> | null | undefined, n?: number): T[];\n        /**\n         * @see _.sampleSize\n         */\n        sampleSize<T extends object>(collection: T | null | undefined, n?: number): Array<T[keyof T]>;\n    }\n    interface String {\n        /**\n         * @see _.sampleSize\n         */\n        sampleSize(n?: number): Collection<string>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.sampleSize\n         */\n        sampleSize(n?: number): Collection<T>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.sampleSize\n         */\n        sampleSize(n?: number): Collection<T[keyof T]>;\n    }\n    interface StringChain {\n        /**\n         * @see _.sampleSize\n         */\n        sampleSize(n?: number): CollectionChain<string>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.sampleSize\n         */\n        sampleSize(n?: number): CollectionChain<string>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.sampleSize\n         */\n        sampleSize(n?: number): CollectionChain<T>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.sampleSize\n         */\n        sampleSize(n?: number): CollectionChain<T[keyof T]>;\n    }\n    interface LoDashStatic {\n        /**\n         * Creates an array of shuffled values, using a version of the Fisher-Yates shuffle.\n         *\n         * @param collection The collection to shuffle.\n         * @return Returns the new shuffled array.\n         */\n        shuffle<T>(collection: List<T> | null | undefined): T[];\n        /**\n         * @see _.shuffle\n         */\n        shuffle<T extends object>(collection: T | null | undefined): Array<T[keyof T]>;\n    }\n    interface String {\n        /**\n         * @see _.shuffle\n         */\n        shuffle(): Collection<string>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.shuffle\n         */\n        shuffle(): Collection<T>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.shuffle\n         */\n        shuffle(): Collection<T[keyof T]>;\n    }\n    interface StringChain {\n        /**\n         * @see _.shuffle\n         */\n        shuffle(): CollectionChain<string>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.shuffle\n         */\n        shuffle(): CollectionChain<string>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.shuffle\n         */\n        shuffle(): CollectionChain<T>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.shuffle\n         */\n        shuffle(): CollectionChain<T[keyof T]>;\n    }\n    interface LoDashStatic {\n        /**\n         * Gets the size of collection by returning its length for array-like values or the number of own enumerable\n         * properties for objects.\n         *\n         * @param collection The collection to inspect.\n         * @return Returns the size of collection.\n         */\n        size(collection: object | string | null | undefined): number;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.size\n         */\n        size(): number;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.size\n         */\n        size(): PrimitiveChain<number>;\n    }\n    interface LoDashStatic {\n        /**\n         * Checks if predicate returns truthy for any element of collection. Iteration is stopped once predicate\n         * returns truthy. The predicate is invoked with three arguments: (value, index|key, collection).\n         *\n         * @param collection The collection to iterate over.\n         * @param predicate The function invoked per iteration.\n         * @return Returns true if any element passes the predicate check, else false.\n         */\n        some<T>(collection: List<T> | null | undefined, predicate?: ListIterateeCustom<T, boolean>): boolean;\n        /**\n         * @see _.some\n         */\n        some<T extends object>(collection: T | null | undefined, predicate?: ObjectIterateeCustom<T, boolean>): boolean;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.some\n         */\n        some(predicate?: ListIterateeCustom<T, boolean>): boolean;\n    }\n    interface Object<T> {\n        /**\n         * @see _.some\n         */\n        some(predicate?: ObjectIterateeCustom<T, boolean>): boolean;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.some\n         */\n        some(predicate?: ListIterateeCustom<T, boolean>): PrimitiveChain<boolean>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.some\n         */\n        some(predicate?: ObjectIterateeCustom<T, boolean>): PrimitiveChain<boolean>;\n    }\n    interface LoDashStatic {\n        /**\n         * Creates an array of elements, sorted in ascending order by the results of\n         * running each element in a collection through each iteratee. This method\n         * performs a stable sort, that is, it preserves the original sort order of\n         * equal elements. The iteratees are invoked with one argument: (value).\n         *\n         * @category Collection\n         * @param collection The collection to iterate over.\n         * @param [iteratees=[_.identity]]\n         *  The iteratees to sort by, specified individually or in arrays.\n         * @returns Returns the new sorted array.\n         * @example\n         *\n         * var users = [\n         *   { 'user': 'fred',   'age': 48 },\n         *   { 'user': 'barney', 'age': 36 },\n         *   { 'user': 'fred',   'age': 42 },\n         *   { 'user': 'barney', 'age': 34 }\n         * ];\n         *\n         * _.sortBy(users, function(o) { return o.user; });\n         * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]\n         *\n         * _.sortBy(users, ['user', 'age']);\n         * // => objects for [['barney', 34], ['barney', 36], ['fred', 42], ['fred', 48]]\n         *\n         * _.sortBy(users, 'user', function(o) {\n         *   return Math.floor(o.age / 10);\n         * });\n         * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]\n         */\n        sortBy<T>(collection: List<T> | null | undefined, ...iteratees: Array<Many<ListIteratee<T>>>): T[];\n        /**\n         * @see _.sortBy\n         */\n        sortBy<T extends object>(collection: T | null | undefined, ...iteratees: Array<Many<ObjectIteratee<T>>>): Array<T[keyof T]>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.sortBy\n         */\n        sortBy(...iteratees: Array<Many<ListIteratee<T>>>): Collection<T>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.sortBy\n         */\n        sortBy(...iteratees: Array<Many<ObjectIteratee<T>>>): Collection<T[keyof T]>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.sortBy\n         */\n        sortBy(...iteratees: Array<Many<ListIteratee<T>>>): CollectionChain<T>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.sortBy\n         */\n        sortBy(...iteratees: Array<Many<ObjectIteratee<T>>>): CollectionChain<T[keyof T]>;\n    }\n}\n\ndeclare module lodash {\n    interface LoDashStatic {\n        /**\n         * Attempts to invoke func, returning either the result or the caught error object. Any additional arguments\n         * are provided to func when it’s invoked.\n         *\n         * @param func The function to attempt.\n         * @return Returns the func result or error object.\n         */\n        attempt<TResult>(func: (...args: any[]) => TResult, ...args: any[]): TResult | Error;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.attempt\n         */\n        attempt<TResult>(...args: any[]): TResult | Error;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.attempt\n         */\n        attempt<TResult>(...args: any[]): ExpChain<TResult | Error>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Binds methods of an object to the object itself, overwriting the existing method. Method names may be\n         * specified as individual arguments or as arrays of method names. If no method names are provided all\n         * enumerable function properties, own and inherited, of object are bound.\n         *\n         * Note: This method does not set the \"length\" property of bound functions.\n         *\n         * @param object The object to bind and assign the bound methods to.\n         * @param methodNames The object method names to bind, specified as individual method names or arrays of\n         * method names.\n         * @return Returns object.\n         */\n        bindAll<T>(object: T, ...methodNames: Array<Many<string>>): T;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.bindAll\n         */\n        bindAll(...methodNames: Array<Many<string>>): this;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.bindAll\n         */\n        bindAll(...methodNames: Array<Many<string>>): this;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a function that iterates over pairs and invokes the corresponding\n         * function of the first predicate to return truthy. The predicate-function\n         * pairs are invoked with the this binding and arguments of the created\n         * function.\n         *\n         * @since 4.0.0\n         * @category Util\n         * @param pairs The predicate-function pairs.\n         * @returns Returns the new composite function.\n         * @example\n         *\n         * var func = _.cond([\n         *   [_.matches({ 'a': 1 }),           _.constant('matches A')],\n         *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],\n         *   [_.stubTrue,                      _.constant('no match')]\n         * ]);\n         *\n         * func({ 'a': 1, 'b': 2 });\n         * // => 'matches A'\n         *\n         * func({ 'a': 0, 'b': 1 });\n         * // => 'matches B'\n         *\n         * func({ 'a': '1', 'b': '2' });\n         * // => 'no match'\n         */\n        cond<R>(pairs: Array<CondPairNullary<R>>): () => R;\n        cond<T, R>(pairs: Array<CondPairUnary<T, R>>): (Target: T) => R;\n    }\n\n    type CondPairNullary<R> = [() => boolean, () => R];\n    type CondPairUnary<T, R> = [(val: T) => boolean, (val: T) => R];\n\n\n    type ConformsPredicateObject<T> = {\n        [P in keyof T]: T[P] extends (arg: infer A) => any ? A : any\n    };\n    interface LoDashStatic {\n        /**\n         * Creates a function that invokes the predicate properties of source with the corresponding\n         * property values of a given object, returning true if all predicates return truthy, else false.\n         */\n        conforms<T>(source: ConformsPredicateObject<T>): (value: T) => boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.conforms\n         */\n        conforms(): Function<(value: ConformsPredicateObject<TValue>) => boolean>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.conforms\n         */\n        conforms(): FunctionChain<(value: ConformsPredicateObject<TValue>) => boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a function that returns value.\n         *\n         * @param value The value to return from the new function.\n         * @return Returns the new function.\n         */\n        constant<T>(value: T): () => T;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.constant\n         */\n        constant(): Function<() => TValue>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.constant\n         */\n        constant(): FunctionChain<() => TValue>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Checks value to determine whether a default value should be returned in\n         * its place. The defaultValue is returned if value is NaN, null,\n         * or undefined.\n         *\n         * @param value The value to check.\n         * @param defaultValue The default value.\n         * @returns Returns the resolved value.\n         */\n        defaultTo<T>(value: T | null | undefined, defaultValue: T): T;\n        /**\n         * @see _.defaultTo\n         */\n        defaultTo<T, TDefault>(value: T | null | undefined, defaultValue: TDefault): T | TDefault;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.defaultTo\n         */\n        defaultTo(defaultValue: TValue): TValue;\n        /**\n         * @see _.defaultTo\n         */\n        defaultTo<TDefault>(defaultValue: TDefault): TValue extends null | undefined ? TDefault : TValue | TDefault;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.defaultTo\n         */\n        defaultTo(defaultValue: TValue): ExpChain<TValue>;\n        /**\n         * @see _.defaultTo\n         */\n        defaultTo<TDefault>(defaultValue: TDefault): ExpChain<TValue extends null | undefined ? TDefault : TValue | TDefault>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a function that returns the result of invoking the provided functions with the this binding of the\n         * created function, where each successive invocation is supplied the return value of the previous.\n         *\n         * @param funcs Functions to invoke.\n         * @return Returns the new function.\n         */\n        flow<A extends any[], R1, R2, R3, R4, R5, R6, R7>(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;\n        /**\n         * @see _.flow\n         */\n        flow<A extends any[], R1, R2, R3, R4, R5, R6, R7>(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<Many<(a: any) => any>>): (...args: A) => any;\n        /**\n         * @see _.flow\n         */\n        flow<A extends any[], R1, R2, R3, R4, R5, R6>(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;\n        /**\n         * @see _.flow\n         */\n        flow<A extends any[], R1, R2, R3, R4, R5>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5;\n        /**\n         * @see _.flow\n         */\n        flow<A extends any[], R1, R2, R3, R4>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4;\n        /**\n         * @see _.flow\n         */\n        flow<A extends any[], R1, R2, R3>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3;\n        /**\n         * @see _.flow\n         */\n        flow<A extends any[], R1, R2>(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2;\n        /**\n         * @see _.flow\n         */\n        flow(...func: Array<Many<(...args: any[]) => any>>): (...args: any[]) => any;\n    }\n    interface Function<T extends (...arg: any) => any> {\n        /**\n         * @see _.flow\n         */\n        flow<R2, R3, R4, R5, R6, R7>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): Function<(...args: Parameters<T>) => R7>;\n        /**\n         * @see _.flow\n         */\n        flow<R2, R3, R4, R5, R6, R7>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array<Many<(a: any) => any>>): Function<(...args: Parameters<T>) => any>;\n        /**\n         * @see _.flow\n         */\n        flow<R2, R3, R4, R5, R6>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): Function<(...args: Parameters<T>) => R6>;\n        /**\n         * @see _.flow\n         */\n        flow<R2, R3, R4, R5>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): Function<(...args: Parameters<T>) => R5>;\n        /**\n         * @see _.flow\n         */\n        flow<R2, R3, R4>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): Function<(...args: Parameters<T>) => R4>;\n        /**\n         * @see _.flow\n         */\n        flow<R2, R3>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3): Function<(...args: Parameters<T>) => R3>;\n        /**\n         * @see _.flow\n         */\n        flow<R2>(f2: (a: ReturnType<T>) => R2): Function<(...args: Parameters<T>) => R2>;\n        /**\n         * @see _.flow\n         */\n        flow(...func: Array<Many<(...args: any[]) => any>>): Function<(...args: any[]) => any>;\n    }\n    interface FunctionChain<T> {\n        /**\n         * @see _.flow\n         */\n        flow<R2, R3, R4, R5, R6, R7>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): FunctionChain<(...args: Parameters<T>) => R7>;\n        /**\n         * @see _.flow\n         */\n        flow<R2, R3, R4, R5, R6, R7>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array<Many<(a: any) => any>>): FunctionChain<(...args: Parameters<T>) => any>;\n        /**\n         * @see _.flow\n         */\n        flow<R2, R3, R4, R5, R6>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): FunctionChain<(...args: Parameters<T>) => R6>;\n        /**\n         * @see _.flow\n         */\n        flow<R2, R3, R4, R5>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): FunctionChain<(...args: Parameters<T>) => R5>;\n        /**\n         * @see _.flow\n         */\n        flow<R2, R3, R4>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): FunctionChain<(...args: Parameters<T>) => R4>;\n        /**\n         * @see _.flow\n         */\n        flow<R2, R3>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3): FunctionChain<(...args: Parameters<T>) => R3>;\n        /**\n         * @see _.flow\n         */\n        flow<R2>(f2: (a: ReturnType<T>) => R2): FunctionChain<(...args: Parameters<T>) => R2>;\n        /**\n         * @see _.flow\n         */\n        flow(...func: Array<Many<(...args: any[]) => any>>): FunctionChain<(...args: any[]) => any>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * This method is like _.flow except that it creates a function that invokes the provided functions from right\n         * to left.\n         *\n         * @param funcs Functions to invoke.\n         * @return Returns the new function.\n         */\n        flowRight<A extends any[], R1, R2, R3, R4, R5, R6, R7>(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;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2, R3, R4, R5, R6>(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;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2, R3, R4, R5>(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R5;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2, R3, R4>(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R4;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2, R3>(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R3;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2>(f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R2;\n        /**\n         * @see _.flowRight\n         */\n        flowRight(...func: Array<Many<(...args: any[]) => any>>): (...args: any[]) => any;\n    }\n    interface Function<T> {\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2, R3, R4, R5>(f6: (a: R5) => Parameters<T>[\"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<T>>;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2, R3, R4>(f5: (a: R4) => Parameters<T>[\"0\"], f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): Function<(...args: A) => ReturnType<T>>;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2, R3>(f4: (a: R3) => Parameters<T>[\"0\"], f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): Function<(...args: A) => ReturnType<T>>;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2>(f3: (a: R2) => Parameters<T>[\"0\"], f2: (a: R1) => R2, f1: (...args: A) => R1): Function<(...args: A) => ReturnType<T>>;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1>(f2: (a: R1) => Parameters<T>[\"0\"], f1: (...args: A) => R1): Function<(...args: A) => ReturnType<T>>;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[]>(f1: (...args: A) => Parameters<T>[\"0\"]): Function<(...args: A) => ReturnType<T>>;\n        /**\n         * @see _.flowRight\n         */\n        flowRight(...func: Array<Many<(...args: any[]) => any>>): Function<(...args: any[]) => any>;\n    }\n    interface FunctionChain<T> {\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2, R3, R4, R5>(f6: (a: R5) => Parameters<T>[\"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<T>>;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2, R3, R4>(f5: (a: R4) => Parameters<T>[\"0\"], f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType<T>>;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2, R3>(f4: (a: R3) => Parameters<T>[\"0\"], f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType<T>>;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1, R2>(f3: (a: R2) => Parameters<T>[\"0\"], f2: (a: R1) => R2, f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType<T>>;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[], R1>(f2: (a: R1) => Parameters<T>[\"0\"], f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType<T>>;\n        /**\n         * @see _.flowRight\n         */\n        flowRight<A extends any[]>(f1: (...args: A) => Parameters<T>[\"0\"]): FunctionChain<(...args: A) => ReturnType<T>>;\n        /**\n         * @see _.flowRight\n         */\n        flowRight(...func: Array<Many<(...args: any[]) => any>>): FunctionChain<(...args: any[]) => any>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * This method returns the first argument provided to it.\n         *\n         * @param value Any value.\n         * @return Returns value.\n         */\n        identity<T>(value: T): T;\n        /**\n         * @see _.identity\n         */\n        identity(): undefined;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.identity\n         */\n        identity(): TValue;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.identity\n         */\n        identity(): this;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a function that invokes func with the arguments of the created\n         * function. If func is a property name the created callback returns the\n         * property value for a given element. If func is an object the created\n         * callback returns true for elements that contain the equivalent object properties, otherwise it returns false.\n         *\n         * @category Util\n         * @param [func=_.identity] The value to convert to a callback.\n         * @returns Returns the callback.\n         * @example\n         *\n         * var users = [\n         *   { 'user': 'barney', 'age': 36 },\n         *   { 'user': 'fred',   'age': 40 }\n         * ];\n         *\n         * // create custom iteratee shorthands\n         * _.iteratee = _.wrap(_.iteratee, function(callback, func) {\n         *   var p = /^(S+)s*([<>])s*(S+)$/.exec(func);\n         *   return !p ? callback(func) : function(object) {\n         *     return (p[2] == '>' ? object[p[1]] > p[3] : object[p[1]] < p[3]);\n         *   };\n         * });\n         *\n         * _.filter(users, 'age > 36');\n         * // => [{ 'user': 'fred', 'age': 40 }]\n         */\n        iteratee<TFunction extends (...args: any[]) => any>(func: TFunction): TFunction;\n        /**\n         * @see _.iteratee\n         */\n        iteratee(func: symbol | number | string | object): (...args: any[]) => any;\n    }\n    interface Function<T extends (...args: any) => any> {\n        /**\n         * @see _.iteratee\n         */\n        iteratee(): Function<T>;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.iteratee\n         */\n        iteratee(): Function<(o: object) => boolean>;\n    }\n    interface Object<T> {\n        /**\n         * @see _.iteratee\n         */\n        iteratee(): Function<(o: T) => boolean>;\n    }\n    interface String {\n        /**\n         * @see _.iteratee\n         */\n        iteratee(): Function<(o: object) => any>;\n    }\n    interface FunctionChain<T extends (...args: any) => any> {\n        /**\n         * @see _.iteratee\n         */\n        iteratee(): FunctionChain<T>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.iteratee\n         */\n        iteratee(): FunctionChain<(o: object) => boolean>;\n    }\n    interface ObjectChain<T> {\n        /**\n         * @see _.iteratee\n         */\n        iteratee(): FunctionChain<(o: T) => boolean>;\n    }\n    interface StringChain {\n        /**\n         * @see _.iteratee\n         */\n        iteratee(): FunctionChain<(o: object) => any>;\n    }\n    interface StringNullableChain {\n        /**\n         * @see _.iteratee\n         */\n        iteratee(): FunctionChain<(o: object) => any>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a function that performs a deep comparison between a given object and source, returning true if the\n         * given object has equivalent property values, else false.\n         *\n         * Note: This method supports comparing arrays, booleans, Date objects, numbers, Object objects, regexes, and\n         * strings. Objects are compared by their own, not inherited, enumerable properties. For comparing a single own\n         * or inherited property value see _.matchesProperty.\n         *\n         * @param source The object of property values to match.\n         * @return Returns the new function.\n         */\n        matches<T>(source: T): (value: any) => boolean;\n        /**\n         * @see _.matches\n         */\n        matches<T, V>(source: T): (value: V) => boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.matches\n         */\n        matches<V>(): Function<(value: V) => boolean>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.matches\n         */\n        matches<V>(): FunctionChain<(value: V) => boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a function that compares the property value of path on a given object to value.\n         *\n         * Note: This method supports comparing arrays, booleans, Date objects, numbers, Object objects, regexes, and\n         * strings. Objects are compared by their own, not inherited, enumerable properties.\n         *\n         * @param path The path of the property to get.\n         * @param srcValue The value to match.\n         * @return Returns the new function.\n         */\n        matchesProperty<T>(path: PropertyPath, srcValue: T): (value: any) => boolean;\n        /**\n         * @see _.matchesProperty\n         */\n        matchesProperty<T, V>(path: PropertyPath, srcValue: T): (value: V) => boolean;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.matchesProperty\n         */\n        matchesProperty<SrcValue>(srcValue: SrcValue): Function<(value: any) => boolean>;\n        /**\n         * @see _.matchesProperty\n         */\n        matchesProperty<SrcValue, Value>(srcValue: SrcValue): Function<(value: Value) => boolean>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.matchesProperty\n         */\n        matchesProperty<SrcValue>(srcValue: SrcValue): FunctionChain<(value: any) => boolean>;\n        /**\n         * @see _.matchesProperty\n         */\n        matchesProperty<SrcValue, Value>(srcValue: SrcValue): FunctionChain<(value: Value) => boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a function that invokes the method at path on a given object. Any additional arguments are provided\n         * to the invoked method.\n         *\n         * @param path The path of the method to invoke.\n         * @param args The arguments to invoke the method with.\n         * @return Returns the new function.\n         */\n        method(path: PropertyPath, ...args: any[]): (object: any) => any;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.method\n         */\n        method(...args: any[]): Function<(object: any) => any>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.method\n         */\n        method(...args: any[]): FunctionChain<(object: any) => any>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * The opposite of _.method; this method creates a function that invokes the method at a given path on object.\n         * Any additional arguments are provided to the invoked method.\n         *\n         * @param object The object to query.\n         * @param args The arguments to invoke the method with.\n         * @return Returns the new function.\n         */\n        methodOf(object: object, ...args: any[]): (path: PropertyPath) => any;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.methodOf\n         */\n        methodOf(...args: any[]): LoDashImplicitWrapper<(path: PropertyPath) => any>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.methodOf\n         */\n        methodOf(...args: any[]): LoDashExplicitWrapper<(path: PropertyPath) => any>;\n    }\n\n    interface MixinOptions {\n        /**\n         * @see _.chain\n         */\n        chain?: boolean | undefined;\n    }\n    interface LoDashStatic {\n        /**\n         * Adds all own enumerable function properties of a source object to the destination object. If object is a\n         * function then methods are added to its prototype as well.\n         *\n         * Note: Use _.runInContext to create a pristine lodash function to avoid conflicts caused by modifying\n         * the original.\n         *\n         * @param object The destination object.\n         * @param source The object of functions to add.\n         * @param options The options object.\n         * @param options.chain Specify whether the functions added are chainable.\n         * @return Returns object.\n         */\n        mixin<TObject>(object: TObject, source: Dictionary<(...args: any[]) => any>, options?: MixinOptions): TObject;\n        /**\n         * @see _.mixin\n         */\n        mixin<TResult>(source: Dictionary<(...args: any[]) => any>, options?: MixinOptions): LoDashStatic;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.mixin\n         */\n        mixin(source: Dictionary<(...args: any[]) => any>, options?: MixinOptions): this;\n        /**\n         * @see _.mixin\n         */\n        mixin(options?: MixinOptions): LoDashImplicitWrapper<LoDashStatic>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.mixin\n         */\n        mixin(source: Dictionary<(...args: any[]) => any>, options?: MixinOptions): this;\n        /**\n         * @see _.mixin\n         */\n        mixin(options?: MixinOptions): LoDashExplicitWrapper<LoDashStatic>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Reverts the _ variable to its previous value and returns a reference to the lodash function.\n         *\n         * @return Returns the lodash function.\n         */\n        noConflict(): typeof _;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.noConflict\n         */\n        noConflict(): typeof _;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.noConflict\n         */\n        noConflict(): LoDashExplicitWrapper<typeof _>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * A no-operation function that returns undefined regardless of the arguments it receives.\n         *\n         * @return undefined\n         */\n        noop(...args: any[]): void;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.noop\n         */\n        noop(...args: any[]): void;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.noop\n         */\n        noop(...args: any[]): PrimitiveChain<undefined>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a function that returns its nth argument.\n         *\n         * @param n The index of the argument to return.\n         * @return Returns the new function.\n         */\n        nthArg(n?: number): (...args: any[]) => any;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.nthArg\n         */\n        nthArg(): Function<(...args: any[]) => any>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.nthArg\n         */\n        nthArg(): FunctionChain<(...args: any[]) => any>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a function that invokes iteratees with the arguments provided to the created function and returns\n         * their results.\n         *\n         * @param iteratees The iteratees to invoke.\n         * @return Returns the new function.\n         */\n        over<TResult>(...iteratees: Array<Many<(...args: any[]) => TResult>>): (...args: any[]) => TResult[];\n    }\n    interface Collection<T> {\n        /**\n         * @see _.over\n         */\n        over<TResult>(...iteratees: Array<Many<(...args: any[]) => TResult>>): Function<(...args: any[]) => TResult[]>;\n    }\n    interface Function<T> {\n        /**\n         * @see _.over\n         */\n        over<TResult>(...iteratees: Array<Many<(...args: any[]) => TResult>>): Function<(...args: any[]) => Array<ReturnType<T> | TResult>>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.over\n         */\n        over<TResult>(...iteratees: Array<Many<(...args: any[]) => TResult>>): FunctionChain<(...args: any[]) => TResult[]>;\n    }\n    interface FunctionChain<T> {\n        /**\n         * @see _.over\n         */\n        over<TResult>(...iteratees: Array<Many<(...args: any[]) => TResult>>): FunctionChain<(...args: any[]) => Array<ReturnType<T> | TResult>>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a function that checks if all of the predicates return truthy when invoked with the arguments\n         * provided to the created function.\n         *\n         * @param predicates The predicates to check.\n         * @return Returns the new function.\n         */\n        overEvery<T, Result1 extends T, Result2 extends T>(...predicates: [\n            (arg: T) => arg is Result1,\n            (arg: T) => arg is Result2\n        ]): (arg: T) => arg is Result1 & Result2;\n        overEvery<T>(...predicates: Array<Many<(...args: T[]) => boolean>>): (...args: T[]) => boolean;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.overEvery\n         */\n        overEvery<TArgs>(...iteratees: Array<Many<(...args: TArgs[]) => boolean>>): Function<(...args: TArgs[]) => boolean>;\n    }\n    interface Function<T> {\n        /**\n         * @see _.overEvery\n         */\n        overEvery<TArgs>(...iteratees: Array<Many<(...args: TArgs[]) => boolean>>): Function<(...args: Parameters<T> | TArgs[]) => boolean>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.overEvery\n         */\n        overEvery<TArgs>(...iteratees: Array<Many<(...args: TArgs[]) => boolean>>): FunctionChain<(...args:  TArgs[]) => boolean>;\n    }\n    interface FunctionChain<T> {\n        /**\n         * @see _.overEvery\n         */\n        overEvery<TArgs>(...iteratees: Array<Many<(...args: TArgs[]) => boolean>>): FunctionChain<(...args: Parameters<T> | TArgs[]) => boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a function that checks if any of the predicates return truthy when invoked with the arguments\n         * provided to the created function.\n         *\n         * @param predicates The predicates to check.\n         * @return Returns the new function.\n         */\n        overSome<T, Result1 extends T, Result2 extends T>(...predicates: [\n            (arg: T) => arg is Result1,\n            (arg: T) => arg is Result2\n        ]): (arg: T) => arg is Result1 | Result2;\n        overSome<T>(...predicates: Array<Many<(...args: T[]) => boolean>>): (...args: T[]) => boolean;\n    }\n    interface Collection<T> {\n        /**\n         * @see _.overSome\n         */\n        overSome<TArgs>(...iteratees: Array<Many<(...args: TArgs[]) => boolean>>): Function<(...args: TArgs[]) => boolean>;\n    }\n    interface Function<T> {\n        /**\n         * @see _.overSome\n         */\n        overSome<TArgs>(...iteratees: Array<Many<(...args: TArgs[]) => boolean>>): Function<(...args: Parameters<T> | TArgs[]) => boolean>;\n    }\n    interface CollectionChain<T> {\n        /**\n         * @see _.overSome\n         */\n        overSome<TArgs>(...iteratees: Array<Many<(...args: TArgs[]) => boolean>>): FunctionChain<(...args: TArgs[]) => boolean>;\n    }\n    interface FunctionChain<T> {\n        /**\n         * @see _.overSome\n         */\n        overSome<TArgs>(...iteratees: Array<Many<(...args: TArgs[]) => boolean>>): FunctionChain<(...args: Parameters<T> | TArgs[]) => boolean>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates a function that returns the property value at path on a given object.\n         *\n         * @param path The path of the property to get.\n         * @return Returns the new function.\n         */\n        property<TObj, TResult>(path: PropertyPath): (obj: TObj) => TResult;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.property\n         */\n        property<TObj, TResult>(): Function<(obj: TObj) => TResult>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.property\n         */\n        property<TObj, TResult>(): FunctionChain<(obj: TObj) => TResult>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * The opposite of _.property; this method creates a function that returns the property value at a given path\n         * on object.\n         *\n         * @param object The object to query.\n         * @return Returns the new function.\n         */\n        propertyOf<T extends {}>(object: T): (path: PropertyPath) => any;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.propertyOf\n         */\n        propertyOf(): LoDashImplicitWrapper<(path: PropertyPath) => any>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.propertyOf\n         */\n        propertyOf(): LoDashExplicitWrapper<(path: PropertyPath) => any>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end.\n         * 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\n         * range is created unless a negative step is specified.\n         *\n         * @param start The start of the range.\n         * @param end The end of the range.\n         * @param step The value to increment or decrement by.\n         * @return Returns a new range array.\n         */\n        range(start: number, end?: number, step?: number): number[];\n        /**\n         * @see _.range\n         */\n        range(end: number, index: string | number, guard: object): number[];\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.range\n         */\n        range(end?: number, step?: number): Collection<number>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.range\n         */\n        range(end?: number, step?: number): CollectionChain<number>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * This method is like _.range except that it populates values in\n         * descending order.\n         *\n         * @category Util\n         * @param start The start of the range.\n         * @param end The end of the range.\n         * @param step The value to increment or decrement by.\n         * @returns Returns the new array of numbers.\n         * @example\n         *\n         * _.rangeRight(4);\n         * // => [3, 2, 1, 0]\n         *\n         * _.rangeRight(-4);\n         * // => [-3, -2, -1, 0]\n         *\n         * _.rangeRight(1, 5);\n         * // => [4, 3, 2, 1]\n         *\n         * _.rangeRight(0, 20, 5);\n         * // => [15, 10, 5, 0]\n         *\n         * _.rangeRight(0, -4, -1);\n         * // => [-3, -2, -1, 0]\n         *\n         * _.rangeRight(1, 4, 0);\n         * // => [1, 1, 1]\n         *\n         * _.rangeRight(0);\n         * // => []\n         */\n        rangeRight(start: number, end?: number, step?: number): number[];\n        /**\n         * @see _.rangeRight\n         */\n        rangeRight(end: number, index: string | number, guard: object): number[];\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.rangeRight\n         */\n        rangeRight(end?: number, step?: number): Collection<number>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.rangeRight\n         */\n        rangeRight(end?: number, step?: number): CollectionChain<number>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Create a new pristine lodash function using the given context object.\n         *\n         * @param context The context object.\n         * @return Returns a new lodash function.\n         */\n        runInContext(context?: object): LoDashStatic;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.runInContext\n         */\n        runInContext(): LoDashStatic;\n    }\n\n    interface LoDashStatic {\n        /**\n         * This method returns a new empty array.\n         *\n         * @returns Returns the new empty array.\n         */\n        stubArray(): any[];\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.stubArray\n         */\n        stubArray(): any[];\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.stubArray\n         */\n        stubArray(): CollectionChain<any>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * This method returns false.\n         *\n         * @returns Returns false.\n         */\n        stubFalse(): false;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.stubFalse\n         */\n        stubFalse(): false;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.stubFalse\n         */\n        stubFalse(): PrimitiveChain<false>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * This method returns a new empty object.\n         *\n         * @returns Returns the new empty object.\n         */\n        stubObject(): any;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.stubObject\n         */\n        stubObject(): any;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.stubObject\n         */\n        stubObject(): LoDashExplicitWrapper<any>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * This method returns an empty string.\n         *\n         * @returns Returns the empty string.\n         */\n        stubString(): string;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.stubString\n         */\n        stubString(): string;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.stubString\n         */\n        stubString(): StringChain;\n    }\n\n    interface LoDashStatic {\n        /**\n         * This method returns true.\n         *\n         * @returns Returns true.\n         */\n        stubTrue(): true;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.stubTrue\n         */\n        stubTrue(): true;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.stubTrue\n         */\n        stubTrue(): PrimitiveChain<true>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Invokes the iteratee function n times, returning an array of the results of each invocation. The iteratee\n         * is invoked with one argument; (index).\n         *\n         * @param n The number of times to invoke iteratee.\n         * @param iteratee The function invoked per iteration.\n         * @return Returns the array of results.\n         */\n        times<TResult>(n: number, iteratee: (num: number) => TResult): TResult[];\n        /**\n         * @see _.times\n         */\n        times(n: number): number[];\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.times\n         */\n        times<TResult>(iteratee: (num: number) => TResult): TResult[];\n        /**\n         * @see _.times\n         */\n        times(): number[];\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.times\n         */\n        times<TResult>(iteratee: (num: number) => TResult): CollectionChain<TResult>;\n        /**\n         * @see _.times\n         */\n        times(): CollectionChain<number>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Converts value to a property path array.\n         *\n         * @category Util\n         * @param value The value to convert.\n         * @returns Returns the new property path array.\n         * @example\n         *\n         * _.toPath('a.b.c');\n         * // => ['a', 'b', 'c']\n         *\n         * _.toPath('a[0].b.c');\n         * // => ['a', '0', 'b', 'c']\n         *\n         * var path = ['a', 'b', 'c'],\n         *     newPath = _.toPath(path);\n         *\n         * console.log(newPath);\n         * // => ['a', 'b', 'c']\n         *\n         * console.log(path === newPath);\n         * // => false\n         */\n        toPath(value: any): string[];\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.toPath\n         */\n        toPath(): Collection<string>;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.toPath\n         */\n        toPath(): CollectionChain<string>;\n    }\n\n    interface LoDashStatic {\n        /**\n         * Generates a unique ID. If prefix is provided the ID is appended to it.\n         *\n         * @param prefix The value to prefix the ID with.\n         * @return Returns the unique ID.\n         */\n        uniqueId(prefix?: string): string;\n    }\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.uniqueId\n         */\n        uniqueId(): string;\n    }\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.uniqueId\n         */\n        uniqueId(): StringChain;\n    }\n\n    // stubTrue\n\n    interface LoDashStatic {\n        /**\n         * This method returns true.\n         *\n         * @return Returns true.\n         */\n        stubTrue(): true;\n    }\n\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.stubTrue\n         */\n        stubTrue(): true;\n    }\n\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.stubTrue\n         */\n        stubTrue(): LoDashExplicitWrapper<true>;\n    }\n\n    // stubFalse\n\n    interface LoDashStatic {\n        /**\n         * This method returns false.\n         *\n         * @return Returns false.\n         */\n        stubFalse(): false;\n    }\n\n    interface LoDashImplicitWrapper<TValue> {\n        /**\n         * @see _.stubFalse\n         */\n        stubFalse(): false;\n    }\n\n    interface LoDashExplicitWrapper<TValue> {\n        /**\n         * @see _.stubFalse\n         */\n        stubFalse(): LoDashExplicitWrapper<false>;\n    }\n}\n\n\ndeclare const _: lodash.LoDashStatic;\ndeclare namespace _ {\n    // tslint:disable-next-line no-empty-interface (This will be augmented)\n    interface LoDashStatic {}\n}\n";
export default _default;