Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

exer

Package Overview
Dependencies
Maintainers
1
Versions
40
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

exer - npm Package Compare versions

Comparing version 0.0.29 to 0.0.30

814

lib/index.d.ts

@@ -34,238 +34,238 @@ /// <reference types="node" />

templateSettings: lo.TemplateSettings;
chunk<T>(array: ArrayLike<T>, size?: number): T[][];
compact<T>(array: ArrayLike<false | "" | 0 | T>): T[];
concat<T>(array: lo.Many<T>, ...values: lo.Many<T>[]): T[];
difference<T>(array: ArrayLike<T>, ...values: ArrayLike<T>[]): T[];
differenceBy<T1, T2>(array: ArrayLike<T1>, values: ArrayLike<T2>, iteratee: lo.ValueIteratee<T1 | T2>): T1[];
differenceBy<T1, T2, T3>(array: ArrayLike<T1>, values1: ArrayLike<T2>, values2: ArrayLike<T3>, iteratee: lo.ValueIteratee<T1 | T2 | T3>): T1[];
differenceBy<T1, T2, T3, T4>(array: ArrayLike<T1>, values1: ArrayLike<T2>, values2: ArrayLike<T3>, values3: ArrayLike<T4>, iteratee: lo.ValueIteratee<T1 | T2 | T3 | T4>): T1[];
differenceBy<T1, T2, T3, T4, T5>(array: ArrayLike<T1>, values1: ArrayLike<T2>, values2: ArrayLike<T3>, values3: ArrayLike<T4>, values4: ArrayLike<T5>, iteratee: lo.ValueIteratee<T1 | T2 | T3 | T4 | T5>): T1[];
differenceBy<T1, T2, T3, T4, T5, T6>(array: ArrayLike<T1>, values1: ArrayLike<T2>, values2: ArrayLike<T3>, values3: ArrayLike<T4>, values4: ArrayLike<T5>, values5: ArrayLike<T6>, iteratee: lo.ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6>): T1[];
differenceBy<T1, T2, T3, T4, T5, T6, T7>(array: ArrayLike<T1>, values1: ArrayLike<T2>, values2: ArrayLike<T3>, values3: ArrayLike<T4>, values4: ArrayLike<T5>, values5: ArrayLike<T6>, ...values: (string | number | symbol | [string | number | symbol, any] | ArrayLike<T7> | ((value: T1 | T2 | T3 | T4 | T5 | T6 | T7) => unknown) | lo.PartialShallow<T1> | lo.PartialShallow<T2> | lo.PartialShallow<T3> | lo.PartialShallow<T4> | lo.PartialShallow<T5> | lo.PartialShallow<T6> | lo.PartialShallow<T7>)[]): T1[];
differenceBy<T>(array: ArrayLike<T>, ...values: ArrayLike<T>[]): T[];
differenceWith<T1, T2>(array: ArrayLike<T1>, values: ArrayLike<T2>, comparator: lo.Comparator2<T1, T2>): T1[];
differenceWith<T1, T2, T3>(array: ArrayLike<T1>, values1: ArrayLike<T2>, values2: ArrayLike<T3>, comparator: lo.Comparator2<T1, T2 | T3>): T1[];
differenceWith<T1, T2, T3, T4>(array: ArrayLike<T1>, values1: ArrayLike<T2>, values2: ArrayLike<T3>, ...values: (ArrayLike<T4> | lo.Comparator2<T1, T2 | T3 | T4>)[]): T1[];
differenceWith<T>(array: ArrayLike<T>, ...values: ArrayLike<T>[]): T[];
drop<T>(array: ArrayLike<T>, n?: number): T[];
dropRight<T>(array: ArrayLike<T>, n?: number): T[];
dropRightWhile<T>(array: ArrayLike<T>, predicate?: lo.ListIteratee<T>): T[];
dropWhile<T>(array: ArrayLike<T>, predicate?: lo.ListIteratee<T>): T[];
fill<T>(array: any[], value: T): T[];
fill<T>(array: ArrayLike<any>, value: T): ArrayLike<T>;
fill<T, U>(array: U[], value: T, start?: number, end?: number): (T | U)[];
fill<T, U>(array: ArrayLike<U>, value: T, start?: number, end?: number): ArrayLike<T | U>;
findIndex<T>(array: ArrayLike<T>, predicate?: lo.ListIterateeCustom<T, boolean>, fromIndex?: number): number;
findLastIndex<T>(array: ArrayLike<T>, predicate?: lo.ListIterateeCustom<T, boolean>, fromIndex?: number): number;
first: <T>(array: ArrayLike<T>) => T;
flatten<T>(array: ArrayLike<lo.Many<T>>): T[];
flattenDeep<T>(array: lo.ListOfRecursiveArraysOrValues<T>): T[];
flattenDepth<T>(array: lo.ListOfRecursiveArraysOrValues<T>, depth?: number): T[];
fromPairs<T>(pairs: ArrayLike<[string | number | symbol, T]>): lo.Dictionary<T>;
fromPairs(pairs: ArrayLike<any[]>): lo.Dictionary<any>;
head<T>(array: ArrayLike<T>): T;
indexOf<T>(array: ArrayLike<T>, value: T, fromIndex?: number): number;
initial<T>(array: ArrayLike<T>): T[];
intersection<T>(...arrays: ArrayLike<T>[]): T[];
intersectionBy<T1, T2>(array: ArrayLike<T1>, values: ArrayLike<T2>, iteratee: lo.ValueIteratee<T1 | T2>): T1[];
intersectionBy<T1, T2, T3>(array: ArrayLike<T1>, values1: ArrayLike<T2>, values2: ArrayLike<T3>, iteratee: lo.ValueIteratee<T1 | T2 | T3>): T1[];
intersectionBy<T1, T2, T3, T4>(array: ArrayLike<T1>, values1: ArrayLike<T2>, values2: ArrayLike<T3>, ...values: (string | number | symbol | [string | number | symbol, any] | ArrayLike<T4> | ((value: T1 | T2 | T3 | T4) => unknown) | lo.PartialShallow<T1> | lo.PartialShallow<T2> | lo.PartialShallow<T3> | lo.PartialShallow<T4>)[]): T1[];
intersectionBy<T>(array?: ArrayLike<T>, ...values: ArrayLike<T>[]): T[];
intersectionBy<T>(...values: (string | number | symbol | [string | number | symbol, any] | ArrayLike<T> | ((value: T) => unknown) | lo.PartialShallow<T>)[]): T[];
intersectionWith<T1, T2>(array: ArrayLike<T1>, values: ArrayLike<T2>, comparator: lo.Comparator2<T1, T2>): T1[];
intersectionWith<T1, T2, T3>(array: ArrayLike<T1>, values1: ArrayLike<T2>, values2: ArrayLike<T3>, comparator: lo.Comparator2<T1, T2 | T3>): T1[];
intersectionWith<T1, T2, T3, T4>(array: ArrayLike<T1>, values1: ArrayLike<T2>, values2: ArrayLike<T3>, ...values: (ArrayLike<T4> | lo.Comparator2<T1, T2 | T3 | T4>)[]): T1[];
intersectionWith<T>(array?: ArrayLike<T>, ...values: ArrayLike<T>[]): T[];
join(array: ArrayLike<any>, separator?: string): string;
last<T>(array: ArrayLike<T>): T;
lastIndexOf<T>(array: ArrayLike<T>, value: T, fromIndex?: number | true): number;
nth<T>(array: ArrayLike<T>, n?: number): T;
pull<T>(array: T[], ...values: T[]): T[];
pull<T>(array: ArrayLike<T>, ...values: T[]): ArrayLike<T>;
pullAll<T>(array: T[], values?: ArrayLike<T>): T[];
pullAll<T>(array: ArrayLike<T>, values?: ArrayLike<T>): ArrayLike<T>;
pullAllBy<T>(array: T[], values?: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): T[];
pullAllBy<T>(array: ArrayLike<T>, values?: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): ArrayLike<T>;
pullAllBy<T1, T2>(array: T1[], values: ArrayLike<T2>, iteratee: lo.ValueIteratee<T1 | T2>): T1[];
pullAllBy<T1, T2>(array: ArrayLike<T1>, values: ArrayLike<T2>, iteratee: lo.ValueIteratee<T1 | T2>): ArrayLike<T1>;
pullAllWith<T>(array: T[], values?: ArrayLike<T>, comparator?: lo.Comparator<T>): T[];
pullAllWith<T>(array: ArrayLike<T>, values?: ArrayLike<T>, comparator?: lo.Comparator<T>): ArrayLike<T>;
pullAllWith<T1, T2>(array: T1[], values: ArrayLike<T2>, comparator: lo.Comparator2<T1, T2>): T1[];
pullAllWith<T1, T2>(array: ArrayLike<T1>, values: ArrayLike<T2>, comparator: lo.Comparator2<T1, T2>): ArrayLike<T1>;
pullAt<T>(array: T[], ...indexes: lo.Many<number>[]): T[];
pullAt<T>(array: ArrayLike<T>, ...indexes: lo.Many<number>[]): ArrayLike<T>;
remove<T>(array: ArrayLike<T>, predicate?: lo.ListIteratee<T>): T[];
reverse<TList extends ArrayLike<any>>(array: TList): TList;
slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
sortedIndex<T>(array: ArrayLike<T>, value: T): number;
sortedIndex<T>(array: ArrayLike<T>, value: T): number;
sortedIndexBy<T>(array: ArrayLike<T>, value: T, iteratee?: lo.ValueIteratee<T>): number;
sortedIndexOf<T>(array: ArrayLike<T>, value: T): number;
sortedLastIndex<T>(array: ArrayLike<T>, value: T): number;
sortedLastIndexBy<T>(array: ArrayLike<T>, value: T, iteratee: lo.ValueIteratee<T>): number;
sortedLastIndexOf<T>(array: ArrayLike<T>, value: T): number;
sortedUniq<T>(array: ArrayLike<T>): T[];
sortedUniqBy<T>(array: ArrayLike<T>, iteratee: lo.ValueIteratee<T>): T[];
tail<T>(array: ArrayLike<T>): T[];
take<T>(array: ArrayLike<T>, n?: number): T[];
takeRight<T>(array: ArrayLike<T>, n?: number): T[];
takeRightWhile<T>(array: ArrayLike<T>, predicate?: lo.ListIteratee<T>): T[];
takeWhile<T>(array: ArrayLike<T>, predicate?: lo.ListIteratee<T>): T[];
union<T>(...arrays: ArrayLike<T>[]): T[];
unionBy<T>(arrays: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): T[];
unionBy<T>(arrays1: ArrayLike<T>, arrays2: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): T[];
unionBy<T>(arrays1: ArrayLike<T>, arrays2: ArrayLike<T>, arrays3: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): T[];
unionBy<T>(arrays1: ArrayLike<T>, arrays2: ArrayLike<T>, arrays3: ArrayLike<T>, arrays4: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): T[];
unionBy<T>(arrays1: ArrayLike<T>, arrays2: ArrayLike<T>, arrays3: ArrayLike<T>, arrays4: ArrayLike<T>, arrays5: ArrayLike<T>, ...iteratee: (string | number | symbol | [string | number | symbol, any] | ((value: T) => unknown) | lo.PartialShallow<T> | ArrayLike<T>)[]): T[];
unionWith<T>(arrays: ArrayLike<T>, comparator?: lo.Comparator<T>): T[];
unionWith<T>(arrays: ArrayLike<T>, arrays2: ArrayLike<T>, comparator?: lo.Comparator<T>): T[];
unionWith<T>(arrays: ArrayLike<T>, arrays2: ArrayLike<T>, arrays3: ArrayLike<T>, ...comparator: (lo.Comparator<T> | ArrayLike<T>)[]): T[];
uniq<T>(array: ArrayLike<T>): T[];
uniqBy<T>(array: ArrayLike<T>, iteratee: lo.ValueIteratee<T>): T[];
uniqWith<T>(array: ArrayLike<T>, comparator?: lo.Comparator<T>): T[];
unzip<T>(array: T[][] | ArrayLike<ArrayLike<T>>): T[][];
unzipWith<T, TResult>(array: ArrayLike<ArrayLike<T>>, iteratee: (...values: T[]) => TResult): TResult[];
unzipWith<T>(array: ArrayLike<ArrayLike<T>>): T[][];
without<T>(array: ArrayLike<T>, ...values: T[]): T[];
xor<T>(...arrays: ArrayLike<T>[]): T[];
xorBy<T>(arrays: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): T[];
xorBy<T>(arrays: ArrayLike<T>, arrays2: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): T[];
xorBy<T>(arrays: ArrayLike<T>, arrays2: ArrayLike<T>, arrays3: ArrayLike<T>, ...iteratee: (string | number | symbol | [string | number | symbol, any] | ((value: T) => unknown) | lo.PartialShallow<T> | ArrayLike<T>)[]): T[];
xorWith<T>(arrays: ArrayLike<T>, comparator?: lo.Comparator<T>): T[];
xorWith<T>(arrays: ArrayLike<T>, arrays2: ArrayLike<T>, comparator?: lo.Comparator<T>): T[];
xorWith<T>(arrays: ArrayLike<T>, arrays2: ArrayLike<T>, arrays3: ArrayLike<T>, ...comparator: (lo.Comparator<T> | ArrayLike<T>)[]): T[];
zip<T1, T2>(arrays1: ArrayLike<T1>, arrays2: ArrayLike<T2>): [T1, T2][];
zip<T1, T2, T3>(arrays1: ArrayLike<T1>, arrays2: ArrayLike<T2>, arrays3: ArrayLike<T3>): [T1, T2, T3][];
zip<T1, T2, T3, T4>(arrays1: ArrayLike<T1>, arrays2: ArrayLike<T2>, arrays3: ArrayLike<T3>, arrays4: ArrayLike<T4>): [T1, T2, T3, T4][];
zip<T1, T2, T3, T4, T5>(arrays1: ArrayLike<T1>, arrays2: ArrayLike<T2>, arrays3: ArrayLike<T3>, arrays4: ArrayLike<T4>, arrays5: ArrayLike<T5>): [T1, T2, T3, T4, T5][];
zip<T>(...arrays: ArrayLike<T>[]): T[][];
zipObject<T>(props: ArrayLike<string | number | symbol>, values: ArrayLike<T>): lo.Dictionary<T>;
zipObject(props?: ArrayLike<string | number | symbol>): lo.Dictionary<undefined>;
zipObjectDeep(paths?: ArrayLike<lo.Many<string | number | symbol>>, values?: ArrayLike<any>): object;
zipWith<T, TResult>(arrays: ArrayLike<T>, iteratee: (value1: T) => TResult): TResult[];
zipWith<T1, T2, TResult>(arrays1: ArrayLike<T1>, arrays2: ArrayLike<T2>, iteratee: (value1: T1, value2: T2) => TResult): TResult[];
zipWith<T1, T2, T3, TResult>(arrays1: ArrayLike<T1>, arrays2: ArrayLike<T2>, arrays3: ArrayLike<T3>, iteratee: (value1: T1, value2: T2, value3: T3) => TResult): TResult[];
zipWith<T1, T2, T3, T4, TResult>(arrays1: ArrayLike<T1>, arrays2: ArrayLike<T2>, arrays3: ArrayLike<T3>, arrays4: ArrayLike<T4>, iteratee: (value1: T1, value2: T2, value3: T3, value4: T4) => TResult): TResult[];
zipWith<T1, T2, T3, T4, T5, TResult>(arrays1: ArrayLike<T1>, arrays2: ArrayLike<T2>, arrays3: ArrayLike<T3>, arrays4: ArrayLike<T4>, arrays5: ArrayLike<T5>, iteratee: (value1: T1, value2: T2, value3: T3, value4: T4, value5: T5) => TResult): TResult[];
zipWith<T, TResult>(...iteratee: (((...group: T[]) => TResult) | ArrayLike<T>)[]): TResult[];
countBy<T>(collection: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): lo.Dictionary<number>;
countBy<T extends object>(collection: T, iteratee?: lo.ValueIteratee<T[keyof T]>): lo.Dictionary<number>;
chunk<T>(array: lo.List<T>, size?: number): T[][];
compact<T_1>(array: lo.List<false | "" | 0 | T_1>): T_1[];
concat<T_2>(array: lo.Many<T_2>, ...values: lo.Many<T_2>[]): T_2[];
difference<T_3>(array: lo.List<T_3>, ...values: lo.List<T_3>[]): T_3[];
differenceBy<T1, T2>(array: lo.List<T1>, values: lo.List<T2>, iteratee: lo.ValueIteratee<T1 | T2>): T1[];
differenceBy<T1_1, T2_1, T3>(array: lo.List<T1_1>, values1: lo.List<T2_1>, values2: lo.List<T3>, iteratee: lo.ValueIteratee<T1_1 | T2_1 | T3>): T1_1[];
differenceBy<T1_2, T2_2, T3_1, T4>(array: lo.List<T1_2>, values1: lo.List<T2_2>, values2: lo.List<T3_1>, values3: lo.List<T4>, iteratee: lo.ValueIteratee<T1_2 | T2_2 | T3_1 | T4>): T1_2[];
differenceBy<T1_3, T2_3, T3_2, T4_1, T5>(array: lo.List<T1_3>, values1: lo.List<T2_3>, values2: lo.List<T3_2>, values3: lo.List<T4_1>, values4: lo.List<T5>, iteratee: lo.ValueIteratee<T1_3 | T2_3 | T3_2 | T4_1 | T5>): T1_3[];
differenceBy<T1_4, T2_4, T3_3, T4_2, T5_1, T6>(array: lo.List<T1_4>, values1: lo.List<T2_4>, values2: lo.List<T3_3>, values3: lo.List<T4_2>, values4: lo.List<T5_1>, values5: lo.List<T6>, iteratee: lo.ValueIteratee<T1_4 | T2_4 | T3_3 | T4_2 | T5_1 | T6>): T1_4[];
differenceBy<T1_5, T2_5, T3_4, T4_3, T5_2, T6_1, T7>(array: lo.List<T1_5>, values1: lo.List<T2_5>, values2: lo.List<T3_4>, values3: lo.List<T4_3>, values4: lo.List<T5_2>, values5: lo.List<T6_1>, ...values: (string | number | symbol | [string | number | symbol, any] | lo.List<T7> | ((value: T1_5 | T2_5 | T3_4 | T4_3 | T5_2 | T6_1 | T7) => unknown) | lo.PartialShallow<T1_5> | lo.PartialShallow<T2_5> | lo.PartialShallow<T3_4> | lo.PartialShallow<T4_3> | lo.PartialShallow<T5_2> | lo.PartialShallow<T6_1> | lo.PartialShallow<T7>)[]): T1_5[];
differenceBy<T_4>(array: lo.List<T_4>, ...values: lo.List<T_4>[]): T_4[];
differenceWith<T1_6, T2_6>(array: lo.List<T1_6>, values: lo.List<T2_6>, comparator: lo.Comparator2<T1_6, T2_6>): T1_6[];
differenceWith<T1_7, T2_7, T3_5>(array: lo.List<T1_7>, values1: lo.List<T2_7>, values2: lo.List<T3_5>, comparator: lo.Comparator2<T1_7, T2_7 | T3_5>): T1_7[];
differenceWith<T1_8, T2_8, T3_6, T4_4>(array: lo.List<T1_8>, values1: lo.List<T2_8>, values2: lo.List<T3_6>, ...values: (lo.List<T4_4> | lo.Comparator2<T1_8, T2_8 | T3_6 | T4_4>)[]): T1_8[];
differenceWith<T_5>(array: lo.List<T_5>, ...values: lo.List<T_5>[]): T_5[];
drop<T_6>(array: lo.List<T_6>, n?: number): T_6[];
dropRight<T_7>(array: lo.List<T_7>, n?: number): T_7[];
dropRightWhile<T_8>(array: lo.List<T_8>, predicate?: lo.ListIteratee<T_8>): T_8[];
dropWhile<T_9>(array: lo.List<T_9>, predicate?: lo.ListIteratee<T_9>): T_9[];
fill<T_10>(array: any[], value: T_10): T_10[];
fill<T_11>(array: lo.List<any>, value: T_11): lo.List<T_11>;
fill<T_12, U>(array: U[], value: T_12, start?: number, end?: number): (T_12 | U)[];
fill<T_13, U_1>(array: lo.List<U_1>, value: T_13, start?: number, end?: number): lo.List<T_13 | U_1>;
findIndex<T_14>(array: lo.List<T_14>, predicate?: lo.ListIterateeCustom<T_14, boolean>, fromIndex?: number): number;
findLastIndex<T_15>(array: lo.List<T_15>, predicate?: lo.ListIterateeCustom<T_15, boolean>, fromIndex?: number): number;
first: <T_16>(array: lo.List<T_16>) => T_16;
flatten<T_17>(array: lo.List<lo.Many<T_17>>): T_17[];
flattenDeep<T_18>(array: lo.ListOfRecursiveArraysOrValues<T_18>): lo.Flat<T_18>[];
flattenDepth<T_19>(array: lo.ListOfRecursiveArraysOrValues<T_19>, depth?: number): T_19[];
fromPairs<T_20>(pairs: lo.List<[string | number | symbol, T_20]>): lo.Dictionary<T_20>;
fromPairs(pairs: lo.List<any[]>): lo.Dictionary<any>;
head<T_16>(array: lo.List<T_16>): T_16;
indexOf<T_21>(array: lo.List<T_21>, value: T_21, fromIndex?: number): number;
initial<T_22>(array: lo.List<T_22>): T_22[];
intersection<T_23>(...arrays: lo.List<T_23>[]): T_23[];
intersectionBy<T1_9, T2_9>(array: lo.List<T1_9>, values: lo.List<T2_9>, iteratee: lo.ValueIteratee<T1_9 | T2_9>): T1_9[];
intersectionBy<T1_10, T2_10, T3_7>(array: lo.List<T1_10>, values1: lo.List<T2_10>, values2: lo.List<T3_7>, iteratee: lo.ValueIteratee<T1_10 | T2_10 | T3_7>): T1_10[];
intersectionBy<T1_11, T2_11, T3_8, T4_5>(array: lo.List<T1_11>, values1: lo.List<T2_11>, values2: lo.List<T3_8>, ...values: (string | number | symbol | [string | number | symbol, any] | lo.List<T4_5> | ((value: T1_11 | T2_11 | T3_8 | T4_5) => unknown) | lo.PartialShallow<T1_11> | lo.PartialShallow<T2_11> | lo.PartialShallow<T3_8> | lo.PartialShallow<T4_5>)[]): T1_11[];
intersectionBy<T_24>(array?: lo.List<T_24>, ...values: lo.List<T_24>[]): T_24[];
intersectionBy<T_25>(...values: (string | number | symbol | [string | number | symbol, any] | lo.List<T_25> | ((value: T_25) => unknown) | lo.PartialShallow<T_25>)[]): T_25[];
intersectionWith<T1_12, T2_12>(array: lo.List<T1_12>, values: lo.List<T2_12>, comparator: lo.Comparator2<T1_12, T2_12>): T1_12[];
intersectionWith<T1_13, T2_13, T3_9>(array: lo.List<T1_13>, values1: lo.List<T2_13>, values2: lo.List<T3_9>, comparator: lo.Comparator2<T1_13, T2_13 | T3_9>): T1_13[];
intersectionWith<T1_14, T2_14, T3_10, T4_6>(array: lo.List<T1_14>, values1: lo.List<T2_14>, values2: lo.List<T3_10>, ...values: (lo.List<T4_6> | lo.Comparator2<T1_14, T2_14 | T3_10 | T4_6>)[]): T1_14[];
intersectionWith<T_26>(array?: lo.List<T_26>, ...values: lo.List<T_26>[]): T_26[];
join(array: lo.List<any>, separator?: string): string;
last<T_27>(array: lo.List<T_27>): T_27;
lastIndexOf<T_28>(array: lo.List<T_28>, value: T_28, fromIndex?: number | true): number;
nth<T_29>(array: lo.List<T_29>, n?: number): T_29;
pull<T_30>(array: T_30[], ...values: T_30[]): T_30[];
pull<T_31>(array: lo.List<T_31>, ...values: T_31[]): lo.List<T_31>;
pullAll<T_32>(array: T_32[], values?: lo.List<T_32>): T_32[];
pullAll<T_33>(array: lo.List<T_33>, values?: lo.List<T_33>): lo.List<T_33>;
pullAllBy<T_34>(array: T_34[], values?: lo.List<T_34>, iteratee?: lo.ValueIteratee<T_34>): T_34[];
pullAllBy<T_35>(array: lo.List<T_35>, values?: lo.List<T_35>, iteratee?: lo.ValueIteratee<T_35>): lo.List<T_35>;
pullAllBy<T1_15, T2_15>(array: T1_15[], values: lo.List<T2_15>, iteratee: lo.ValueIteratee<T1_15 | T2_15>): T1_15[];
pullAllBy<T1_16, T2_16>(array: lo.List<T1_16>, values: lo.List<T2_16>, iteratee: lo.ValueIteratee<T1_16 | T2_16>): lo.List<T1_16>;
pullAllWith<T_36>(array: T_36[], values?: lo.List<T_36>, comparator?: lo.Comparator<T_36>): T_36[];
pullAllWith<T_37>(array: lo.List<T_37>, values?: lo.List<T_37>, comparator?: lo.Comparator<T_37>): lo.List<T_37>;
pullAllWith<T1_17, T2_17>(array: T1_17[], values: lo.List<T2_17>, comparator: lo.Comparator2<T1_17, T2_17>): T1_17[];
pullAllWith<T1_18, T2_18>(array: lo.List<T1_18>, values: lo.List<T2_18>, comparator: lo.Comparator2<T1_18, T2_18>): lo.List<T1_18>;
pullAt<T_38>(array: T_38[], ...indexes: lo.Many<number>[]): T_38[];
pullAt<T_39>(array: lo.List<T_39>, ...indexes: lo.Many<number>[]): lo.List<T_39>;
remove<T_40>(array: lo.List<T_40>, predicate?: lo.ListIteratee<T_40>): T_40[];
reverse<TList extends lo.List<any>>(array: TList): TList;
slice<T_41>(array: lo.List<T_41>, start?: number, end?: number): T_41[];
sortedIndex<T_42>(array: lo.List<T_42>, value: T_42): number;
sortedIndex<T_43>(array: lo.List<T_43>, value: T_43): number;
sortedIndexBy<T_44>(array: lo.List<T_44>, value: T_44, iteratee?: lo.ValueIteratee<T_44>): number;
sortedIndexOf<T_45>(array: lo.List<T_45>, value: T_45): number;
sortedLastIndex<T_46>(array: lo.List<T_46>, value: T_46): number;
sortedLastIndexBy<T_47>(array: lo.List<T_47>, value: T_47, iteratee: lo.ValueIteratee<T_47>): number;
sortedLastIndexOf<T_48>(array: lo.List<T_48>, value: T_48): number;
sortedUniq<T_49>(array: lo.List<T_49>): T_49[];
sortedUniqBy<T_50>(array: lo.List<T_50>, iteratee: lo.ValueIteratee<T_50>): T_50[];
tail<T_51>(array: lo.List<T_51>): T_51[];
take<T_52>(array: lo.List<T_52>, n?: number): T_52[];
takeRight<T_53>(array: lo.List<T_53>, n?: number): T_53[];
takeRightWhile<T_54>(array: lo.List<T_54>, predicate?: lo.ListIteratee<T_54>): T_54[];
takeWhile<T_55>(array: lo.List<T_55>, predicate?: lo.ListIteratee<T_55>): T_55[];
union<T_56>(...arrays: lo.List<T_56>[]): T_56[];
unionBy<T_57>(arrays: lo.List<T_57>, iteratee?: lo.ValueIteratee<T_57>): T_57[];
unionBy<T_58>(arrays1: lo.List<T_58>, arrays2: lo.List<T_58>, iteratee?: lo.ValueIteratee<T_58>): T_58[];
unionBy<T_59>(arrays1: lo.List<T_59>, arrays2: lo.List<T_59>, arrays3: lo.List<T_59>, iteratee?: lo.ValueIteratee<T_59>): T_59[];
unionBy<T_60>(arrays1: lo.List<T_60>, arrays2: lo.List<T_60>, arrays3: lo.List<T_60>, arrays4: lo.List<T_60>, iteratee?: lo.ValueIteratee<T_60>): T_60[];
unionBy<T_61>(arrays1: lo.List<T_61>, arrays2: lo.List<T_61>, arrays3: lo.List<T_61>, arrays4: lo.List<T_61>, arrays5: lo.List<T_61>, ...iteratee: (string | number | symbol | [string | number | symbol, any] | ((value: T_61) => unknown) | lo.PartialShallow<T_61> | lo.List<T_61>)[]): T_61[];
unionWith<T_62>(arrays: lo.List<T_62>, comparator?: lo.Comparator<T_62>): T_62[];
unionWith<T_63>(arrays: lo.List<T_63>, arrays2: lo.List<T_63>, comparator?: lo.Comparator<T_63>): T_63[];
unionWith<T_64>(arrays: lo.List<T_64>, arrays2: lo.List<T_64>, arrays3: lo.List<T_64>, ...comparator: (lo.Comparator<T_64> | lo.List<T_64>)[]): T_64[];
uniq<T_65>(array: lo.List<T_65>): T_65[];
uniqBy<T_66>(array: lo.List<T_66>, iteratee: lo.ValueIteratee<T_66>): T_66[];
uniqWith<T_67>(array: lo.List<T_67>, comparator?: lo.Comparator<T_67>): T_67[];
unzip<T_68>(array: T_68[][] | lo.List<lo.List<T_68>>): T_68[][];
unzipWith<T_69, TResult>(array: lo.List<lo.List<T_69>>, iteratee: (...values: T_69[]) => TResult): TResult[];
unzipWith<T_70>(array: lo.List<lo.List<T_70>>): T_70[][];
without<T_71>(array: lo.List<T_71>, ...values: T_71[]): T_71[];
xor<T_72>(...arrays: lo.List<T_72>[]): T_72[];
xorBy<T_73>(arrays: lo.List<T_73>, iteratee?: lo.ValueIteratee<T_73>): T_73[];
xorBy<T_74>(arrays: lo.List<T_74>, arrays2: lo.List<T_74>, iteratee?: lo.ValueIteratee<T_74>): T_74[];
xorBy<T_75>(arrays: lo.List<T_75>, arrays2: lo.List<T_75>, arrays3: lo.List<T_75>, ...iteratee: (string | number | symbol | [string | number | symbol, any] | ((value: T_75) => unknown) | lo.PartialShallow<T_75> | lo.List<T_75>)[]): T_75[];
xorWith<T_76>(arrays: lo.List<T_76>, comparator?: lo.Comparator<T_76>): T_76[];
xorWith<T_77>(arrays: lo.List<T_77>, arrays2: lo.List<T_77>, comparator?: lo.Comparator<T_77>): T_77[];
xorWith<T_78>(arrays: lo.List<T_78>, arrays2: lo.List<T_78>, arrays3: lo.List<T_78>, ...comparator: (lo.Comparator<T_78> | lo.List<T_78>)[]): T_78[];
zip<T1_19, T2_19>(arrays1: lo.List<T1_19>, arrays2: lo.List<T2_19>): [T1_19, T2_19][];
zip<T1_20, T2_20, T3_11>(arrays1: lo.List<T1_20>, arrays2: lo.List<T2_20>, arrays3: lo.List<T3_11>): [T1_20, T2_20, T3_11][];
zip<T1_21, T2_21, T3_12, T4_7>(arrays1: lo.List<T1_21>, arrays2: lo.List<T2_21>, arrays3: lo.List<T3_12>, arrays4: lo.List<T4_7>): [T1_21, T2_21, T3_12, T4_7][];
zip<T1_22, T2_22, T3_13, T4_8, T5_3>(arrays1: lo.List<T1_22>, arrays2: lo.List<T2_22>, arrays3: lo.List<T3_13>, arrays4: lo.List<T4_8>, arrays5: lo.List<T5_3>): [T1_22, T2_22, T3_13, T4_8, T5_3][];
zip<T_79>(...arrays: lo.List<T_79>[]): T_79[][];
zipObject<T_80>(props: lo.List<string | number | symbol>, values: lo.List<T_80>): lo.Dictionary<T_80>;
zipObject(props?: lo.List<string | number | symbol>): lo.Dictionary<undefined>;
zipObjectDeep(paths?: lo.List<lo.Many<string | number | symbol>>, values?: lo.List<any>): object;
zipWith<T_81, TResult_1>(arrays: lo.List<T_81>, iteratee: (value1: T_81) => TResult_1): TResult_1[];
zipWith<T1_23, T2_23, TResult_2>(arrays1: lo.List<T1_23>, arrays2: lo.List<T2_23>, iteratee: (value1: T1_23, value2: T2_23) => TResult_2): TResult_2[];
zipWith<T1_24, T2_24, T3_14, TResult_3>(arrays1: lo.List<T1_24>, arrays2: lo.List<T2_24>, arrays3: lo.List<T3_14>, iteratee: (value1: T1_24, value2: T2_24, value3: T3_14) => TResult_3): TResult_3[];
zipWith<T1_25, T2_25, T3_15, T4_9, TResult_4>(arrays1: lo.List<T1_25>, arrays2: lo.List<T2_25>, arrays3: lo.List<T3_15>, arrays4: lo.List<T4_9>, iteratee: (value1: T1_25, value2: T2_25, value3: T3_15, value4: T4_9) => TResult_4): TResult_4[];
zipWith<T1_26, T2_26, T3_16, T4_10, T5_4, TResult_5>(arrays1: lo.List<T1_26>, arrays2: lo.List<T2_26>, arrays3: lo.List<T3_16>, arrays4: lo.List<T4_10>, arrays5: lo.List<T5_4>, iteratee: (value1: T1_26, value2: T2_26, value3: T3_16, value4: T4_10, value5: T5_4) => TResult_5): TResult_5[];
zipWith<T_82, TResult_6>(...iteratee: (((...group: T_82[]) => TResult_6) | lo.List<T_82>)[]): TResult_6[];
countBy<T_83>(collection: lo.List<T_83>, iteratee?: lo.ValueIteratee<T_83>): lo.Dictionary<number>;
countBy<T_84 extends object>(collection: T_84, iteratee?: lo.ValueIteratee<T_84[keyof T_84]>): lo.Dictionary<number>;
each: {
<T>(collection: T[], iteratee?: lo.ArrayIterator<T, any>): T[];
<T_85>(collection: T_85[], iteratee?: lo.ArrayIterator<T_85, any>): T_85[];
(collection: string, iteratee?: lo.StringIterator<any>): string;
<T>(collection: ArrayLike<T>, iteratee?: lo.ListIterator<T, any>): ArrayLike<T>;
<T extends object>(collection: T, iteratee?: lo.ObjectIterator<T, any>): T;
<T, TArray extends T[]>(collection: TArray & T[], iteratee?: lo.ArrayIterator<T, any>): TArray;
<T_86>(collection: lo.List<T_86>, iteratee?: lo.ListIterator<T_86, any>): lo.List<T_86>;
<T_87 extends object>(collection: T_87, iteratee?: lo.ObjectIterator<T_87, any>): T_87;
<T_88, TArray extends T_88[]>(collection: TArray & T_88[], iteratee?: lo.ArrayIterator<T_88, any>): TArray;
<TString extends string>(collection: TString, iteratee?: lo.StringIterator<any>): TString;
<T, TList extends ArrayLike<T>>(collection: TList & ArrayLike<T>, iteratee?: lo.ListIterator<T, any>): TList;
<T extends object>(collection: T, iteratee?: lo.ObjectIterator<T, any>): T;
<T_89, TList_1 extends lo.List<T_89>>(collection: TList_1 & lo.List<T_89>, iteratee?: lo.ListIterator<T_89, any>): TList_1;
<T_90 extends object>(collection: T_90, iteratee?: lo.ObjectIterator<T_90, any>): T_90;
};
eachRight: {
<T>(collection: T[], iteratee?: lo.ArrayIterator<T, any>): T[];
<T_91>(collection: T_91[], iteratee?: lo.ArrayIterator<T_91, any>): T_91[];
(collection: string, iteratee?: lo.StringIterator<any>): string;
<T>(collection: ArrayLike<T>, iteratee?: lo.ListIterator<T, any>): ArrayLike<T>;
<T extends object>(collection: T, iteratee?: lo.ObjectIterator<T, any>): T;
<T, TArray extends T[]>(collection: TArray & T[], iteratee?: lo.ArrayIterator<T, any>): TArray;
<TString extends string>(collection: TString, iteratee?: lo.StringIterator<any>): TString;
<T, TList extends ArrayLike<T>>(collection: TList & ArrayLike<T>, iteratee?: lo.ListIterator<T, any>): TList;
<T extends object>(collection: T, iteratee?: lo.ObjectIterator<T, any>): T;
<T_92>(collection: lo.List<T_92>, iteratee?: lo.ListIterator<T_92, any>): lo.List<T_92>;
<T_93 extends object>(collection: T_93, iteratee?: lo.ObjectIterator<T_93, any>): T_93;
<T_94, TArray_1 extends T_94[]>(collection: TArray_1 & T_94[], iteratee?: lo.ArrayIterator<T_94, any>): TArray_1;
<TString_1 extends string>(collection: TString_1, iteratee?: lo.StringIterator<any>): TString_1;
<T_95, TList_2 extends lo.List<T_95>>(collection: TList_2 & lo.List<T_95>, iteratee?: lo.ListIterator<T_95, any>): TList_2;
<T_96 extends object>(collection: T_96, iteratee?: lo.ObjectIterator<T_96, any>): T_96;
};
every<T>(collection: ArrayLike<T>, predicate?: lo.ListIterateeCustom<T, boolean>): boolean;
every<T extends object>(collection: T, predicate?: lo.ObjectIterateeCustom<T, boolean>): boolean;
every<T_97>(collection: lo.List<T_97>, predicate?: lo.ListIterateeCustom<T_97, boolean>): boolean;
every<T_98 extends object>(collection: T_98, predicate?: lo.ObjectIterateeCustom<T_98, boolean>): boolean;
filter(collection: string, predicate?: lo.StringIterator<boolean>): string[];
filter<T, S extends T>(collection: ArrayLike<T>, predicate: lo.ListIteratorTypeGuard<T, S>): S[];
filter<T>(collection: ArrayLike<T>, predicate?: lo.ListIterateeCustom<T, boolean>): T[];
filter<T extends object, S extends T[keyof T]>(collection: T, predicate: lo.ObjectIteratorTypeGuard<T, S>): S[];
filter<T extends object>(collection: T, predicate?: lo.ObjectIterateeCustom<T, boolean>): T[keyof T][];
find<T, S extends T>(collection: ArrayLike<T>, predicate: lo.ListIteratorTypeGuard<T, S>, fromIndex?: number): S;
find<T>(collection: ArrayLike<T>, predicate?: lo.ListIterateeCustom<T, boolean>, fromIndex?: number): T;
find<T extends object, S extends T[keyof T]>(collection: T, predicate: lo.ObjectIteratorTypeGuard<T, S>, fromIndex?: number): S;
find<T extends object>(collection: T, predicate?: lo.ObjectIterateeCustom<T, boolean>, fromIndex?: number): T[keyof T];
findLast<T, S extends T>(collection: ArrayLike<T>, predicate: lo.ListIteratorTypeGuard<T, S>, fromIndex?: number): S;
findLast<T>(collection: ArrayLike<T>, predicate?: lo.ListIterateeCustom<T, boolean>, fromIndex?: number): T;
findLast<T extends object, S extends T[keyof T]>(collection: T, predicate: lo.ObjectIteratorTypeGuard<T, S>, fromIndex?: number): S;
findLast<T extends object>(collection: T, predicate?: lo.ObjectIterateeCustom<T, boolean>, fromIndex?: number): T[keyof T];
flatMap<T>(collection: lo.Dictionary<lo.Many<T>> | lo.NumericDictionary<lo.Many<T>>): T[];
filter<T_99, S extends T_99>(collection: lo.List<T_99>, predicate: lo.ListIteratorTypeGuard<T_99, S>): S[];
filter<T_100>(collection: lo.List<T_100>, predicate?: lo.ListIterateeCustom<T_100, boolean>): T_100[];
filter<T_101 extends object, S_1 extends T_101[keyof T_101]>(collection: T_101, predicate: lo.ObjectIteratorTypeGuard<T_101, S_1>): S_1[];
filter<T_102 extends object>(collection: T_102, predicate?: lo.ObjectIterateeCustom<T_102, boolean>): T_102[keyof T_102][];
find<T_103, S_2 extends T_103>(collection: lo.List<T_103>, predicate: lo.ListIteratorTypeGuard<T_103, S_2>, fromIndex?: number): S_2;
find<T_104>(collection: lo.List<T_104>, predicate?: lo.ListIterateeCustom<T_104, boolean>, fromIndex?: number): T_104;
find<T_105 extends object, S_3 extends T_105[keyof T_105]>(collection: T_105, predicate: lo.ObjectIteratorTypeGuard<T_105, S_3>, fromIndex?: number): S_3;
find<T_106 extends object>(collection: T_106, predicate?: lo.ObjectIterateeCustom<T_106, boolean>, fromIndex?: number): T_106[keyof T_106];
findLast<T_107, S_4 extends T_107>(collection: lo.List<T_107>, predicate: lo.ListIteratorTypeGuard<T_107, S_4>, fromIndex?: number): S_4;
findLast<T_108>(collection: lo.List<T_108>, predicate?: lo.ListIterateeCustom<T_108, boolean>, fromIndex?: number): T_108;
findLast<T_109 extends object, S_5 extends T_109[keyof T_109]>(collection: T_109, predicate: lo.ObjectIteratorTypeGuard<T_109, S_5>, fromIndex?: number): S_5;
findLast<T_110 extends object>(collection: T_110, predicate?: lo.ObjectIterateeCustom<T_110, boolean>, fromIndex?: number): T_110[keyof T_110];
flatMap<T_111>(collection: lo.Dictionary<lo.Many<T_111>> | lo.NumericDictionary<lo.Many<T_111>>): T_111[];
flatMap(collection: object): any[];
flatMap<T, TResult>(collection: ArrayLike<T>, iteratee: lo.ListIterator<T, lo.Many<TResult>>): TResult[];
flatMap<T extends object, TResult>(collection: T, iteratee: lo.ObjectIterator<T, lo.Many<TResult>>): TResult[];
flatMap<T_112, TResult_7>(collection: lo.List<T_112>, iteratee: lo.ListIterator<T_112, lo.Many<TResult_7>>): TResult_7[];
flatMap<T_113 extends object, TResult_8>(collection: T_113, iteratee: lo.ObjectIterator<T_113, lo.Many<TResult_8>>): TResult_8[];
flatMap(collection: object, iteratee: string): any[];
flatMap(collection: object, iteratee: object): boolean[];
flatMapDeep<T>(collection: lo.Dictionary<T | lo.ListOfRecursiveArraysOrValues<T>> | lo.NumericDictionary<T | lo.ListOfRecursiveArraysOrValues<T>>): T[];
flatMapDeep<T, TResult>(collection: ArrayLike<T>, iteratee: lo.ListIterator<T, TResult | lo.ListOfRecursiveArraysOrValues<TResult>>): TResult[];
flatMapDeep<T extends object, TResult>(collection: T, iteratee: lo.ObjectIterator<T, TResult | lo.ListOfRecursiveArraysOrValues<TResult>>): TResult[];
flatMapDeep<T_114>(collection: lo.Dictionary<T_114 | lo.ListOfRecursiveArraysOrValues<T_114>> | lo.NumericDictionary<T_114 | lo.ListOfRecursiveArraysOrValues<T_114>>): T_114[];
flatMapDeep<T_115, TResult_9>(collection: lo.List<T_115>, iteratee: lo.ListIterator<T_115, TResult_9 | lo.ListOfRecursiveArraysOrValues<TResult_9>>): TResult_9[];
flatMapDeep<T_116 extends object, TResult_10>(collection: T_116, iteratee: lo.ObjectIterator<T_116, TResult_10 | lo.ListOfRecursiveArraysOrValues<TResult_10>>): TResult_10[];
flatMapDeep(collection: object, iteratee: string): any[];
flatMapDeep(collection: object, iteratee: object): boolean[];
flatMapDepth<T>(collection: lo.Dictionary<T | lo.ListOfRecursiveArraysOrValues<T>> | lo.NumericDictionary<T | lo.ListOfRecursiveArraysOrValues<T>>): T[];
flatMapDepth<T, TResult>(collection: ArrayLike<T>, iteratee: lo.ListIterator<T, TResult | lo.ListOfRecursiveArraysOrValues<TResult>>, depth?: number): TResult[];
flatMapDepth<T extends object, TResult>(collection: T, iteratee: lo.ObjectIterator<T, TResult | lo.ListOfRecursiveArraysOrValues<TResult>>, depth?: number): TResult[];
flatMapDepth<T_117>(collection: lo.Dictionary<T_117 | lo.ListOfRecursiveArraysOrValues<T_117>> | lo.NumericDictionary<T_117 | lo.ListOfRecursiveArraysOrValues<T_117>>): T_117[];
flatMapDepth<T_118, TResult_11>(collection: lo.List<T_118>, iteratee: lo.ListIterator<T_118, TResult_11 | lo.ListOfRecursiveArraysOrValues<TResult_11>>, depth?: number): TResult_11[];
flatMapDepth<T_119 extends object, TResult_12>(collection: T_119, iteratee: lo.ObjectIterator<T_119, TResult_12 | lo.ListOfRecursiveArraysOrValues<TResult_12>>, depth?: number): TResult_12[];
flatMapDepth(collection: object, iteratee: string, depth?: number): any[];
flatMapDepth(collection: object, iteratee: object, depth?: number): boolean[];
forEach<T>(collection: T[], iteratee?: lo.ArrayIterator<T, any>): T[];
forEach<T_85>(collection: T_85[], iteratee?: lo.ArrayIterator<T_85, any>): T_85[];
forEach(collection: string, iteratee?: lo.StringIterator<any>): string;
forEach<T>(collection: ArrayLike<T>, iteratee?: lo.ListIterator<T, any>): ArrayLike<T>;
forEach<T extends object>(collection: T, iteratee?: lo.ObjectIterator<T, any>): T;
forEach<T, TArray extends T[]>(collection: TArray & T[], iteratee?: lo.ArrayIterator<T, any>): TArray;
forEach<T_86>(collection: lo.List<T_86>, iteratee?: lo.ListIterator<T_86, any>): lo.List<T_86>;
forEach<T_87 extends object>(collection: T_87, iteratee?: lo.ObjectIterator<T_87, any>): T_87;
forEach<T_88, TArray extends T_88[]>(collection: TArray & T_88[], iteratee?: lo.ArrayIterator<T_88, any>): TArray;
forEach<TString extends string>(collection: TString, iteratee?: lo.StringIterator<any>): TString;
forEach<T, TList extends ArrayLike<T>>(collection: TList & ArrayLike<T>, iteratee?: lo.ListIterator<T, any>): TList;
forEach<T extends object>(collection: T, iteratee?: lo.ObjectIterator<T, any>): T;
forEachRight<T>(collection: T[], iteratee?: lo.ArrayIterator<T, any>): T[];
forEach<T_89, TList_1 extends lo.List<T_89>>(collection: TList_1 & lo.List<T_89>, iteratee?: lo.ListIterator<T_89, any>): TList_1;
forEach<T_90 extends object>(collection: T_90, iteratee?: lo.ObjectIterator<T_90, any>): T_90;
forEachRight<T_91>(collection: T_91[], iteratee?: lo.ArrayIterator<T_91, any>): T_91[];
forEachRight(collection: string, iteratee?: lo.StringIterator<any>): string;
forEachRight<T>(collection: ArrayLike<T>, iteratee?: lo.ListIterator<T, any>): ArrayLike<T>;
forEachRight<T extends object>(collection: T, iteratee?: lo.ObjectIterator<T, any>): T;
forEachRight<T, TArray extends T[]>(collection: TArray & T[], iteratee?: lo.ArrayIterator<T, any>): TArray;
forEachRight<TString extends string>(collection: TString, iteratee?: lo.StringIterator<any>): TString;
forEachRight<T, TList extends ArrayLike<T>>(collection: TList & ArrayLike<T>, iteratee?: lo.ListIterator<T, any>): TList;
forEachRight<T extends object>(collection: T, iteratee?: lo.ObjectIterator<T, any>): T;
groupBy<T>(collection: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): lo.Dictionary<T[]>;
groupBy<T extends object>(collection: T, iteratee?: lo.ValueIteratee<T[keyof T]>): lo.Dictionary<T[keyof T][]>;
includes<T>(collection: lo.Dictionary<T> | lo.NumericDictionary<T>, target: T, fromIndex?: number): boolean;
forEachRight<T_92>(collection: lo.List<T_92>, iteratee?: lo.ListIterator<T_92, any>): lo.List<T_92>;
forEachRight<T_93 extends object>(collection: T_93, iteratee?: lo.ObjectIterator<T_93, any>): T_93;
forEachRight<T_94, TArray_1 extends T_94[]>(collection: TArray_1 & T_94[], iteratee?: lo.ArrayIterator<T_94, any>): TArray_1;
forEachRight<TString_1 extends string>(collection: TString_1, iteratee?: lo.StringIterator<any>): TString_1;
forEachRight<T_95, TList_2 extends lo.List<T_95>>(collection: TList_2 & lo.List<T_95>, iteratee?: lo.ListIterator<T_95, any>): TList_2;
forEachRight<T_96 extends object>(collection: T_96, iteratee?: lo.ObjectIterator<T_96, any>): T_96;
groupBy<T_120>(collection: lo.List<T_120>, iteratee?: lo.ValueIteratee<T_120>): lo.Dictionary<T_120[]>;
groupBy<T_121 extends object>(collection: T_121, iteratee?: lo.ValueIteratee<T_121[keyof T_121]>): lo.Dictionary<T_121[keyof T_121][]>;
includes<T_122>(collection: lo.Dictionary<T_122> | lo.NumericDictionary<T_122>, target: T_122, fromIndex?: number): boolean;
invokeMap(collection: object, methodName: string, ...args: any[]): any[];
invokeMap<TResult>(collection: object, method: (...args: any[]) => TResult, ...args: any[]): TResult[];
keyBy<T>(collection: ArrayLike<T>, iteratee?: lo.ValueIterateeCustom<T, string | number | symbol>): lo.Dictionary<T>;
keyBy<T extends object>(collection: T, iteratee?: lo.ValueIterateeCustom<T[keyof T], string | number | symbol>): lo.Dictionary<T[keyof T]>;
map<T, TResult>(collection: T[], iteratee: lo.ArrayIterator<T, TResult>): TResult[];
map<T, TResult>(collection: ArrayLike<T>, iteratee: lo.ListIterator<T, TResult>): TResult[];
map<T>(collection: lo.Dictionary<T> | lo.NumericDictionary<T>): T[];
map<T extends object, TResult>(collection: T, iteratee: lo.ObjectIterator<T, TResult>): TResult[];
map<T, K extends keyof T>(collection: lo.Dictionary<T> | lo.NumericDictionary<T>, iteratee: K): T[K][];
map<T>(collection: lo.Dictionary<T> | lo.NumericDictionary<T>, iteratee?: string): any[];
map<T>(collection: lo.Dictionary<T> | lo.NumericDictionary<T>, iteratee?: object): boolean[];
orderBy<T>(collection: ArrayLike<T>, iteratees?: lo.Many<lo.ListIterator<T, unknown>>, orders?: lo.Many<boolean | "asc" | "desc">): T[];
orderBy<T>(collection: ArrayLike<T>, iteratees?: lo.Many<lo.ListIteratee<T>>, orders?: lo.Many<boolean | "asc" | "desc">): T[];
orderBy<T extends object>(collection: T, iteratees?: lo.Many<lo.ObjectIterator<T, unknown>>, orders?: lo.Many<boolean | "asc" | "desc">): T[keyof T][];
orderBy<T extends object>(collection: T, iteratees?: lo.Many<lo.ObjectIteratee<T>>, orders?: lo.Many<boolean | "asc" | "desc">): T[keyof T][];
partition<T, U extends T>(collection: ArrayLike<T>, callback: lo.ValueIteratorTypeGuard<T, U>): [U[], Exclude<T, U>[]];
partition<T>(collection: ArrayLike<T>, callback: lo.ValueIteratee<T>): [T[], T[]];
partition<T extends object>(collection: T, callback: lo.ValueIteratee<T[keyof T]>): [T[keyof T][], T[keyof T][]];
reduce<T, TResult>(collection: T[], callback: lo.MemoListIterator<T, TResult, T[]>, accumulator: TResult): TResult;
reduce<T, TResult>(collection: ArrayLike<T>, callback: lo.MemoListIterator<T, TResult, ArrayLike<T>>, accumulator: TResult): TResult;
reduce<T extends object, TResult>(collection: T, callback: lo.MemoObjectIterator<T[keyof T], TResult, T>, accumulator: TResult): TResult;
reduce<T>(collection: T[], callback: lo.MemoListIterator<T, T, T[]>): T;
reduce<T>(collection: ArrayLike<T>, callback: lo.MemoListIterator<T, T, ArrayLike<T>>): T;
reduce<T extends object>(collection: T, callback: lo.MemoObjectIterator<T[keyof T], T[keyof T], T>): T[keyof T];
reduceRight<T, TResult>(collection: T[], callback: lo.MemoListIterator<T, TResult, T[]>, accumulator: TResult): TResult;
reduceRight<T, TResult>(collection: ArrayLike<T>, callback: lo.MemoListIterator<T, TResult, ArrayLike<T>>, accumulator: TResult): TResult;
reduceRight<T extends object, TResult>(collection: T, callback: lo.MemoObjectIterator<T[keyof T], TResult, T>, accumulator: TResult): TResult;
reduceRight<T>(collection: T[], callback: lo.MemoListIterator<T, T, T[]>): T;
reduceRight<T>(collection: ArrayLike<T>, callback: lo.MemoListIterator<T, T, ArrayLike<T>>): T;
reduceRight<T extends object>(collection: T, callback: lo.MemoObjectIterator<T[keyof T], T[keyof T], T>): T[keyof T];
invokeMap<TResult_13>(collection: object, method: (...args: any[]) => TResult_13, ...args: any[]): TResult_13[];
keyBy<T_123>(collection: lo.List<T_123>, iteratee?: lo.ValueIterateeCustom<T_123, string | number | symbol>): lo.Dictionary<T_123>;
keyBy<T_124 extends object>(collection: T_124, iteratee?: lo.ValueIterateeCustom<T_124[keyof T_124], string | number | symbol>): lo.Dictionary<T_124[keyof T_124]>;
map<T_125, TResult_14>(collection: T_125[], iteratee: lo.ArrayIterator<T_125, TResult_14>): TResult_14[];
map<T_126, TResult_15>(collection: lo.List<T_126>, iteratee: lo.ListIterator<T_126, TResult_15>): TResult_15[];
map<T_127>(collection: lo.Dictionary<T_127> | lo.NumericDictionary<T_127>): T_127[];
map<T_128 extends object, TResult_16>(collection: T_128, iteratee: lo.ObjectIterator<T_128, TResult_16>): TResult_16[];
map<T_129, K extends keyof T_129>(collection: lo.Dictionary<T_129> | lo.NumericDictionary<T_129>, iteratee: K): T_129[K][];
map<T_130>(collection: lo.Dictionary<T_130> | lo.NumericDictionary<T_130>, iteratee?: string): any[];
map<T_131>(collection: lo.Dictionary<T_131> | lo.NumericDictionary<T_131>, iteratee?: object): boolean[];
orderBy<T_132>(collection: lo.List<T_132>, iteratees?: lo.Many<lo.ListIterator<T_132, unknown>>, orders?: lo.Many<boolean | "asc" | "desc">): T_132[];
orderBy<T_133>(collection: lo.List<T_133>, iteratees?: lo.Many<lo.ListIteratee<T_133>>, orders?: lo.Many<boolean | "asc" | "desc">): T_133[];
orderBy<T_134 extends object>(collection: T_134, iteratees?: lo.Many<lo.ObjectIterator<T_134, unknown>>, orders?: lo.Many<boolean | "asc" | "desc">): T_134[keyof T_134][];
orderBy<T_135 extends object>(collection: T_135, iteratees?: lo.Many<lo.ObjectIteratee<T_135>>, orders?: lo.Many<boolean | "asc" | "desc">): T_135[keyof T_135][];
partition<T_136, U_2 extends T_136>(collection: lo.List<T_136>, callback: lo.ValueIteratorTypeGuard<T_136, U_2>): [U_2[], Exclude<T_136, U_2>[]];
partition<T_137>(collection: lo.List<T_137>, callback: lo.ValueIteratee<T_137>): [T_137[], T_137[]];
partition<T_138 extends object>(collection: T_138, callback: lo.ValueIteratee<T_138[keyof T_138]>): [T_138[keyof T_138][], T_138[keyof T_138][]];
reduce<T_139, TResult_17>(collection: T_139[], callback: lo.MemoListIterator<T_139, TResult_17, T_139[]>, accumulator: TResult_17): TResult_17;
reduce<T_140, TResult_18>(collection: lo.List<T_140>, callback: lo.MemoListIterator<T_140, TResult_18, lo.List<T_140>>, accumulator: TResult_18): TResult_18;
reduce<T_141 extends object, TResult_19>(collection: T_141, callback: lo.MemoObjectIterator<T_141[keyof T_141], TResult_19, T_141>, accumulator: TResult_19): TResult_19;
reduce<T_142>(collection: T_142[], callback: lo.MemoListIterator<T_142, T_142, T_142[]>): T_142;
reduce<T_143>(collection: lo.List<T_143>, callback: lo.MemoListIterator<T_143, T_143, lo.List<T_143>>): T_143;
reduce<T_144 extends object>(collection: T_144, callback: lo.MemoObjectIterator<T_144[keyof T_144], T_144[keyof T_144], T_144>): T_144[keyof T_144];
reduceRight<T_145, TResult_20>(collection: T_145[], callback: lo.MemoListIterator<T_145, TResult_20, T_145[]>, accumulator: TResult_20): TResult_20;
reduceRight<T_146, TResult_21>(collection: lo.List<T_146>, callback: lo.MemoListIterator<T_146, TResult_21, lo.List<T_146>>, accumulator: TResult_21): TResult_21;
reduceRight<T_147 extends object, TResult_22>(collection: T_147, callback: lo.MemoObjectIterator<T_147[keyof T_147], TResult_22, T_147>, accumulator: TResult_22): TResult_22;
reduceRight<T_148>(collection: T_148[], callback: lo.MemoListIterator<T_148, T_148, T_148[]>): T_148;
reduceRight<T_149>(collection: lo.List<T_149>, callback: lo.MemoListIterator<T_149, T_149, lo.List<T_149>>): T_149;
reduceRight<T_150 extends object>(collection: T_150, callback: lo.MemoObjectIterator<T_150[keyof T_150], T_150[keyof T_150], T_150>): T_150[keyof T_150];
reject(collection: string, predicate?: lo.StringIterator<boolean>): string[];
reject<T>(collection: ArrayLike<T>, predicate?: lo.ListIterateeCustom<T, boolean>): T[];
reject<T extends object>(collection: T, predicate?: lo.ObjectIterateeCustom<T, boolean>): T[keyof T][];
sample<T>(collection: lo.Dictionary<T> | lo.NumericDictionary<T>): T;
sample<T extends object>(collection: T): T[keyof T];
sampleSize<T>(collection: lo.Dictionary<T> | lo.NumericDictionary<T>, n?: number): T[];
sampleSize<T extends object>(collection: T, n?: number): T[keyof T][];
shuffle<T>(collection: ArrayLike<T>): T[];
shuffle<T extends object>(collection: T): T[keyof T][];
reject<T_151>(collection: lo.List<T_151>, predicate?: lo.ListIterateeCustom<T_151, boolean>): T_151[];
reject<T_152 extends object>(collection: T_152, predicate?: lo.ObjectIterateeCustom<T_152, boolean>): T_152[keyof T_152][];
sample<T_153>(collection: lo.Dictionary<T_153> | lo.NumericDictionary<T_153>): T_153;
sample<T_154 extends object>(collection: T_154): T_154[keyof T_154];
sampleSize<T_155>(collection: lo.Dictionary<T_155> | lo.NumericDictionary<T_155>, n?: number): T_155[];
sampleSize<T_156 extends object>(collection: T_156, n?: number): T_156[keyof T_156][];
shuffle<T_157>(collection: lo.List<T_157>): T_157[];
shuffle<T_158 extends object>(collection: T_158): T_158[keyof T_158][];
size(collection: string | object): number;
some<T>(collection: ArrayLike<T>, predicate?: lo.ListIterateeCustom<T, boolean>): boolean;
some<T extends object>(collection: T, predicate?: lo.ObjectIterateeCustom<T, boolean>): boolean;
sortBy<T>(collection: ArrayLike<T>, ...iteratees: lo.Many<lo.ListIteratee<T>>[]): T[];
sortBy<T extends object>(collection: T, ...iteratees: lo.Many<lo.ObjectIteratee<T>>[]): T[keyof T][];
some<T_159>(collection: lo.List<T_159>, predicate?: lo.ListIterateeCustom<T_159, boolean>): boolean;
some<T_160 extends object>(collection: T_160, predicate?: lo.ObjectIterateeCustom<T_160, boolean>): boolean;
sortBy<T_161>(collection: lo.List<T_161>, ...iteratees: lo.Many<lo.ListIteratee<T_161>>[]): T_161[];
sortBy<T_162 extends object>(collection: T_162, ...iteratees: lo.Many<lo.ObjectIteratee<T_162>>[]): T_162[keyof T_162][];
now(): number;
after<TFunc extends (...args: any[]) => any>(n: number, func: TFunc): TFunc;
ary(func: (...args: any[]) => any, n?: number): (...args: any[]) => any;
before<TFunc extends (...args: any[]) => any>(n: number, func: TFunc): TFunc;
before<TFunc_1 extends (...args: any[]) => any>(n: number, func: TFunc_1): TFunc_1;
bind: lo.FunctionBind;

