/// import * as lang from './lang'; import { chunk, compact, concat, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, fill, findIndex, findLastIndex, first, flatten, flattenDeep, flattenDepth, fromPairs, head, indexOf, initial, intersection, intersectionBy, intersectionWith, join, last, lastIndexOf, nth, pull, pullAll, pullAllBy, pullAllWith, pullAt, remove, reverse, slice, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, tail, take, takeRight, takeRightWhile, takeWhile, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unshift, unzip, unzipWith, without, xor, xorBy, xorWith, zip, zipObject, zipWith } from './array'; import { countBy, each, eachRight, every, filter, find, findLast, flatMap, flatMapDeep, flatMapDepth, forEach, forEachRight, freeze, groupBy, includes, invokeMap, keyBy, map, orderBy, partition, preventExtensions, reduce, reduceRight, reject, sample, sampleSize, seal, shuffle, size, some, sortBy } from './collection'; import { now } from './date'; import { after, ary, before, bind, bindKey, curry, curryRight, debounce, delay, flip, negate, once, overArgs, partial, partialRight, rearg, rest, spread, unary, wrap } from './function'; import { add, ceil, divide, floor, max, maxBy, mean, meanBy, min, minBy, multiply, round, subtract, sum, sumBy } from './math'; import { clamp, inRange, random } from './number'; import { assign, assignIn, assignInWith, assignWith, at, create, defaults, entries, extend, extendWith, findKey, findLastKey, forIn, forInRight, forOwn, forOwnRight, functions, functionsIn, get, has, hasIn, invert, invertBy, keys, keysIn, mapKeys, mapValues, merge, omit, omitBy, pick, pickBy, set, setWith, toPairs, toPairsIn, transform, unset, update, updateWith, values, valuesIn } from './object'; import { castArray, clone, cloneDeep, cloneWith, conformsTo, eq, gt, gte, isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isElement, isEmpty, isEqual, isEqualWith, isError, isExtensible, isFinite, isFrozen, isFunction, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isRegExp, isSafeInteger, isSealed, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, lt, lte, toPlainObject, toNumber, toSafeInteger, toString } from './lang'; import { chain2, tap2, thru } from './seq'; import { camelCase, capitalize, endsWith, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, padEnd, padStart, parseInt, repeat, replace, snakeCase, split, startCase, startsWith, toLower, toUpper, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words } from './string'; import { attempt, cond, conforms, constant, defaultTo, flow, flowRight, identity, iteratee, method, methodOf, noop, nthArg, over, overEvery, overSome, property, propertyOf, range, rangeRight, sleep, stubArray, stubFalse, stubObject, stubString, stubTrue, times, toPath, uniqueId, uniqueId2 } from './util'; declare const _: { attempt: (func: Function, ...args: any) => any; cond: (pairs: any[]) => (...item: any[]) => any; conforms: (object: Object) => any; constant: (arg: T) => any; defaultTo: (value: any, defaultValue: any) => any; flow: (funcs: Function | Function[]) => Function; flowRight: (funcs: Function | Function[]) => Function; identity: (value: T_1) => T_1; iteratee: (predicate?: import("./helpers/predicateType").default) => any; method: (path: string | any[], ...args: any) => any; methodOf: (object: any, ...args: any) => any; noop: () => void; nthArg: (idx?: number) => Function; over: (array: any[]) => Function; overEvery: (predicates?: any[]) => Function; overSome: (predicates?: any[]) => Function; property: (path: string | any[]) => Function; propertyOf: (obj: any) => Function; range: (start?: number, end?: number | undefined, step?: number | undefined) => number[]; rangeRight: (start?: number, end?: number | undefined, step?: number | undefined) => any[]; sleep: (miliseconds?: number) => Promise; stubArray: () => never[]; stubFalse: () => boolean; stubObject: () => {}; stubString: () => string; stubTrue: () => boolean; times: (n: number, func?: Function) => any[]; toPath: (path: any) => any[]; uniqueId: (str?: string) => string; uniqueId2: () => any; castArray: (input: T_3) => T_3 | T_3[]; clone: (value: T_4) => T_4; cloneDeep: (value: T_5) => T_5; cloneWith: typeof lang.cloneWith; conformsTo: (object: any, source: any) => boolean; eq: (value: any, other: any) => boolean; gt: (value: any, other: any) => boolean; gte: (value: any, other: any) => boolean; isArguments: (value: any) => Boolean; isArray: (value: any) => boolean; isArrayBuffer: (value: any) => boolean; isArrayLike: (value: any) => boolean; isArrayLikeObject: (value: any) => boolean; isBoolean: (value: any) => boolean; isBuffer: (value: any) => boolean; isDate: (value: any) => boolean; isElement: (value: any) => boolean; isEmpty: (value: any) => boolean; isEqual: (value: any, other: any) => boolean; isEqualWith: (value: any, other: any, customizer: Function) => boolean; isError: (value: any) => boolean; isExtensible: (collection: Object | any[]) => boolean; isFinite: (value: any) => boolean; isFrozen: (collection: Object | any[]) => boolean; isFunction: (value: any) => boolean; isInteger: (value: any) => boolean; isLength: (value: any) => boolean; isMap: (value: any) => boolean; isMatch: (object: Object, source: Object) => boolean; isMatchWith: (object: Object, source: Object, customizer: Function) => boolean; isNaN: (value: any) => boolean; isNative: (value: any) => boolean; isNil: (value: any) => boolean; isNull: (value: any) => boolean; isNumber: (value: any) => boolean; isObject: (value: any) => boolean; isObjectLike: (value: any) => boolean; isPlainObject: (value: any) => boolean; isRegExp: (value: any) => boolean; isSafeInteger: (value: any) => boolean; isSealed: (collection: Object | any[]) => boolean; isSet: (value: any) => boolean; isString: (value: any) => boolean; isSymbol: (value: any) => boolean; isTypedArray: (value: any) => boolean; isUndefined: (value: any) => boolean; isWeakMap: (value: any) => boolean; isWeakSet: (value: any) => boolean; lt: (value: any, other: any) => boolean; lte: (value: any, other: any) => boolean; toNumber: (value: any) => number; toPlainObject: (value: any) => object; toSafeInteger: (value: any) => number; toString: (value: any) => string; camelCase: (str?: string) => string; capitalize: (str: string) => string; endsWith: (str: string, target: string, position?: number) => boolean; escape: (str: string) => string; escapeRegExp: (str: string) => string; kebabCase: (str?: string) => string; lowerCase: (str?: string) => string; lowerFirst: (str?: string) => string; pad: (str: string, length: number, characters?: string) => string; padEnd: (str?: string, length?: number, chars?: string) => string; padStart: (str?: string, length?: number, chars?: string) => string; parseInt: (str?: string, radix?: number) => number; repeat: (str?: string, n?: number) => string; replace: (str: string | undefined, pattern: string | RegExp, replacement: string | RegExp) => string; snakeCase: (str?: string) => string; split: (str: string | undefined, separator: string | RegExp, limit: number) => string[]; startCase: (str?: string) => string; startsWith: (str?: string, target?: string, position?: number) => boolean; toLower: (str?: string) => string; toUpper: (str?: string) => string; trim: (str?: string, characters?: string) => string; trimEnd: (str?: string, characters?: string) => string; trimStart: (str?: string, characters?: string) => string; unescape: (str: string) => string; upperCase: (str?: string) => string; upperFirst: (str?: string) => string; words: (str?: string, pattern?: string | RegExp) => any; chain2: (value: any) => { fn(func: Function, ...args: any): any; value: () => any; }; tap2: (value: any, interceptor: Function) => { fn(func: Function, ...args: any): any; value: () => any; }; thru: (value: any, fn: Function) => any; assign: (object: T_6, ...sources: any[]) => T_6; assignIn: (object: T_7, ...sources: any[]) => T_7; assignInWith: (object: T_8, ...args: any) => T_8; assignWith: (object: T_9, ...args: any) => T_9; at: (object: T_10, paths: any[]) => any[]; create: (prototype: T_11, properties?: T_11 | null) => T_11; defaults: (...args: any) => object; entries: (object: object) => [string, any][]; extend: (object: T_7, ...sources: any[]) => T_7; extendWith: (object: T_8, ...args: any) => T_8; findKey: (object: T_12, predicate?: import("./helpers/predicateType").default) => any; findLastKey: (object: T_13, predicate?: import("./helpers/predicateType").default) => any; forIn: (object: Object, iteratee?: Function) => Object; forInRight: (object: T_14, iteratee?: Function) => T_14; forOwn: (object: Object, iteratee?: Function) => Object; forOwnRight: (object: T_15, iteratee?: Function) => T_15; functions: (object: Object) => any[]; functionsIn: (object: Object) => any[]; get: (object: any, path: any, defaultValue?: any) => any; has: (object: T_16, path: any) => boolean; hasIn: (object: T_17, path: any) => boolean; invert: (object: Object) => Object; invertBy: (object: Object, iteratee?: import("./helpers/predicateType").default) => Object; keys: (object: any) => any[]; keysIn: (object: any) => any[]; mapKeys: (object: any, iteratee?: import("./helpers/predicateType").default) => Object; mapValues: (object: any, iteratee?: import("./helpers/predicateType").default) => Object; merge: (object: T_21, ...sources: any) => T_21; omit: (object: Object, paths: any[]) => Object; omitBy: (object: Object, predicate?: import("./helpers/predicateType").default) => any; pick: (object: Object, paths: string | string[]) => Object; pickBy: (object: Object, predicate?: import("./helpers/predicateType").default) => Object; set: (object: T_24, path: string | any[], value: any) => T_24; setWith: (object: T_25, path: string | any[], value: any, customizer: Function) => T_25; toPairs: (object: object) => [string, any][]; toPairsIn: (object: object) => [string, any][]; transform: (collection: Record | T_26[], iteratee?: Function, accumulator?: U | undefined) => U; unset: (object: T_27, path: any) => boolean; update: (object: T_28, path: any, updater: Function) => Object; updateWith: (object: T_29, path: any, updater: Function, customizer?: any) => Object; values: (object: Object) => any[]; valuesIn: (object: Object) => any[]; clamp: (number: number, lower: number, upper: number) => number; inRange: (number: number, start?: number, end?: number | undefined) => boolean; random: (lower?: number, upper?: number | boolean | undefined) => number; add: (augend: string | number, addend: string | number, ...args: (string | number)[]) => string | number; ceil: (value: number, precision?: number) => number; divide: (dividend: string | number, divisor: string | number) => number; floor: (value: number, precision?: number) => number; max: (collection: number[]) => number | undefined; maxBy: (collection: T_30[], iteratee: import("./helpers/predicateType").default) => {}; mean: (collection: number[]) => number; meanBy: (collection: T_31[], iteratee: import("./helpers/predicateType").default) => number; min: (collection: number[]) => number | undefined; minBy: (collection: T_32, iteratee: import("./helpers/predicateType").default) => T_32; multiply: (...numbers: number[]) => number; round: (value: number, precision?: number) => number; subtract: (...numbers: number[]) => number; sum: (numbers: number[]) => number; sumBy: (numbers: T_33[], iteratee: import("./helpers/predicateType").default) => number; after: (times: number, fn: Function) => any; ary: (fn: Function, arity?: number) => (...args: any) => any; before: (times: number, fn: Function) => Function; bind: (fn: Function, ctx: any, ...boundArgs: any) => any; bindKey: (object: any, method: any, ...args: any) => (...bound: any) => any; curry: (func: Function) => (...args: any) => any; curryRight: (func: Function) => Function; debounce: (func: Function, delay: number, { leading }?: any) => (...args: any) => void; delay: (fn: Function, timer: number, ...args: any) => NodeJS.Timeout; flip: (func: Function) => (...args: any) => any; negate: (func: Function) => (...args: any) => boolean; once: (fn: Function) => Function; overArgs: (fn: Function, transforms: any) => Function; partial: (func: Function, ...args: any) => (...furtherArgs: any) => any; partialRight: (func: Function, ...cachedArgs: any) => (...args: any) => any; rearg: (func: Function, order: any) => (...args: any) => any; rest: (func: Function) => (first: any, ...args: any) => any; spread: (func: Function) => (args: any) => any; unary: (fn: Function) => Function; wrap: (value: any, func: Function) => Function; now: () => number; countBy: (collection: T_35[], predicate?: import("./helpers/predicateType").default) => Object; each: (collection: T_36, iteratee?: Function) => T_36; eachRight: (collection: T_37, iteratee?: Function) => T_37; every: (collection: T_38, iteratee?: import("./helpers/predicateType").default) => T_38; filter: (collection: T_39, iteratee?: import("./helpers/predicateType").default) => T_39; find: (collection: T_40[], iteratee?: import("./helpers/predicateType").default, fromIndex?: number) => Object; findLast: (collection: T_41, iteratee?: import("./helpers/predicateType").default, fromIndex?: number) => T_41 | undefined; flatMap: (collection: T_42, iteratee?: import("./helpers/predicateType").default) => T_42; flatMapDeep: (collection: T_43, iteratee?: import("./helpers/predicateType").default) => T_43; flatMapDepth: (collection: T_44, iteratee?: import("./helpers/predicateType").default, depth?: number) => T_44; forEach: (collection: T_36, iteratee?: Function) => T_36; forEachRight: (collection: T_37, iteratee?: Function) => T_37; freeze: (collection: Object | any[]) => Object | any[]; groupBy: (collection: T_45[], predicate?: import("./helpers/predicateType").default) => Object; includes: (collection: T_46, iteratee?: import("./helpers/predicateType").default, fromIndex?: number) => boolean; invokeMap: (collection: T_47, path: string | Function | any[], ...args: any) => any; keyBy: (collection: T_48[], predicate?: import("./helpers/predicateType").default) => Object; map: (collection: Object | T_49[], iteratee?: import("./helpers/predicateType").default) => T_49; orderBy: (collection: T_50, iteratee: string | string[], orders?: string | string[]) => T_50; partition: (collection: T_51[], predicate?: import("./helpers/predicateType").default) => any[]; preventExtensions: (collection: Object | any[]) => Object | any[]; reduce: (collection: Object | T_52[], iteratee: import("./helpers/predicateType").default | undefined, initialValue: any) => T_52; reduceRight: (collection: T_53, iteratee: import("./helpers/predicateType").default | undefined, initialValue: any) => T_53; reject: (collection: T_54[], predicate?: import("./helpers/predicateType").default) => any[]; sample: (collection: T_55) => any; sampleSize: (collection: T_56, length?: number) => T_56; seal: (collection: Object | any[]) => Object | any[]; shuffle: (collection: T_57) => T_57; size: (collection: string | Object | any[]) => number; some: (collection: T_58, iteratee?: import("./helpers/predicateType").default) => boolean; sortBy: (collection: T_59[], iteratees?: string | Function | (string | Function)[]) => T_59[]; chunk: (array: T_60[], chunkSize?: number, cache?: T_60[][]) => T_60[][]; compact: (array: T_61[]) => T_61[]; concat: (array: T_62[], ...restArray: any[]) => T_62[]; difference: (array: T_63[] | null | undefined, ...restArray: T_63[][]) => T_63[]; differenceBy: import("./array/interface/IDifferenceBy").default; differenceWith: import("./array/interface/IDifferenceWith").default; drop: (array: T_64[], n?: number) => T_64[]; dropRight: (array: T_65[], n?: number) => T_65[]; dropRightWhile: (array: T_66[], predicate?: import("./helpers/predicateType").default) => T_66[]; dropWhile: (array: T_67[], predicate?: import("./helpers/predicateType").default) => T_67[]; fill: (array: T_68[], value: any, start?: number, end?: number) => T_68[]; findIndex: (array: T_69, predicate?: import("./helpers/predicateType").default, fromIndex?: number) => number; findLastIndex: (array: T_70[], predicate?: import("./helpers/predicateType").default, fromIndex?: number, toIndex?: number) => number; first: (array: T_71[]) => T_71 | undefined; flatten: (array: T_72[]) => any[]; flattenDeep: (array: T_73[]) => any[]; flattenDepth: (array: T_74[], depth?: number) => any[]; fromPairs: (array: T_75[][]) => Object; head: (array: T_71[]) => T_71 | undefined; indexOf: (array: T_76[], value: T_76, startIndex?: number) => number; initial: (array: T_77[]) => T_77[]; intersection: import("./array/interface/IIntersection").default; intersectionBy: (array: T_78[], ...args: any[]) => T_78[]; intersectionWith: import("./array/interface/IIntersectionWith").default; join: (array: T_79[], joiner?: string) => string; last: (array: T_80[]) => T_80 | undefined; lastIndexOf: (array: T_81[], element: T_81, fromIndex?: number) => number; nth: (array: T_82[], index?: number) => T_82 | undefined; pull: (array: T_83[], ...elementsToRemove: T_83[]) => T_83[]; pullAll: (array: T_84[], elementsToRemove: T_84[]) => T_84[]; pullAllBy: (array: T_85[], elementsToRemove: T_85[], iteratee?: import("./helpers/predicateType").default) => T_85[]; pullAllWith: (array: T_86[], elementsToRemove: T_86[], comparator: Function) => T_86[]; pullAt: (array: T_87[], indexes: number | number[]) => T_87[]; remove: (array: T_88[], predicate?: Function) => T_88[]; reverse: (array: T_89[]) => T_89[]; slice: (array: T_90[], start?: number, end?: number) => T_90[]; sortedIndex: (array: T_91[], value: T_91) => number; sortedIndexBy: (array: T_92[], value: T_92, iteratee?: import("./helpers/predicateType").default) => number; sortedIndexOf: (array: T_93[], value: T_93) => number; sortedLastIndex: (array: T_94[], value: T_94) => number; sortedLastIndexBy: (array: T_95[], value: T_95, iteratee?: import("./helpers/predicateType").default) => number; sortedLastIndexOf: (array: T_96[], value: T_96) => number; sortedUniq: (array: T_97[]) => T_97[]; sortedUniqBy: (array: T_98[], iteratee: Function) => T_98[]; tail: (array: T_99[]) => T_99[]; take: (array: T_100[], n?: number) => T_100[]; takeRight: (array: T_101[], length?: number) => T_101[]; takeRightWhile: (array: T_102[], predicate?: import("./helpers/predicateType").default) => T_102[]; takeWhile: (array: T_103[], predicate?: import("./helpers/predicateType").default) => T_103[]; union: (array: T_104[], ...restArray: T_104[][]) => T_104[]; unionBy: (array: T_105[], ...args: any) => T_105[]; unionWith: (array: T_106[], ...args: any) => T_106[]; uniq: (array: T_107[]) => T_107[]; uniqBy: (array: T_108[], iteratee?: import("./helpers/predicateType").default) => T_108[]; uniqWith: (array: T_109[], comparator?: import("./helpers/predicateType").default) => T_109[]; unshift: (array: T_110[], ...elements: any) => T_110[]; unzip: ([...array]: any[][]) => any[][]; unzipWith: (array: any[][], predicate?: import("./helpers/predicateType").default) => any[]; without: (array: T_112[], ...exception: T_112[]) => T_112[]; xor: (array: T_113[], ...restArray: T_113[][]) => T_113[]; xorBy: (array: T_114[], ...args: any) => T_114[]; xorWith: (array: T_115[], ...args: any) => T_115[]; zip: (array: any[], ...args: any[][]) => any[][]; zipObject: (props?: any[], values?: any[]) => Object; zipWith: (arrays: any[], ...args: any[]) => any[]; }; export { chunk, compact, concat, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, first, fill, findIndex, findLastIndex, flatten, flattenDeep, flattenDepth, fromPairs, head, indexOf, initial, intersection, intersectionBy, intersectionWith, join, last, lastIndexOf, nth, pull, pullAll, pullAllBy, pullAllWith, pullAt, remove, reverse, slice, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, tail, take, takeRight, takeRightWhile, takeWhile, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unshift, unzip, unzipWith, without, xor, xorBy, xorWith, zip, zipObject, zipWith, countBy, each, eachRight, every, filter, find, findLast, flatMap, flatMapDeep, flatMapDepth, forEach, forEachRight, freeze, groupBy, includes, invokeMap, keyBy, map, orderBy, partition, preventExtensions, reduce, reduceRight, reject, sample, sampleSize, seal, shuffle, size, some, sortBy, now, after, ary, before, bind, bindKey, curry, curryRight, debounce, delay, flip, negate, once, overArgs, partial, partialRight, rearg, rest, spread, unary, wrap, castArray, clone, cloneDeep, cloneWith, conformsTo, eq, gt, gte, isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isElement, isEmpty, isEqual, isEqualWith, isError, isExtensible, isFinite, isFrozen, isFunction, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isRegExp, isSafeInteger, isSealed, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, lt, lte, toPlainObject, toNumber, toSafeInteger, toString, add, ceil, divide, floor, max, maxBy, mean, meanBy, min, minBy, multiply, round, subtract, sum, sumBy, clamp, inRange, random, assign, assignIn, assignInWith, assignWith, at, create, defaults, entries, extend, extendWith, findKey, findLastKey, forIn, forInRight, forOwn, forOwnRight, functions, functionsIn, get, has, hasIn, invert, invertBy, keys, keysIn, mapKeys, mapValues, merge, omit, omitBy, pick, pickBy, set, setWith, toPairs, toPairsIn, transform, unset, update, updateWith, values, valuesIn, chain2, tap2, thru, camelCase, capitalize, endsWith, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, padEnd, padStart, parseInt, repeat, replace, snakeCase, split, startCase, startsWith, toLower, toUpper, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words, attempt, cond, conforms, constant, defaultTo, flow, flowRight, identity, iteratee, method, methodOf, noop, nthArg, over, overEvery, overSome, property, propertyOf, range, rangeRight, sleep, stubArray, stubFalse, stubObject, stubString, stubTrue, times, toPath, uniqueId, uniqueId2, }; export default _;