@@ -275,12 +275,12 @@ bindKey: lo.FunctionBindKey;

curryRight: lo.CurryRight;
debounce<T extends (...args: any) => any>(func: T, wait?: number, options?: lo.DebounceSettings): T & lo.Cancelable;
debounce<T_163 extends (...args: any) => any>(func: T_163, wait?: number, options?: lo.DebounceSettings): T_163 & lo.Cancelable;
defer(func: (...args: any[]) => any, ...args: any[]): number;
delay(func: (...args: any[]) => any, wait: number, ...args: any[]): number;
flip<T extends (...args: any) => any>(func: T): T;
flip<T_164 extends (...args: any) => any>(func: T_164): T_164;
memoize: {
<T extends (...args: any) => any>(func: T, resolver?: (...args: any[]) => any): T & lo.MemoizedFunction;
<T_165 extends (...args: any) => any>(func: T_165, resolver?: (...args: any[]) => any): T_165 & lo.MemoizedFunction;
Cache: lo.MapCacheConstructor;
};
negate<T extends any[]>(predicate: (...args: T) => any): (...args: T) => boolean;
once<T extends (...args: any) => any>(func: T): T;
negate<T_166 extends any[]>(predicate: (...args: T_166) => boolean): (...args: T_166) => boolean;
once<T_167 extends (...args: any) => any>(func: T_167): T_167;
overArgs(func: (...args: any[]) => any, ...transforms: lo.Many<(...args: any[]) => any>[]): (...args: any[]) => any;

@@ -291,15 +291,15 @@ partial: lo.Partial;

rest(func: (...args: any[]) => any, start?: number): (...args: any[]) => any;
spread<TResult>(func: (...args: any[]) => TResult, start?: number): (...args: any[]) => TResult;
throttle<T extends (...args: any) => any>(func: T, wait?: number, options?: lo.ThrottleSettings): T & lo.Cancelable;
unary<T, TResult>(func: (arg1: T, ...args: any[]) => TResult): (arg1: T) => TResult;
wrap<T, TArgs, TResult>(value: T, wrapper: (value: T, ...args: TArgs[]) => TResult): (...args: TArgs[]) => TResult;
castArray<T>(value?: lo.Many<T>): T[];
clone<T>(value: T): T;
cloneDeep<T>(value: T): T;
cloneDeepWith<T>(value: T, customizer: lo.CloneDeepWithCustomizer<T>): any;
cloneDeepWith<T>(value: T): T;
cloneWith<T, TResult extends string | number | boolean | object>(value: T, customizer: lo.CloneWithCustomizer<T, TResult>): TResult;
cloneWith<T, TResult>(value: T, customizer: lo.CloneWithCustomizer<T, TResult>): T | TResult;
cloneWith<T>(value: T): T;
conformsTo<T>(object: T, source: lo.ConformsPredicateObject<T>): boolean;
spread<TResult_23>(func: (...args: any[]) => TResult_23, start?: number): (...args: any[]) => TResult_23;
throttle<T_168 extends (...args: any) => any>(func: T_168, wait?: number, options?: lo.ThrottleSettings): T_168 & lo.Cancelable;
unary<T_169, TResult_24>(func: (arg1: T_169, ...args: any[]) => TResult_24): (arg1: T_169) => TResult_24;
wrap<T_170, TArgs, TResult_25>(value: T_170, wrapper: (value: T_170, ...args: TArgs[]) => TResult_25): (...args: TArgs[]) => TResult_25;
castArray<T_171>(value?: lo.Many<T_171>): T_171[];
clone<T_172>(value: T_172): T_172;
cloneDeep<T_173>(value: T_173): T_173;
cloneDeepWith<T_174>(value: T_174, customizer: lo.CloneDeepWithCustomizer<T_174>): any;
cloneDeepWith<T_175>(value: T_175): T_175;
cloneWith<T_176, TResult_26 extends string | number | boolean | object>(value: T_176, customizer: lo.CloneWithCustomizer<T_176, TResult_26>): TResult_26;
cloneWith<T_177, TResult_27>(value: T_177, customizer: lo.CloneWithCustomizer<T_177, TResult_27>): T_177 | TResult_27;
cloneWith<T_178>(value: T_178): T_178;
conformsTo<T_179>(object: T_179, source: lo.ConformsPredicateObject<T_179>): boolean;
eq(value: any, other: any): boolean;

@@ -310,7 +310,7 @@ gt(value: any, other: any): boolean;

isArray(value?: any): value is any[];
isArray<T>(value?: any): value is any[];
isArray<T_180>(value?: any): value is any[];
isArrayBuffer(value?: any): value is ArrayBuffer;
isArrayLike<T extends {
isArrayLike<T_181 extends {
__lodashAnyHack: any;
}>(t: T): boolean;
}>(t: T_181): boolean;
isArrayLike(value: (...args: any[]) => any): value is never;

@@ -320,5 +320,5 @@ isArrayLike(value: any): value is {

};
isArrayLikeObject<T extends {
isArrayLikeObject<T_182 extends {
__lodashAnyHack: any;
}>(value: T): boolean;
}>(value: T_182): boolean;
isArrayLikeObject(value: string | number | boolean | Function | ((...args: any[]) => any)): value is never;

@@ -362,4 +362,4 @@ isArrayLikeObject(value: any): value is object & {

lte(value: any, other: any): boolean;
toArray<T>(value: lo.Dictionary<T> | lo.NumericDictionary<T>): T[];
toArray<T>(value: T): T[keyof T][];
toArray<T_183>(value: lo.Dictionary<T_183> | lo.NumericDictionary<T_183>): T_183[];
toArray<T_184>(value: T_184): T_184[keyof T_184][];
toArray(): any[];

@@ -377,13 +377,13 @@ toFinite(value: any): number;

floor(n: number, precision?: number): number;
max<T>(collection: ArrayLike<T>): T;
maxBy<T>(collection: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): T;
mean(collection: ArrayLike<any>): number;
meanBy<T>(collection: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): number;
min<T>(collection: ArrayLike<T>): T;
minBy<T>(collection: ArrayLike<T>, iteratee?: lo.ValueIteratee<T>): T;
max<T_185>(collection: lo.List<T_185>): T_185;
maxBy<T_186>(collection: lo.List<T_186>, iteratee?: lo.ValueIteratee<T_186>): T_186;
mean(collection: lo.List<any>): number;
meanBy<T_187>(collection: lo.List<T_187>, iteratee?: lo.ValueIteratee<T_187>): number;
min<T_188>(collection: lo.List<T_188>): T_188;
minBy<T_189>(collection: lo.List<T_189>, iteratee?: lo.ValueIteratee<T_189>): T_189;
multiply(multiplier: number, multiplicand: number): number;
round(n: number, precision?: number): number;
subtract(minuend: number, subtrahend: number): number;
sum(collection: ArrayLike<any>): number;
sumBy<T>(collection: ArrayLike<T>, iteratee?: string | ((value: T) => number)): number;
sum(collection: lo.List<any>): number;
sumBy<T_190>(collection: lo.List<T_190>, iteratee?: string | ((value: T_190) => number)): number;
clamp(number: number, lower: number, upper: number): number;

@@ -397,135 +397,135 @@ clamp(number: number, upper: number): number;

assign<TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
assign<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
assign<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
assign<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4;
assign<TObject>(object: TObject): TObject;
assign<TObject_1, TSource1, TSource2>(object: TObject_1, source1: TSource1, source2: TSource2): TObject_1 & TSource1 & TSource2;
assign<TObject_2, TSource1_1, TSource2_1, TSource3>(object: TObject_2, source1: TSource1_1, source2: TSource2_1, source3: TSource3): TObject_2 & TSource1_1 & TSource2_1 & TSource3;
assign<TObject_3, TSource1_2, TSource2_2, TSource3_1, TSource4>(object: TObject_3, source1: TSource1_2, source2: TSource2_2, source3: TSource3_1, source4: TSource4): TObject_3 & TSource1_2 & TSource2_2 & TSource3_1 & TSource4;
assign<TObject_4>(object: TObject_4): TObject_4;
assign(object: any, ...otherArgs: any[]): any;
assignIn<TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
assignIn<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
assignIn<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
assignIn<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4;
assignIn<TObject>(object: TObject): TObject;
assignIn<TResult>(object: any, ...otherArgs: any[]): TResult;
assignInWith<TObject, TSource>(object: TObject, source: TSource, customizer: lo.AssignCustomizer): TObject & TSource;
assignInWith<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2, customizer: lo.AssignCustomizer): TObject & TSource1 & TSource2;
assignInWith<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: lo.AssignCustomizer): TObject & TSource1 & TSource2 & TSource3;
assignInWith<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: lo.AssignCustomizer): TObject & TSource1 & TSource2 & TSource3 & TSource4;
assignInWith<TObject>(object: TObject): TObject;
assignInWith<TResult>(object: any, ...otherArgs: any[]): TResult;
assignWith<TObject, TSource>(object: TObject, source: TSource, customizer: lo.AssignCustomizer): TObject & TSource;
assignWith<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2, customizer: lo.AssignCustomizer): TObject & TSource1 & TSource2;
assignWith<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: lo.AssignCustomizer): TObject & TSource1 & TSource2 & TSource3;
assignWith<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: lo.AssignCustomizer): TObject & TSource1 & TSource2 & TSource3 & TSource4;
assignWith<TObject>(object: TObject): TObject;
assignWith<TResult>(object: any, ...otherArgs: any[]): TResult;
at<T>(object: lo.Dictionary<T> | lo.NumericDictionary<T>, ...props: lo.Many<string | number | symbol>[]): T[];
at<T extends object>(object: T, ...props: lo.Many<keyof T>[]): T[keyof T][];
create<T extends object, U extends object>(prototype: T, properties?: U): T & U;
defaults<TObject, TSource>(object: TObject, source: TSource): TSource & TObject;
defaults<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TSource2 & TSource1 & TObject;
defaults<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TSource3 & TSource2 & TSource1 & TObject;
defaults<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TSource4 & TSource3 & TSource2 & TSource1 & TObject;
defaults<TObject>(object: TObject): TObject;
assignIn<TObject_5, TSource_1>(object: TObject_5, source: TSource_1): TObject_5 & TSource_1;
assignIn<TObject_6, TSource1_3, TSource2_3>(object: TObject_6, source1: TSource1_3, source2: TSource2_3): TObject_6 & TSource1_3 & TSource2_3;
assignIn<TObject_7, TSource1_4, TSource2_4, TSource3_2>(object: TObject_7, source1: TSource1_4, source2: TSource2_4, source3: TSource3_2): TObject_7 & TSource1_4 & TSource2_4 & TSource3_2;
assignIn<TObject_8, TSource1_5, TSource2_5, TSource3_3, TSource4_1>(object: TObject_8, source1: TSource1_5, source2: TSource2_5, source3: TSource3_3, source4: TSource4_1): TObject_8 & TSource1_5 & TSource2_5 & TSource3_3 & TSource4_1;
assignIn<TObject_9>(object: TObject_9): TObject_9;
assignIn<TResult_28>(object: any, ...otherArgs: any[]): TResult_28;
assignInWith<TObject_10, TSource_2>(object: TObject_10, source: TSource_2, customizer: lo.AssignCustomizer): TObject_10 & TSource_2;
assignInWith<TObject_11, TSource1_6, TSource2_6>(object: TObject_11, source1: TSource1_6, source2: TSource2_6, customizer: lo.AssignCustomizer): TObject_11 & TSource1_6 & TSource2_6;
assignInWith<TObject_12, TSource1_7, TSource2_7, TSource3_4>(object: TObject_12, source1: TSource1_7, source2: TSource2_7, source3: TSource3_4, customizer: lo.AssignCustomizer): TObject_12 & TSource1_7 & TSource2_7 & TSource3_4;
assignInWith<TObject_13, TSource1_8, TSource2_8, TSource3_5, TSource4_2>(object: TObject_13, source1: TSource1_8, source2: TSource2_8, source3: TSource3_5, source4: TSource4_2, customizer: lo.AssignCustomizer): TObject_13 & TSource1_8 & TSource2_8 & TSource3_5 & TSource4_2;
assignInWith<TObject_14>(object: TObject_14): TObject_14;
assignInWith<TResult_29>(object: any, ...otherArgs: any[]): TResult_29;
assignWith<TObject_15, TSource_3>(object: TObject_15, source: TSource_3, customizer: lo.AssignCustomizer): TObject_15 & TSource_3;
assignWith<TObject_16, TSource1_9, TSource2_9>(object: TObject_16, source1: TSource1_9, source2: TSource2_9, customizer: lo.AssignCustomizer): TObject_16 & TSource1_9 & TSource2_9;
assignWith<TObject_17, TSource1_10, TSource2_10, TSource3_6>(object: TObject_17, source1: TSource1_10, source2: TSource2_10, source3: TSource3_6, customizer: lo.AssignCustomizer): TObject_17 & TSource1_10 & TSource2_10 & TSource3_6;
assignWith<TObject_18, TSource1_11, TSource2_11, TSource3_7, TSource4_3>(object: TObject_18, source1: TSource1_11, source2: TSource2_11, source3: TSource3_7, source4: TSource4_3, customizer: lo.AssignCustomizer): TObject_18 & TSource1_11 & TSource2_11 & TSource3_7 & TSource4_3;
assignWith<TObject_19>(object: TObject_19): TObject_19;
assignWith<TResult_30>(object: any, ...otherArgs: any[]): TResult_30;
at<T_191>(object: lo.Dictionary<T_191> | lo.NumericDictionary<T_191>, ...props: lo.Many<string | number | symbol>[]): T_191[];
at<T_192 extends object>(object: T_192, ...props: lo.Many<keyof T_192>[]): T_192[keyof T_192][];
create<T_193 extends object, U_3 extends object>(prototype: T_193, properties?: U_3): T_193 & U_3;
defaults<TObject_20, TSource_4>(object: TObject_20, source: TSource_4): NonNullable<TSource_4 & TObject_20>;
defaults<TObject_21, TSource1_12, TSource2_12>(object: TObject_21, source1: TSource1_12, source2: TSource2_12): NonNullable<TSource2_12 & TSource1_12 & TObject_21>;
defaults<TObject_22, TSource1_13, TSource2_13, TSource3_8>(object: TObject_22, source1: TSource1_13, source2: TSource2_13, source3: TSource3_8): NonNullable<TSource3_8 & TSource2_13 & TSource1_13 & TObject_22>;
defaults<TObject_23, TSource1_14, TSource2_14, TSource3_9, TSource4_4>(object: TObject_23, source1: TSource1_14, source2: TSource2_14, source3: TSource3_9, source4: TSource4_4): NonNullable<TSource4_4 & TSource3_9 & TSource2_14 & TSource1_14 & TObject_23>;
defaults<TObject_24>(object: TObject_24): NonNullable<TObject_24>;
defaults(object: any, ...sources: any[]): any;
defaultsDeep(object: any, ...sources: any[]): any;
entries<T>(object?: lo.Dictionary<T> | lo.NumericDictionary<T>): [string, T][];
entries<T_194>(object?: lo.Dictionary<T_194> | lo.NumericDictionary<T_194>): [string, T_194][];
entries(object?: object): [string, any][];
entriesIn<T>(object?: lo.Dictionary<T> | lo.NumericDictionary<T>): [string, T][];
entriesIn<T_195>(object?: lo.Dictionary<T_195> | lo.NumericDictionary<T_195>): [string, T_195][];
entriesIn(object?: object): [string, any][];
extend<TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
extend<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
extend<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
extend<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4;
extend<TObject>(object: TObject): TObject;
extend<TResult>(object: any, ...otherArgs: any[]): TResult;
extendWith<TObject, TSource>(object: TObject, source: TSource, customizer: lo.AssignCustomizer): TObject & TSource;
extendWith<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2, customizer: lo.AssignCustomizer): TObject & TSource1 & TSource2;
extendWith<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: lo.AssignCustomizer): TObject & TSource1 & TSource2 & TSource3;
extendWith<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: lo.AssignCustomizer): TObject & TSource1 & TSource2 & TSource3 & TSource4;
extendWith<TObject>(object: TObject): TObject;
extendWith<TResult>(object: any, ...otherArgs: any[]): TResult;
findKey<T>(object: T, predicate?: lo.ObjectIteratee<T>): string;
findLastKey<T>(object: T, predicate?: lo.ObjectIteratee<T>): string;
forIn<T>(object: T, iteratee?: lo.ObjectIterator<T, any>): T;
forIn<T>(object: T, iteratee?: lo.ObjectIterator<T, any>): T;
forInRight<T>(object: T, iteratee?: lo.ObjectIterator<T, any>): T;
forInRight<T>(object: T, iteratee?: lo.ObjectIterator<T, any>): T;
forOwn<T>(object: T, iteratee?: lo.ObjectIterator<T, any>): T;
forOwn<T>(object: T, iteratee?: lo.ObjectIterator<T, any>): T;
forOwnRight<T>(object: T, iteratee?: lo.ObjectIterator<T, any>): T;
forOwnRight<T>(object: T, iteratee?: lo.ObjectIterator<T, any>): T;
extend<TObject_25, TSource_5>(object: TObject_25, source: TSource_5): TObject_25 & TSource_5;
extend<TObject_26, TSource1_15, TSource2_15>(object: TObject_26, source1: TSource1_15, source2: TSource2_15): TObject_26 & TSource1_15 & TSource2_15;
extend<TObject_27, TSource1_16, TSource2_16, TSource3_10>(object: TObject_27, source1: TSource1_16, source2: TSource2_16, source3: TSource3_10): TObject_27 & TSource1_16 & TSource2_16 & TSource3_10;
extend<TObject_28, TSource1_17, TSource2_17, TSource3_11, TSource4_5>(object: TObject_28, source1: TSource1_17, source2: TSource2_17, source3: TSource3_11, source4: TSource4_5): TObject_28 & TSource1_17 & TSource2_17 & TSource3_11 & TSource4_5;
extend<TObject_29>(object: TObject_29): TObject_29;
extend<TResult_31>(object: any, ...otherArgs: any[]): TResult_31;
extendWith<TObject_30, TSource_6>(object: TObject_30, source: TSource_6, customizer: lo.AssignCustomizer): TObject_30 & TSource_6;
extendWith<TObject_31, TSource1_18, TSource2_18>(object: TObject_31, source1: TSource1_18, source2: TSource2_18, customizer: lo.AssignCustomizer): TObject_31 & TSource1_18 & TSource2_18;
extendWith<TObject_32, TSource1_19, TSource2_19, TSource3_12>(object: TObject_32, source1: TSource1_19, source2: TSource2_19, source3: TSource3_12, customizer: lo.AssignCustomizer): TObject_32 & TSource1_19 & TSource2_19 & TSource3_12;
extendWith<TObject_33, TSource1_20, TSource2_20, TSource3_13, TSource4_6>(object: TObject_33, source1: TSource1_20, source2: TSource2_20, source3: TSource3_13, source4: TSource4_6, customizer: lo.AssignCustomizer): TObject_33 & TSource1_20 & TSource2_20 & TSource3_13 & TSource4_6;
extendWith<TObject_34>(object: TObject_34): TObject_34;
extendWith<TResult_32>(object: any, ...otherArgs: any[]): TResult_32;
findKey<T_196>(object: T_196, predicate?: lo.ObjectIteratee<T_196>): string;
findLastKey<T_197>(object: T_197, predicate?: lo.ObjectIteratee<T_197>): string;
forIn<T_198>(object: T_198, iteratee?: lo.ObjectIterator<T_198, any>): T_198;
forIn<T_199>(object: T_199, iteratee?: lo.ObjectIterator<T_199, any>): T_199;
forInRight<T_200>(object: T_200, iteratee?: lo.ObjectIterator<T_200, any>): T_200;
forInRight<T_201>(object: T_201, iteratee?: lo.ObjectIterator<T_201, any>): T_201;
forOwn<T_202>(object: T_202, iteratee?: lo.ObjectIterator<T_202, any>): T_202;
forOwn<T_203>(object: T_203, iteratee?: lo.ObjectIterator<T_203, any>): T_203;
forOwnRight<T_204>(object: T_204, iteratee?: lo.ObjectIterator<T_204, any>): T_204;
forOwnRight<T_205>(object: T_205, iteratee?: lo.ObjectIterator<T_205, any>): T_205;
functions(object: any): string[];
functionsIn<T extends {}>(object: any): string[];
get<TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey | [TKey]): TObject[TKey];
get<TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey | [TKey]): TObject[TKey];
get<TObject extends object, TKey extends keyof TObject, TDefault>(object: TObject, path: TKey | [TKey], defaultValue: TDefault): TDefault | Exclude<TObject[TKey], undefined>;
get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(object: TObject, path: [TKey1, TKey2]): TObject[TKey1][TKey2];
get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(object: TObject, path: [TKey1, TKey2]): TObject[TKey1][TKey2];
get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault>(object: TObject, path: [TKey1, TKey2], defaultValue: TDefault): TDefault | Exclude<TObject[TKey1][TKey2], undefined>;
get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(object: TObject, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3];
get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(object: TObject, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3];
get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault>(object: TObject, path: [TKey1, TKey2, TKey3], defaultValue: TDefault): TDefault | Exclude<TObject[TKey1][TKey2][TKey3], undefined>;
get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(object: TObject, path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4];
get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(object: TObject, path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4];
get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault>(object: TObject, path: [TKey1, TKey2, TKey3, TKey4], defaultValue: TDefault): TDefault | Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined>;
get<T>(object: lo.NumericDictionary<T>, path: number): T;
get<T>(object: lo.NumericDictionary<T>, path: number): T;
get<T, TDefault>(object: lo.NumericDictionary<T>, path: number, defaultValue: TDefault): T | TDefault;
get<TDefault>(object: null, path: lo.Many<string | number | symbol>, defaultValue: TDefault): TDefault;
functionsIn<T_206 extends {}>(object: any): string[];
get<TObject_35 extends object, TKey extends keyof TObject_35>(object: TObject_35, path: TKey | [TKey]): TObject_35[TKey];
get<TObject_36 extends object, TKey_1 extends keyof TObject_36>(object: TObject_36, path: TKey_1 | [TKey_1]): TObject_36[TKey_1];
get<TObject_37 extends object, TKey_2 extends keyof TObject_37, TDefault>(object: TObject_37, path: TKey_2 | [TKey_2], defaultValue: TDefault): TDefault | Exclude<TObject_37[TKey_2], undefined>;
get<TObject_38 extends object, TKey1 extends keyof TObject_38, TKey2 extends keyof TObject_38[TKey1]>(object: TObject_38, path: [TKey1, TKey2]): TObject_38[TKey1][TKey2];
get<TObject_39 extends object, TKey1_1 extends keyof TObject_39, TKey2_1 extends keyof TObject_39[TKey1_1]>(object: TObject_39, path: [TKey1_1, TKey2_1]): TObject_39[TKey1_1][TKey2_1];
get<TObject_40 extends object, TKey1_2 extends keyof TObject_40, TKey2_2 extends keyof TObject_40[TKey1_2], TDefault_1>(object: TObject_40, path: [TKey1_2, TKey2_2], defaultValue: TDefault_1): TDefault_1 | Exclude<TObject_40[TKey1_2][TKey2_2], undefined>;
get<TObject_41 extends object, TKey1_3 extends keyof TObject_41, TKey2_3 extends keyof TObject_41[TKey1_3], TKey3 extends keyof TObject_41[TKey1_3][TKey2_3]>(object: TObject_41, path: [TKey1_3, TKey2_3, TKey3]): TObject_41[TKey1_3][TKey2_3][TKey3];
get<TObject_42 extends object, TKey1_4 extends keyof TObject_42, TKey2_4 extends keyof TObject_42[TKey1_4], TKey3_1 extends keyof TObject_42[TKey1_4][TKey2_4]>(object: TObject_42, path: [TKey1_4, TKey2_4, TKey3_1]): TObject_42[TKey1_4][TKey2_4][TKey3_1];
get<TObject_43 extends object, TKey1_5 extends keyof TObject_43, TKey2_5 extends keyof TObject_43[TKey1_5], TKey3_2 extends keyof TObject_43[TKey1_5][TKey2_5], TDefault_2>(object: TObject_43, path: [TKey1_5, TKey2_5, TKey3_2], defaultValue: TDefault_2): TDefault_2 | Exclude<TObject_43[TKey1_5][TKey2_5][TKey3_2], undefined>;
get<TObject_44 extends object, TKey1_6 extends keyof TObject_44, TKey2_6 extends keyof TObject_44[TKey1_6], TKey3_3 extends keyof TObject_44[TKey1_6][TKey2_6], TKey4 extends keyof TObject_44[TKey1_6][TKey2_6][TKey3_3]>(object: TObject_44, path: [TKey1_6, TKey2_6, TKey3_3, TKey4]): TObject_44[TKey1_6][TKey2_6][TKey3_3][TKey4];
get<TObject_45 extends object, TKey1_7 extends keyof TObject_45, TKey2_7 extends keyof TObject_45[TKey1_7], TKey3_4 extends keyof TObject_45[TKey1_7][TKey2_7], TKey4_1 extends keyof TObject_45[TKey1_7][TKey2_7][TKey3_4]>(object: TObject_45, path: [TKey1_7, TKey2_7, TKey3_4, TKey4_1]): TObject_45[TKey1_7][TKey2_7][TKey3_4][TKey4_1];
get<TObject_46 extends object, TKey1_8 extends keyof TObject_46, TKey2_8 extends keyof TObject_46[TKey1_8], TKey3_5 extends keyof TObject_46[TKey1_8][TKey2_8], TKey4_2 extends keyof TObject_46[TKey1_8][TKey2_8][TKey3_5], TDefault_3>(object: TObject_46, path: [TKey1_8, TKey2_8, TKey3_5, TKey4_2], defaultValue: TDefault_3): TDefault_3 | Exclude<TObject_46[TKey1_8][TKey2_8][TKey3_5][TKey4_2], undefined>;
get<T_207>(object: lo.NumericDictionary<T_207>, path: number): T_207;
get<T_208>(object: lo.NumericDictionary<T_208>, path: number): T_208;
get<T_209, TDefault_4>(object: lo.NumericDictionary<T_209>, path: number, defaultValue: TDefault_4): T_209 | TDefault_4;
get<TDefault_5>(object: null, path: lo.Many<string | number | symbol>, defaultValue: TDefault_5): TDefault_5;
get(object: null, path: lo.Many<string | number | symbol>): undefined;
get(object: any, path: lo.Many<string | number | symbol>, defaultValue?: any): any;
has<T>(object: T, path: lo.Many<string | number | symbol>): boolean;
hasIn<T>(object: T, path: lo.Many<string | number | symbol>): boolean;
has<T_210>(object: T_210, path: lo.Many<string | number | symbol>): boolean;
hasIn<T_211>(object: T_211, path: lo.Many<string | number | symbol>): boolean;
invert(object: object): lo.Dictionary<string>;
invertBy<T>(object: lo.Dictionary<T> | lo.NumericDictionary<T>, interatee?: lo.ValueIteratee<T>): lo.Dictionary<string[]>;
invertBy<T extends object>(object: T, interatee?: lo.ValueIteratee<T[keyof T]>): lo.Dictionary<string[]>;
invertBy<T_212>(object: lo.Dictionary<T_212> | lo.NumericDictionary<T_212>, interatee?: lo.ValueIteratee<T_212>): lo.Dictionary<string[]>;
invertBy<T_213 extends object>(object: T_213, interatee?: lo.ValueIteratee<T_213[keyof T_213]>): lo.Dictionary<string[]>;
invoke(object: any, path: lo.Many<string | number | symbol>, ...args: any[]): any;
keys(object?: any): string[];
keysIn(object?: any): string[];
mapKeys<T>(object: ArrayLike<T>, iteratee?: lo.ListIteratee<T>): lo.Dictionary<T>;
mapKeys<T extends object>(object: T, iteratee?: lo.ObjectIteratee<T>): lo.Dictionary<T[keyof T]>;
mapValues<TResult>(obj: string, callback: lo.StringIterator<TResult>): lo.NumericDictionary<TResult>;
mapValues<T extends object, TResult>(obj: T, callback: lo.ObjectIterator<T, TResult>): { [P in keyof T]: TResult; };
mapValues<T>(obj: lo.Dictionary<T> | lo.NumericDictionary<T>, iteratee: object): lo.Dictionary<boolean>;
mapValues<T extends object>(obj: T, iteratee: object): { [P in keyof T]: boolean; };
mapValues<T, TKey extends keyof T>(obj: lo.Dictionary<T> | lo.NumericDictionary<T>, iteratee: TKey): lo.Dictionary<T[TKey]>;
mapValues<T>(obj: lo.Dictionary<T> | lo.NumericDictionary<T>, iteratee: string): lo.Dictionary<any>;
mapValues<T extends object>(obj: T, iteratee: string): { [P in keyof T]: any; };
mapKeys<T_214>(object: lo.List<T_214>, iteratee?: lo.ListIteratee<T_214>): lo.Dictionary<T_214>;
mapKeys<T_215 extends object>(object: T_215, iteratee?: lo.ObjectIteratee<T_215>): lo.Dictionary<T_215[keyof T_215]>;
mapValues<TResult_33>(obj: string, callback: lo.StringIterator<TResult_33>): lo.NumericDictionary<TResult_33>;
mapValues<T_216 extends object, TResult_34>(obj: T_216, callback: lo.ObjectIterator<T_216, TResult_34>): { [P in keyof T_216]: TResult_34; };
mapValues<T_217>(obj: lo.Dictionary<T_217> | lo.NumericDictionary<T_217>, iteratee: object): lo.Dictionary<boolean>;
mapValues<T_218 extends object>(obj: T_218, iteratee: object): { [P_1 in keyof T_218]: boolean; };
mapValues<T_219, TKey_3 extends keyof T_219>(obj: lo.Dictionary<T_219> | lo.NumericDictionary<T_219>, iteratee: TKey_3): lo.Dictionary<T_219[TKey_3]>;
mapValues<T_220>(obj: lo.Dictionary<T_220> | lo.NumericDictionary<T_220>, iteratee: string): lo.Dictionary<any>;
mapValues<T_221 extends object>(obj: T_221, iteratee: string): { [P_2 in keyof T_221]: any; };
mapValues(obj: string): lo.NumericDictionary<string>;
mapValues<T>(obj: lo.Dictionary<T> | lo.NumericDictionary<T>): lo.Dictionary<T>;
mapValues<T extends object>(obj: T): T;
mapValues<T extends object>(obj: T): Partial<T>;
merge<TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
merge<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
merge<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
merge<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4;
mapValues<T_222>(obj: lo.Dictionary<T_222> | lo.NumericDictionary<T_222>): lo.Dictionary<T_222>;
mapValues<T_223 extends object>(obj: T_223): T_223;
mapValues<T_224 extends object>(obj: T_224): Partial<T_224>;
merge<TObject_47, TSource_7>(object: TObject_47, source: TSource_7): TObject_47 & TSource_7;
merge<TObject_48, TSource1_21, TSource2_21>(object: TObject_48, source1: TSource1_21, source2: TSource2_21): TObject_48 & TSource1_21 & TSource2_21;
merge<TObject_49, TSource1_22, TSource2_22, TSource3_14>(object: TObject_49, source1: TSource1_22, source2: TSource2_22, source3: TSource3_14): TObject_49 & TSource1_22 & TSource2_22 & TSource3_14;
merge<TObject_50, TSource1_23, TSource2_23, TSource3_15, TSource4_7>(object: TObject_50, source1: TSource1_23, source2: TSource2_23, source3: TSource3_15, source4: TSource4_7): TObject_50 & TSource1_23 & TSource2_23 & TSource3_15 & TSource4_7;
merge(object: any, ...otherArgs: any[]): any;
mergeWith<TObject, TSource>(object: TObject, source: TSource, customizer: (value: any, srcValue: any, key: string, object: any, source: any) => any): TObject & TSource;
mergeWith<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2, customizer: (value: any, srcValue: any, key: string, object: any, source: any) => any): TObject & TSource1 & TSource2;
mergeWith<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: (value: any, srcValue: any, key: string, object: any, source: any) => any): TObject & TSource1 & TSource2 & TSource3;
mergeWith<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: (value: any, srcValue: any, key: string, object: any, source: any) => any): TObject & TSource1 & TSource2 & TSource3 & TSource4;
mergeWith<TObject_51, TSource_8>(object: TObject_51, source: TSource_8, customizer: (value: any, srcValue: any, key: string, object: any, source: any) => any): TObject_51 & TSource_8;
mergeWith<TObject_52, TSource1_24, TSource2_24>(object: TObject_52, source1: TSource1_24, source2: TSource2_24, customizer: (value: any, srcValue: any, key: string, object: any, source: any) => any): TObject_52 & TSource1_24 & TSource2_24;
mergeWith<TObject_53, TSource1_25, TSource2_25, TSource3_16>(object: TObject_53, source1: TSource1_25, source2: TSource2_25, source3: TSource3_16, customizer: (value: any, srcValue: any, key: string, object: any, source: any) => any): TObject_53 & TSource1_25 & TSource2_25 & TSource3_16;
mergeWith<TObject_54, TSource1_26, TSource2_26, TSource3_17, TSource4_8>(object: TObject_54, source1: TSource1_26, source2: TSource2_26, source3: TSource3_17, source4: TSource4_8, customizer: (value: any, srcValue: any, key: string, object: any, source: any) => any): TObject_54 & TSource1_26 & TSource2_26 & TSource3_17 & TSource4_8;
mergeWith(object: any, ...otherArgs: any[]): any;
omit<T extends object, K extends keyof T>(object: T, ...paths: lo.Many<K>[]): Pick<T, Exclude<keyof T, K>>;
omit<T extends object>(object: T, ...paths: lo.Many<string | number | symbol>[]): Partial<T>;
omitBy<T>(object: lo.Dictionary<T>, predicate?: lo.ValueKeyIteratee<T>): lo.Dictionary<T>;
omitBy<T>(object: lo.NumericDictionary<T>, predicate?: lo.ValueKeyIteratee<T>): lo.NumericDictionary<T>;
omitBy<T extends object>(object: T, predicate: lo.ValueKeyIteratee<T[keyof T]>): Partial<T>;
pick<T extends object, U extends keyof T>(object: T, ...props: lo.Many<U>[]): Pick<T, U>;
pick<T>(object: T, ...props: lo.Many<string | number | symbol>[]): Partial<T>;
pickBy<T, S extends T>(object: lo.Dictionary<T>, predicate: lo.ValueKeyIterateeTypeGuard<T, S>): lo.Dictionary<S>;
pickBy<T, S extends T>(object: lo.NumericDictionary<T>, predicate: lo.ValueKeyIterateeTypeGuard<T, S>): lo.NumericDictionary<S>;
pickBy<T>(object: lo.Dictionary<T>, predicate?: lo.ValueKeyIteratee<T>): lo.Dictionary<T>;
pickBy<T>(object: lo.NumericDictionary<T>, predicate?: lo.ValueKeyIteratee<T>): lo.NumericDictionary<T>;
pickBy<T extends object>(object: T, predicate?: lo.ValueKeyIteratee<T[keyof T]>): Partial<T>;
result<TResult>(object: any, path: lo.Many<string | number | symbol>, defaultValue?: TResult | ((...args: any[]) => TResult)): TResult;
set<T extends object>(object: T, path: lo.Many<string | number | symbol>, value: any): T;
set<TResult>(object: object, path: lo.Many<string | number | symbol>, value: any): TResult;
setWith<T extends object>(object: T, path: lo.Many<string | number | symbol>, value: any, customizer?: lo.SetWithCustomizer<T>): T;
setWith<T extends object, TResult>(object: T, path: lo.Many<string | number | symbol>, value: any, customizer?: lo.SetWithCustomizer<T>): TResult;
toPairs<T>(object?: lo.Dictionary<T> | lo.NumericDictionary<T>): [string, T][];
omit<T_225 extends object, K_1 extends keyof T_225>(object: T_225, ...paths: lo.Many<K_1>[]): Pick<T_225, Exclude<keyof T_225, K_1>>;
omit<T_226 extends object>(object: T_226, ...paths: lo.Many<string | number | symbol>[]): Partial<T_226>;
omitBy<T_227>(object: lo.Dictionary<T_227>, predicate?: lo.ValueKeyIteratee<T_227>): lo.Dictionary<T_227>;
omitBy<T_228>(object: lo.NumericDictionary<T_228>, predicate?: lo.ValueKeyIteratee<T_228>): lo.NumericDictionary<T_228>;
omitBy<T_229 extends object>(object: T_229, predicate: lo.ValueKeyIteratee<T_229[keyof T_229]>): Partial<T_229>;
pick<T_230 extends object, U_4 extends keyof T_230>(object: T_230, ...props: lo.Many<U_4>[]): Pick<T_230, U_4>;
pick<T_231>(object: T_231, ...props: lo.Many<string | number | symbol>[]): Partial<T_231>;
pickBy<T_232, S_6 extends T_232>(object: lo.Dictionary<T_232>, predicate: lo.ValueKeyIterateeTypeGuard<T_232, S_6>): lo.Dictionary<S_6>;
pickBy<T_233, S_7 extends T_233>(object: lo.NumericDictionary<T_233>, predicate: lo.ValueKeyIterateeTypeGuard<T_233, S_7>): lo.NumericDictionary<S_7>;
pickBy<T_234>(object: lo.Dictionary<T_234>, predicate?: lo.ValueKeyIteratee<T_234>): lo.Dictionary<T_234>;
pickBy<T_235>(object: lo.NumericDictionary<T_235>, predicate?: lo.ValueKeyIteratee<T_235>): lo.NumericDictionary<T_235>;
pickBy<T_236 extends object>(object: T_236, predicate?: lo.ValueKeyIteratee<T_236[keyof T_236]>): Partial<T_236>;
result<TResult_35>(object: any, path: lo.Many<string | number | symbol>, defaultValue?: TResult_35 | ((...args: any[]) => TResult_35)): TResult_35;
set<T_237 extends object>(object: T_237, path: lo.Many<string | number | symbol>, value: any): T_237;
set<TResult_36>(object: object, path: lo.Many<string | number | symbol>, value: any): TResult_36;
setWith<T_238 extends object>(object: T_238, path: lo.Many<string | number | symbol>, value: any, customizer?: lo.SetWithCustomizer<T_238>): T_238;
setWith<T_239 extends object, TResult_37>(object: T_239, path: lo.Many<string | number | symbol>, value: any, customizer?: lo.SetWithCustomizer<T_239>): TResult_37;
toPairs<T_240>(object?: lo.Dictionary<T_240> | lo.NumericDictionary<T_240>): [string, T_240][];
toPairs(object?: object): [string, any][];
toPairsIn<T>(object?: lo.Dictionary<T> | lo.NumericDictionary<T>): [string, T][];
toPairsIn<T_241>(object?: lo.Dictionary<T_241> | lo.NumericDictionary<T_241>): [string, T_241][];
toPairsIn(object?: object): [string, any][];
transform<T, TResult>(object: T[], iteratee: lo.MemoVoidArrayIterator<T, TResult>, accumulator?: TResult): TResult;
transform<T, TResult>(object: lo.Dictionary<T>, iteratee: lo.MemoVoidDictionaryIterator<T, TResult>, accumulator?: TResult): TResult;
transform<T_242, TResult_38>(object: T_242[], iteratee: lo.MemoVoidArrayIterator<T_242, TResult_38>, accumulator?: TResult_38): TResult_38;
transform<T_243, TResult_39>(object: lo.Dictionary<T_243>, iteratee: lo.MemoVoidDictionaryIterator<T_243, TResult_39>, accumulator?: TResult_39): TResult_39;
transform(object: any[]): any[];

@@ -535,21 +535,21 @@ transform(object: object): lo.Dictionary<any>;

update(object: object, path: lo.Many<string | number | symbol>, updater: (value: any) => any): any;
updateWith<T extends object>(object: T, path: lo.Many<string | number | symbol>, updater: (oldValue: any) => any, customizer?: lo.SetWithCustomizer<T>): T;
updateWith<T extends object, TResult>(object: T, path: lo.Many<string | number | symbol>, updater: (oldValue: any) => any, customizer?: lo.SetWithCustomizer<T>): TResult;
values<T>(object: lo.Dictionary<T> | lo.NumericDictionary<T> | ArrayLike<T>): T[];
values<T extends object>(object: T): T[keyof T][];
updateWith<T_244 extends object>(object: T_244, path: lo.Many<string | number | symbol>, updater: (oldValue: any) => any, customizer?: lo.SetWithCustomizer<T_244>): T_244;
updateWith<T_245 extends object, TResult_40>(object: T_245, path: lo.Many<string | number | symbol>, updater: (oldValue: any) => any, customizer?: lo.SetWithCustomizer<T_245>): TResult_40;
values<T_246>(object: lo.Dictionary<T_246> | lo.NumericDictionary<T_246> | lo.List<T_246>): T_246[];
values<T_247 extends object>(object: T_247): T_247[keyof T_247][];
values(object: any): any[];
valuesIn<T>(object: lo.Dictionary<T> | lo.NumericDictionary<T> | ArrayLike<T>): T[];
valuesIn<T extends object>(object: T): T[keyof T][];
valuesIn<T_248>(object: lo.Dictionary<T_248> | lo.NumericDictionary<T_248> | lo.List<T_248>): T_248[];
valuesIn<T_249 extends object>(object: T_249): T_249[keyof T_249][];
chain<TrapAny extends {
__lodashAnyHack: any;
}>(value: TrapAny): lo.CollectionChain<any> & lo.FunctionChain<any> & lo.ObjectChain<any> & lo.PrimitiveChain<any> & lo.StringChain;
chain<T extends null>(value: T): lo.PrimitiveChain<T>;
chain<T_250 extends null>(value: T_250): lo.PrimitiveChain<T_250>;
chain(value: string): lo.StringChain;
chain(value: string): lo.StringNullableChain;
chain<T extends (...args: any[]) => any>(value: T): lo.FunctionChain<T>;
chain<T = any>(value: ArrayLike<T>): lo.CollectionChain<T>;
chain<T extends object>(value: T): lo.ObjectChain<T>;
chain<T>(value: T): lo.PrimitiveChain<T>;
tap<T>(value: T, interceptor: (value: T) => void): T;
thru<T, TResult>(value: T, interceptor: (value: T) => TResult): TResult;
chain<T_251 extends (...args: any[]) => any>(value: T_251): lo.FunctionChain<T_251>;
chain<T_252 = any>(value: lo.List<T_252>): lo.CollectionChain<T_252>;
chain<T_253 extends object>(value: T_253): lo.ObjectChain<T_253>;
chain<T_254>(value: T_254): lo.PrimitiveChain<T_254>;
tap<T_255>(value: T_255, interceptor: (value: T_255) => void): T_255;
thru<T_256, TResult_41>(value: T_256, interceptor: (value: T_256) => TResult_41): TResult_41;
camelCase(string?: string): string;

@@ -591,44 +591,44 @@ capitalize(string?: string): string;

words(string: string, index: string | number, guard: object): string[];
attempt<TResult>(func: (...args: any[]) => TResult, ...args: any[]): Error | TResult;
bindAll<T>(object: T, ...methodNames: lo.Many<string>[]): T;
cond<T, R>(pairs: [(val: T) => boolean, (val: T) => R][]): (Target: T) => R;
conforms<T>(source: lo.ConformsPredicateObject<T>): (value: T) => boolean;
constant<T>(value: T): () => T;
defaultTo<T>(value: T, defaultValue: T): T;
defaultTo<T, TDefault>(value: T, defaultValue: TDefault): T | TDefault;
attempt<TResult_42>(func: (...args: any[]) => TResult_42, ...args: any[]): Error | TResult_42;
bindAll<T_257>(object: T_257, ...methodNames: lo.Many<string>[]): T_257;
cond<T_258, R>(pairs: lo.CondPair<T_258, R>[]): (Target: T_258) => R;
conforms<T_259>(source: lo.ConformsPredicateObject<T_259>): (value: T_259) => boolean;
constant<T_260>(value: T_260): () => T_260;
defaultTo<T_261>(value: T_261, defaultValue: T_261): T_261;
defaultTo<T_262, TDefault_6>(value: T_262, defaultValue: TDefault_6): T_262 | TDefault_6;
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;
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: lo.Many<(a: any) => any>[]): (...args: A) => any;
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;
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;
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;
flow<A extends any[], R1, R2, R3>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3;
flow<A extends any[], R1, R2>(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2;
flow<A_1 extends any[], R1_1, R2_1, R3_1, R4_1, R5_1, R6_1, R7_1>(f1: (...args: A_1) => R1_1, f2: (a: R1_1) => R2_1, f3: (a: R2_1) => R3_1, f4: (a: R3_1) => R4_1, f5: (a: R4_1) => R5_1, f6: (a: R5_1) => R6_1, f7: (a: R6_1) => R7_1, ...func: lo.Many<(a: any) => any>[]): (...args: A_1) => any;
flow<A_2 extends any[], R1_2, R2_2, R3_2, R4_2, R5_2, R6_2>(f1: (...args: A_2) => R1_2, f2: (a: R1_2) => R2_2, f3: (a: R2_2) => R3_2, f4: (a: R3_2) => R4_2, f5: (a: R4_2) => R5_2, f6: (a: R5_2) => R6_2): (...args: A_2) => R6_2;
flow<A_3 extends any[], R1_3, R2_3, R3_3, R4_3, R5_3>(f1: (...args: A_3) => R1_3, f2: (a: R1_3) => R2_3, f3: (a: R2_3) => R3_3, f4: (a: R3_3) => R4_3, f5: (a: R4_3) => R5_3): (...args: A_3) => R5_3;
flow<A_4 extends any[], R1_4, R2_4, R3_4, R4_4>(f1: (...args: A_4) => R1_4, f2: (a: R1_4) => R2_4, f3: (a: R2_4) => R3_4, f4: (a: R3_4) => R4_4): (...args: A_4) => R4_4;
flow<A_5 extends any[], R1_5, R2_5, R3_5>(f1: (...args: A_5) => R1_5, f2: (a: R1_5) => R2_5, f3: (a: R2_5) => R3_5): (...args: A_5) => R3_5;
flow<A_6 extends any[], R1_6, R2_6>(f1: (...args: A_6) => R1_6, f2: (a: R1_6) => R2_6): (...args: A_6) => R2_6;
flow(...func: lo.Many<(...args: any[]) => any>[]): (...args: any[]) => any;
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;
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;
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;
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;
flowRight<A extends any[], R1, R2, R3>(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R3;
flowRight<A extends any[], R1, R2>(f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R2;
flowRight<A_7 extends any[], R1_7, R2_7, R3_6, R4_5, R5_4, R6_3, R7_2>(f7: (a: R6_3) => R7_2, f6: (a: R5_4) => R6_3, f5: (a: R4_5) => R5_4, f4: (a: R3_6) => R4_5, f3: (a: R2_7) => R3_6, f2: (a: R1_7) => R2_7, f1: (...args: A_7) => R1_7): (...args: A_7) => R7_2;
flowRight<A_8 extends any[], R1_8, R2_8, R3_7, R4_6, R5_5, R6_4>(f6: (a: R5_5) => R6_4, f5: (a: R4_6) => R5_5, f4: (a: R3_7) => R4_6, f3: (a: R2_8) => R3_7, f2: (a: R1_8) => R2_8, f1: (...args: A_8) => R1_8): (...args: A_8) => R6_4;
flowRight<A_9 extends any[], R1_9, R2_9, R3_8, R4_7, R5_6>(f5: (a: R4_7) => R5_6, f4: (a: R3_8) => R4_7, f3: (a: R2_9) => R3_8, f2: (a: R1_9) => R2_9, f1: (...args: A_9) => R1_9): (...args: A_9) => R5_6;
flowRight<A_10 extends any[], R1_10, R2_10, R3_9, R4_8>(f4: (a: R3_9) => R4_8, f3: (a: R2_10) => R3_9, f2: (a: R1_10) => R2_10, f1: (...args: A_10) => R1_10): (...args: A_10) => R4_8;
flowRight<A_11 extends any[], R1_11, R2_11, R3_10>(f3: (a: R2_11) => R3_10, f2: (a: R1_11) => R2_11, f1: (...args: A_11) => R1_11): (...args: A_11) => R3_10;
flowRight<A_12 extends any[], R1_12, R2_12>(f2: (a: R1_12) => R2_12, f1: (...args: A_12) => R1_12): (...args: A_12) => R2_12;
flowRight(...func: lo.Many<(...args: any[]) => any>[]): (...args: any[]) => any;
identity<T>(value: T): T;
identity<T_263>(value: T_263): T_263;
identity(): undefined;
iteratee<TFunction extends (...args: any[]) => any>(func: TFunction): TFunction;
iteratee(func: string | object): (...args: any[]) => any;
matches<T>(source: T): (value: any) => boolean;
matches<T, V>(source: T): (value: V) => boolean;
matchesProperty<T>(path: lo.Many<string | number | symbol>, srcValue: T): (value: any) => boolean;
matchesProperty<T, V>(path: lo.Many<string | number | symbol>, srcValue: T): (value: V) => boolean;
matches<T_264>(source: T_264): (value: any) => boolean;
matches<T_265, V>(source: T_265): (value: V) => boolean;
matchesProperty<T_266>(path: lo.Many<string | number | symbol>, srcValue: T_266): (value: any) => boolean;
matchesProperty<T_267, V_1>(path: lo.Many<string | number | symbol>, srcValue: T_267): (value: V_1) => boolean;
method(path: lo.Many<string | number | symbol>, ...args: any[]): (object: any) => any;
methodOf(object: object, ...args: any[]): (path: lo.Many<string | number | symbol>) => any;
mixin<TObject>(object: TObject, source: lo.Dictionary<(...args: any[]) => any>, options?: lo.MixinOptions): TObject;
mixin<TResult>(source: lo.Dictionary<(...args: any[]) => any>, options?: lo.MixinOptions): lo.LoDashStatic;
mixin<TObject_55>(object: TObject_55, source: lo.Dictionary<(...args: any[]) => any>, options?: lo.MixinOptions): TObject_55;
mixin<TResult_43>(source: lo.Dictionary<(...args: any[]) => any>, options?: lo.MixinOptions): lo.LoDashStatic;
noConflict(): lo.LoDashStatic;
noop(...args: any[]): void;
nthArg(n?: number): (...args: any[]) => any;
over<TResult>(...iteratees: lo.Many<(...args: any[]) => TResult>[]): (...args: any[]) => TResult[];
overEvery<T>(...predicates: lo.Many<(...args: T[]) => boolean>[]): (...args: T[]) => boolean;
overSome<T>(...predicates: lo.Many<(...args: T[]) => boolean>[]): (...args: T[]) => boolean;
property<TObj, TResult>(path: lo.Many<string | number | symbol>): (obj: TObj) => TResult;
propertyOf<T extends {}>(object: T): (path: lo.Many<string | number | symbol>) => any;
over<TResult_44>(...iteratees: lo.Many<(...args: any[]) => TResult_44>[]): (...args: any[]) => TResult_44[];
overEvery<T_268>(...predicates: lo.Many<(...args: T_268[]) => boolean>[]): (...args: T_268[]) => boolean;
overSome<T_269>(...predicates: lo.Many<(...args: T_269[]) => boolean>[]): (...args: T_269[]) => boolean;
property<TObj, TResult_45>(path: lo.Many<string | number | symbol>): (obj: TObj) => TResult_45;
propertyOf<T_270 extends {}>(object: T_270): (path: lo.Many<string | number | symbol>) => any;
range(start: number, end?: number, step?: number): number[];

@@ -641,6 +641,8 @@ range(end: number, index: string | number, guard: object): number[];

stubFalse(): false;
stubFalse(): false;
stubObject(): any;
stubString(): string;
stubTrue(): true;
times<TResult>(n: number, iteratee: (num: number) => TResult): TResult[];
stubTrue(): true;
times<TResult_46>(n: number, iteratee: (num: number) => TResult_46): TResult_46[];
times(n: number): number[];

@@ -647,0 +649,0 @@ toPath(value: any): string[];

2

lib/index.js

@@ -9,3 +9,3 @@ "use strict";

// tslint:disable-next-line:variable-name
exports.Utils = Object.assign({}, lo, utils);
exports.Utils = Object.assign(Object.assign({}, lo), utils);
__export(require("./debug"));

@@ -12,0 +12,0 @@ __export(require("./process"));

4

lib/process.js

@@ -68,3 +68,3 @@ "use strict";

class ProcessInfo {
static get(level) {
static get(level = 0) {
const start = Utils.time();

@@ -225,2 +225,3 @@ this.cpuUsage = process.cpuUsage(this.cpuUsage);

}
exports.ProcessInfo = ProcessInfo;
ProcessInfo.packages = {};

@@ -230,3 +231,2 @@ ProcessInfo.modules = {};

ProcessInfo.cpuUsage = process.cpuUsage();
exports.ProcessInfo = ProcessInfo;
// export function reload(level?: number): NodeModule {

@@ -233,0 +233,0 @@ // const dump = modules(level);

23

package.json
{
"name": "exer",
"version": "0.0.29",
"version": "0.0.30",
"description": "Utils in TypeScript, Debug, NanoTimer ...",

@@ -39,16 +39,17 @@ "author": "kbajalc@gmail.com",

"lodash": "^4.17.15",
"uuid": "^3.3.2"
"reflect-metadata": "^0.1.13",
"uuid": "^3.3.3"
},
"devDependencies": {
"@types/chance": "^1.0.5",
"@types/lodash": "^4.14.136",
"@types/node": "^10.14.13",
"@types/uuid": "^3.4.5",
"chance": "^1.0.18",
"ts-node": "^8.3.0",
"tslint": "^5.18.0",
"tslint-config-airbnb": "^5.11.1",
"@types/chance": "^1.0.7",
"@types/lodash": "^4.14.146",
"@types/node": "^10.17.5",
"@types/uuid": "^3.4.6",
"chance": "^1.1.3",
"ts-node": "^8.5.0",
"tslint": "^5.20.1",
"tslint-config-airbnb": "^5.11.2",
"tty": "^1.0.1",
"typescript": "^3.5.3"
"typescript": "^3.7.2"
}
}
lib/index.js.map

Sorry, the diff of this file is not supported yet

lib/process.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc