nishant-design-system
Version:
Sense UI components library
6,408 lines • 192 kB
JavaScript
// flow-typed signature: fd88436625196dbb8bf813a1f1684e58
// flow-typed version: 179ae71d58/lodash_v4.x.x/flow_>=v0.155.x
declare module "lodash" {
declare type Path = $ReadOnlyArray<string | number> | string | number;
declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
declare type CurriedFunction1<A, R> = __CurriedFunction1<A, R, *>;
declare type __CurriedFunction2<A, B, R, AA: A, BB: B> = ((
...r: [AA]
) => CurriedFunction1<BB, R>) &
((...r: [AA, BB]) => R);
declare type CurriedFunction2<A, B, R> = __CurriedFunction2<A, B, R, *, *>;
declare type __CurriedFunction3<A, B, C, R, AA: A, BB: B, CC: C> = ((
...r: [AA]
) => CurriedFunction2<BB, CC, R>) &
((...r: [AA, BB]) => CurriedFunction1<CC, R>) &
((...r: [AA, BB, CC]) => R);
declare type CurriedFunction3<A, B, C, R> = __CurriedFunction3<
A,
B,
C,
R,
*,
*,
*
>;
declare type __CurriedFunction4<
A,
B,
C,
D,
R,
AA: A,
BB: B,
CC: C,
DD: D
> = ((...r: [AA]) => CurriedFunction3<BB, CC, DD, R>) &
((...r: [AA, BB]) => CurriedFunction2<CC, DD, R>) &
((...r: [AA, BB, CC]) => CurriedFunction1<DD, R>) &
((...r: [AA, BB, CC, DD]) => R);
declare type CurriedFunction4<A, B, C, D, R> = __CurriedFunction4<
A,
B,
C,
D,
R,
*,
*,
*,
*
>;
declare type __CurriedFunction5<
A,
B,
C,
D,
E,
R,
AA: A,
BB: B,
CC: C,
DD: D,
EE: E
> = ((...r: [AA]) => CurriedFunction4<BB, CC, DD, EE, R>) &
((...r: [AA, BB]) => CurriedFunction3<CC, DD, EE, R>) &
((...r: [AA, BB, CC]) => CurriedFunction2<DD, EE, R>) &
((...r: [AA, BB, CC, DD]) => CurriedFunction1<EE, R>) &
((...r: [AA, BB, CC, DD, EE]) => R);
declare type CurriedFunction5<A, B, C, D, E, R> = __CurriedFunction5<
A,
B,
C,
D,
E,
R,
*,
*,
*,
*,
*
>;
declare type __CurriedFunction6<
A,
B,
C,
D,
E,
F,
R,
AA: A,
BB: B,
CC: C,
DD: D,
EE: E,
FF: F
> = ((...r: [AA]) => CurriedFunction5<BB, CC, DD, EE, FF, R>) &
((...r: [AA, BB]) => CurriedFunction4<CC, DD, EE, FF, R>) &
((...r: [AA, BB, CC]) => CurriedFunction3<DD, EE, FF, R>) &
((...r: [AA, BB, CC, DD]) => CurriedFunction2<EE, FF, R>) &
((...r: [AA, BB, CC, DD, EE]) => CurriedFunction1<FF, R>) &
((...r: [AA, BB, CC, DD, EE, FF]) => R);
declare type CurriedFunction6<A, B, C, D, E, F, R> = __CurriedFunction6<
A,
B,
C,
D,
E,
F,
R,
*,
*,
*,
*,
*,
*
>;
declare type Curry = (<A, R>((...r: [A]) => R) => CurriedFunction1<A, R>) &
(<A, B, R>((...r: [A, B]) => R) => CurriedFunction2<A, B, R>) &
(<A, B, C, R>((...r: [A, B, C]) => R) => CurriedFunction3<A, B, C, R>) &
(<A, B, C, D, R>(
(...r: [A, B, C, D]) => R
) => CurriedFunction4<A, B, C, D, R>) &
(<A, B, C, D, E, R>(
(...r: [A, B, C, D, E]) => R
) => CurriedFunction5<A, B, C, D, E, R>) &
(<A, B, C, D, E, F, R>(
(...r: [A, B, C, D, E, F]) => R
) => CurriedFunction6<A, B, C, D, E, F, R>);
declare type UnaryFn<A, R> = (a: A) => R;
declare type TemplateSettings = {
escape?: RegExp,
evaluate?: RegExp,
imports?: Object,
interpolate?: RegExp,
variable?: string,
...
};
declare type TruncateOptions = {
length?: number,
omission?: string,
separator?: RegExp | string,
...
};
declare type Cancelable = {
cancel: () => void,
flush: () => mixed,
...
};
declare type DebounceOptions = {
leading?: boolean,
maxWait?: number,
trailing?: boolean,
...
};
declare type ThrottleOptions = {
leading?: boolean,
trailing?: boolean,
...
};
// using opaque type for object key is not supported by Flow atm: https://github.com/facebook/flow/issues/5407
declare type Key = string | number;
declare type IndexerObject<V, K = Key> = { [key: K]: V, ... };
declare type ReadOnlyIndexerObject<V, K = Key> = $ReadOnly<IndexerObject<V, K>>;
declare type NestedArray<V> = Array<Array<V>>;
declare type Collection<V, K = Key> = $ReadOnlyArray<V> | ReadOnlyIndexerObject<V, K>;
declare type matchesIterateeShorthand = { [key: string]: any, ... };
declare type matchesPropertyIterateeShorthand = [string, any];
declare type propertyIterateeShorthand = string;
declare type OPredicate<A, O> =
| ((value: A, key: string, object: O) => any)
| matchesIterateeShorthand
| matchesPropertyIterateeShorthand
| propertyIterateeShorthand;
declare type IterateeWithResult<V, K, O, R> =
| ((value: V, key: K, object: O) => R)
| string;
declare type OIterateeWithResult<V, K, O, R> =
| ReadOnlyIndexerObject<V, K>
| IterateeWithResult<V, K, O, R>;
declare type OIteratee<O> = OIterateeWithResult<any, any, O, any>;
declare type AFlatMapIteratee<V, O, R> =
| ((item: V, index: number, array: O) => $ReadOnlyArray<R> | R)
| string
declare type OFlatMapIteratee<V, K, O, R> = IterateeWithResult<V, K, O, $ReadOnlyArray<R> | R>;
declare type Predicate<T> =
| ((value: T, index: number, array: Array<T>) => any)
| matchesIterateeShorthand
| matchesPropertyIterateeShorthand
| propertyIterateeShorthand;
declare type _ValueOnlyIteratee<T> = (value: T) => mixed;
declare type ValueOnlyIteratee<T> = _ValueOnlyIteratee<T> | string;
declare type _Iteratee<T> = (
item: T,
index: number,
array: ?Array<T>
) => mixed;
declare type Iteratee<T> = _Iteratee<T> | Object | string;
declare type Comparator<T> = (item: T, item2: T) => boolean;
declare type ReadOnlyMapIterator<T, U> =
| ((item: T, index: number, array: $ReadOnlyArray<T>) => U)
| propertyIterateeShorthand;
declare type OMapIterator<T, O, U> =
| ((item: T, key: string, object: O) => U)
| propertyIterateeShorthand;
declare type Lodash = {|
// Array
chunk<T>(array?: ?$ReadOnlyArray<T>, size?: ?number): Array<Array<T>>;
compact<T, N = ?T | boolean>(array?: ?$ReadOnlyArray<N>): Array<T>;
concat<T>(
base?: ?$ReadOnlyArray<T>,
...elements: $ReadOnlyArray<any>
): Array<T | any>;
difference<T>(
array?: ?$ReadOnlyArray<T>,
...values: $ReadOnlyArray<?$ReadOnlyArray<T>>
): Array<T>;
differenceBy<T, U>(
array?: ?$ReadOnlyArray<T>,
values?: ?$ReadOnlyArray<U>,
iteratee?: ?ValueOnlyIteratee<T | U>
): Array<T>;
differenceWith<T, U>(
array?: ?$ReadOnlyArray<T>,
values?: ?$ReadOnlyArray<U>,
comparator?: ?(item: T, item2: U) => boolean
): Array<T>;
drop<T>(array?: ?$ReadOnlyArray<T>, n?: ?number): Array<T>;
dropRight<T>(array?: ?$ReadOnlyArray<T>, n?: ?number): Array<T>;
dropRightWhile<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>): Array<T>;
dropWhile<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>): Array<T>;
fill<T, U>(
array?: ?Array<T>,
value?: ?U,
start?: ?number,
end?: ?number
): Array<T | U>;
findIndex:
& (<T>(
array: $ReadOnlyArray<T>,
predicate?: ?Predicate<T>,
fromIndex?: ?number
) => number)
& (<T>(
array: void | null,
predicate?: ?Predicate<T>,
fromIndex?: ?number
) => -1);
findLastIndex:
& (<T>(
array: $ReadOnlyArray<T>,
predicate?: ?Predicate<T>,
fromIndex?: ?number
) => number)
& (<T>(
array: void | null,
predicate?: ?Predicate<T>,
fromIndex?: ?number
) => -1);
// alias of _.head
first<T>(array: ?$ReadOnlyArray<T>): T;
flatten<T, X>(array?: ?$ReadOnlyArray<$ReadOnlyArray<T> | X>): Array<T | X>;
flattenDeep<T>(array?: ?$ReadOnlyArray<any>): Array<T>;
flattenDepth(array?: ?$ReadOnlyArray<any>, depth?: ?number): Array<any>;
fromPairs<A, B>(pairs?: ?$ReadOnlyArray<[A, B]>): {| [key: A]: B |};
head<T>(array: ?$ReadOnlyArray<T>): T;
indexOf:
& (<T>(array: $ReadOnlyArray<T>, value: T, fromIndex?: number) => number)
& (<T>(array: void | null, value?: ?T, fromIndex?: ?number) => -1);
initial<T>(array: ?$ReadOnlyArray<T>): Array<T>;
intersection<T>(...arrays?: Array<$ReadOnlyArray<T>>): Array<T>;
//Workaround until (...parameter: T, parameter2: U) works
intersectionBy:
& (<T>(
a1?: ?$ReadOnlyArray<T>,
iteratee?: ?ValueOnlyIteratee<T>
) => Array<T>)
& (<T>(
a1?: ?$ReadOnlyArray<T>,
a2?: ?$ReadOnlyArray<T>,
iteratee?: ?ValueOnlyIteratee<T>
) => Array<T>)
& (<T>(
a1?: ?$ReadOnlyArray<T>,
a2?: ?$ReadOnlyArray<T>,
a3?: ?$ReadOnlyArray<T>,
iteratee?: ?ValueOnlyIteratee<T>
) => Array<T>)
& (<T>(
a1?: ?$ReadOnlyArray<T>,
a2?: ?$ReadOnlyArray<T>,
a3?: ?$ReadOnlyArray<T>,
a4?: ?$ReadOnlyArray<T>,
iteratee?: ?ValueOnlyIteratee<T>
) => Array<T>);
//Workaround until (...parameter: T, parameter2: U) works
intersectionWith:
& (<T>(
a1?: ?$ReadOnlyArray<T>,
comparator?: ?Comparator<T>
) => Array<T>)
& (<T>(
a1?: ?$ReadOnlyArray<T>,
a2?: ?$ReadOnlyArray<T>,
comparator?: ?Comparator<T>
) => Array<T>)
& (<T>(
a1?: ?$ReadOnlyArray<T>,
a2?: ?$ReadOnlyArray<T>,
a3?: ?$ReadOnlyArray<T>,
comparator?: ?Comparator<T>
) => Array<T>)
& (<T>(
a1?: ?$ReadOnlyArray<T>,
a2?: ?$ReadOnlyArray<T>,
a3?: ?$ReadOnlyArray<T>,
a4?: ?$ReadOnlyArray<T>,
comparator?: ?Comparator<T>
) => Array<T>);
join:
& (<T>(array: $ReadOnlyArray<T>, separator?: ?string) => string)
& (<T>(array: void | null, separator?: ?string) => "");
last<T>(array: ?$ReadOnlyArray<T>): T;
lastIndexOf:
& (<T>(array: $ReadOnlyArray<T>, value?: ?T, fromIndex?: ?number) => number)
& (<T>(array: void | null, value?: ?T, fromIndex?: ?number) => -1);
nth:
& (<T>(array: $ReadOnlyArray<T>, n?: ?number) => T)
& ((array: void | null, n?: ?number) => void);
pull:
& (<T>(array: Array<T>, ...values?: $ReadOnlyArray<?T>) => Array<T>)
& (<T: void | null>(array: T, ...values?: $ReadOnlyArray<?any>) => T);
pullAll:
& (<T>(array: Array<T>, values?: ?$ReadOnlyArray<T>) => Array<T>)
& (<T: void | null>(array: T, values?: ?$ReadOnlyArray<any>) => T);
pullAllBy:
& (<T>(
array: Array<T>,
values?: ?$ReadOnlyArray<T>,
iteratee?: ?ValueOnlyIteratee<T>
) => Array<T>)
& (<T: void | null>(
array: T,
values?: ?$ReadOnlyArray<any>,
iteratee?: ?ValueOnlyIteratee<any>
) => T);
pullAllWith:
& (<T: void | null>(
array: T,
values?: ?$ReadOnlyArray<any>,
comparator?: ?Function
) => T)
& (<T>(array: Array<T>, values?: ?($ReadOnlyArray<T>), comparator?: ?Function) => Array<T>);
pullAt:
& (<T>(array?: ?Array<T>, ...indexed?: $ReadOnlyArray<?number>) => Array<T>)
& (<T>(array?: ?Array<T>, indexed?: ?$ReadOnlyArray<number>) => Array<T>);
remove<T>(array?: ?Array<T>, predicate?: ?Predicate<T>): Array<T>;
reverse:
& (<T>(array: Array<T>) => Array<T>)
& (<T: void | null>(array: T) => T);
slice<T>(
array?: ?$ReadOnlyArray<T>,
start?: ?number,
end?: ?number
): Array<T>;
sortedIndex:
& (<T>(array: $ReadOnlyArray<T>, value: T) => number)
& (<T>(array: void | null, value: ?T) => 0);
sortedIndexBy:
& (<T>(
array: $ReadOnlyArray<T>,
value?: ?T,
iteratee?: ?ValueOnlyIteratee<T>
) => number)
& (<T>(
array: void | null,
value?: ?T,
iteratee?: ?ValueOnlyIteratee<T>
) => 0);
sortedIndexOf:
& (<T>(array: $ReadOnlyArray<T>, value: T) => number)
& (<T>(array: void | null, value?: ?T) => -1);
sortedLastIndex:
& (<T>(array: $ReadOnlyArray<T>, value: T) => number)
& (<T>(array: void | null, value?: ?T) => 0);
sortedLastIndexBy:
& (<T>(
array: $ReadOnlyArray<T>,
value: T,
iteratee?: ValueOnlyIteratee<T>
) => number)
& (<T>(
array: void | null,
value?: ?T,
iteratee?: ?ValueOnlyIteratee<T>
) => 0);
sortedLastIndexOf:
& (<T>(array: $ReadOnlyArray<T>, value: T) => number)
& (<T>(array: void | null, value?: ?T) => -1);
sortedUniq<T>(array?: ?$ReadOnlyArray<T>): Array<T>;
sortedUniqBy<T>(
array?: ?$ReadOnlyArray<T>,
iteratee?: ?ValueOnlyIteratee<T>
): Array<T>;
tail<T>(array?: ?$ReadOnlyArray<T>): Array<T>;
take<T>(array?: ?$ReadOnlyArray<T>, n?: ?number): Array<T>;
takeRight<T>(array?: ?$ReadOnlyArray<T>, n?: ?number): Array<T>;
takeRightWhile<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>): Array<T>;
takeWhile<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>): Array<T>;
union: <T>(...arrays?: Array<$ReadOnlyArray<T>>) => Array<T>;
//Workaround until (...parameter: T, parameter2: U) works
unionBy:
& (<T>(
a1?: ?$ReadOnlyArray<T>,
iteratee?: ?ValueOnlyIteratee<T>
) => Array<T>)
& (<T>(
a1?: ?$ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>,
iteratee?: ValueOnlyIteratee<T>
) => Array<T>)
& (<T>(
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>,
a3: $ReadOnlyArray<T>,
iteratee?: ValueOnlyIteratee<T>
) => Array<T>)
& (<T>(
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>,
a3: $ReadOnlyArray<T>,
a4: $ReadOnlyArray<T>,
iteratee?: ValueOnlyIteratee<T>
) => Array<T>);
//Workaround until (...parameter: T, parameter2: U) works
unionWith:
& (<T>(a1?: ?$ReadOnlyArray<T>, comparator?: ?Comparator<T>) => Array<T>)
& (<T>(
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>,
comparator?: Comparator<T>
) => Array<T>)
& (<T>(
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>,
a3: $ReadOnlyArray<T>,
comparator?: Comparator<T>
) => Array<T>)
& (<T>(
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>,
a3: $ReadOnlyArray<T>,
a4: $ReadOnlyArray<T>,
comparator?: Comparator<T>
) => Array<T>);
uniq<T>(array?: ?$ReadOnlyArray<T>): Array<T>;
uniqBy<T>(array?: ?$ReadOnlyArray<T>, iteratee?: ?ValueOnlyIteratee<T>): Array<T>;
uniqWith<T>(array?: ?$ReadOnlyArray<T>, comparator?: ?Comparator<T>): Array<T>;
unzip<T>(array?: ?$ReadOnlyArray<T>): Array<T>;
unzipWith<T>(array: ?$ReadOnlyArray<T>, iteratee?: ?Iteratee<T>): Array<T>;
without<T>(array?: ?$ReadOnlyArray<T>, ...values?: Array<?T>): Array<T>;
xor<T>(...array: $ReadOnlyArray<$ReadOnlyArray<T>>): Array<T>;
//Workaround until (...parameter: T, parameter2: U) works
xorBy:
& (<T>(a1?: ?$ReadOnlyArray<T>, iteratee?: ?ValueOnlyIteratee<T>) => Array<T>)
& (<T>(
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>,
iteratee?: ValueOnlyIteratee<T>
) => Array<T>)
& (<T>(
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>,
a3: $ReadOnlyArray<T>,
iteratee?: ValueOnlyIteratee<T>
) => Array<T>)
& (<T>(
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>,
a3: $ReadOnlyArray<T>,
a4: $ReadOnlyArray<T>,
iteratee?: ValueOnlyIteratee<T>
) => Array<T>);
//Workaround until (...parameter: T, parameter2: U) works
xorWith:
& (<T>(a1?: ?$ReadOnlyArray<T>, comparator?: ?Comparator<T>) => Array<T>)
& (<T>(
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>,
comparator?: Comparator<T>
) => Array<T>)
& (<T>(
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>,
a3: $ReadOnlyArray<T>,
comparator?: Comparator<T>
) => Array<T>)
& (<T>(
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>,
a3: $ReadOnlyArray<T>,
a4: $ReadOnlyArray<T>,
comparator?: Comparator<T>
) => Array<T>);
zip:
& (<A, B>(a1?: ?($ReadOnlyArray<A>), a2?: ?($ReadOnlyArray<B>)) => Array<[A, B]>)
& (<A, B, C>(a1: $ReadOnlyArray<A>, a2: $ReadOnlyArray<B>, a3: $ReadOnlyArray<C>) => Array<[A, B, C]>)
& (<A, B, C, D>(a1: $ReadOnlyArray<A>, a2: $ReadOnlyArray<B>, a3: $ReadOnlyArray<C>, a4: $ReadOnlyArray<D>) => Array<[A, B, C, D]>)
& (<A, B, C, D, E>(
a1: $ReadOnlyArray<A>,
a2: $ReadOnlyArray<B>,
a3: $ReadOnlyArray<C>,
a4: $ReadOnlyArray<D>,
a5: $ReadOnlyArray<E>
) => Array<[A, B, C, D, E]>);
zipObject:
& (<K, V>(props: $ReadOnlyArray<K>, values?: ?$ReadOnlyArray<V>) => { [key: K]: V, ... })
& (<K, V>(props: void | null, values?: ?$ReadOnlyArray<V>) => {...});
zipObjectDeep:
& ((props: $ReadOnlyArray<any>, values?: ?any) => Object)
& ((props: void | null, values?: ?any) => {...});
zipWith:
& (<A>(a1?: ?$ReadOnlyArray<A>) => Array<[A]>)
& (<T, A>(a1: $ReadOnlyArray<A>, iteratee: (A) => T) => Array<T>)
& (<A, B>(a1: $ReadOnlyArray<A>, a2: $ReadOnlyArray<B>) => Array<[A, B]>)
& (<T, A, B>(
a1: $ReadOnlyArray<A>,
a2: $ReadOnlyArray<B>,
iteratee: (A, B) => T
) => Array<T>)
& (<A, B, C>(
a1: $ReadOnlyArray<A>,
a2: $ReadOnlyArray<B>,
a3: $ReadOnlyArray<C>
) => Array<[A, B, C]>)
& (<T, A, B, C>(
a1: $ReadOnlyArray<A>,
a2: $ReadOnlyArray<B>,
a3: $ReadOnlyArray<C>,
iteratee: (A, B, C) => T
) => Array<T>)
& (<A, B, C, D>(
a1: $ReadOnlyArray<A>,
a2: $ReadOnlyArray<B>,
a3: $ReadOnlyArray<C>,
a4: $ReadOnlyArray<D>
) => Array<[A, B, C, D]>)
& (<T, A, B, C, D>(
a1: $ReadOnlyArray<A>,
a2: $ReadOnlyArray<B>,
a3: $ReadOnlyArray<C>,
a4: $ReadOnlyArray<D>,
iteratee: (A, B, C, D) => T
) => Array<T>);
// Collection
countBy:
& (<T>(array: $ReadOnlyArray<T>, iteratee?: ?ValueOnlyIteratee<T>) => { [key: string]: number, ... })
& (<T>(array: void | null, iteratee?: ?ValueOnlyIteratee<T>) => { [key: string]: number, ... })
& ((string: string, iteratee?: ?ValueOnlyIteratee<string>) => { [key: string]: number, ... })
& (<T>(object: ReadOnlyIndexerObject<T>, iteratee?: ?ValueOnlyIteratee<T>) => { [key: string]: number, ... });
// alias of _.forEach
each<A, K, T: ReadOnlyIndexerObject<A, K> | $ReadOnlyArray<A> | string | void | null>(collection: T, iteratee?: ?IterateeWithResult<A, K, T, boolean | void>): T;
// alias of _.forEachRight
eachRight<A, K, T: ReadOnlyIndexerObject<A, K> | $ReadOnlyArray<A> | string | void | null>(collection: T, iteratee?: ?IterateeWithResult<A, K, T, boolean | void>): T;
every:
& (<T>(array?: ?$ReadOnlyArray<T>, iteratee?: ?Iteratee<T>) => boolean)
& ((str: string, iteratee?: ?Iteratee<string>) => boolean)
& (<A, T: ReadOnlyIndexerObject<A>>(object: T, iteratee?: OIterateeWithResult<A, string, T, any>) => boolean);
filter:
& (<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>) => Array<T>)
& (<A, T: ReadOnlyIndexerObject<A>>(
object: T,
predicate?: OPredicate<A, T>
) => Array<A>);
find:
& (<T>(
array: $ReadOnlyArray<T>,
predicate?: ?Predicate<T>,
fromIndex?: ?number
) => T | void)
& (<T>(
array: void | null,
predicate?: ?Predicate<T>,
fromIndex?: ?number
) => void)
& (<R, A, T: ReadOnlyIndexerObject<A>>(
object: T,
predicate?: ?OPredicate<A, T>,
fromIndex?: ?number
) => R);
findLast:
& (<T>(
array: $ReadOnlyArray<T>,
predicate?: ?Predicate<T>,
fromIndex?: ?number
) => T | void)
& (<T>(
array: void | null,
predicate?: ?Predicate<T>,
fromIndex?: ?number
) => void)
& (<R, A, T: ReadOnlyIndexerObject<A>>(
object: T,
predicate?: ?OPredicate<A, T>,
fromIndex?: ?number
) => R);
flatMap:
& (<A, U, T: $ReadOnlyArray<A> = Array<A>>(
array: T,
iteratee?: ?AFlatMapIteratee<A, T, U>
) => Array<U>)
& (<A, K, U, T: ?ReadOnlyIndexerObject<A, K> | string = IndexerObject<A, K>>(
object: T,
iteratee?: ?OFlatMapIteratee<A, K, T, U>
) => Array<U>);
flatMapDeep:
& (<A, U, T: $ReadOnlyArray<A> = Array<A>>(
array: T,
iteratee?: ?AFlatMapIteratee<A, T, any>
) => Array<U>)
& (<A, K, U, T: ?ReadOnlyIndexerObject<A, K> | string = IndexerObject<A, K>>(
object: T,
iteratee?: ?OFlatMapIteratee<A, K, T, any>
) => Array<U>);
flatMapDepth:
& (<A, U, T: $ReadOnlyArray<A> = Array<A>>(
array: T,
iteratee?: ?AFlatMapIteratee<A, T, any>,
depth?: ?number
) => Array<U>)
& (<A, K, U, T: ?ReadOnlyIndexerObject<A, K> | string = IndexerObject<A, K>>(
object: T,
iteratee?: ?OFlatMapIteratee<A, K, T, any>,
depth?: ?number
) => Array<U>);
forEach<A, K, T: ReadOnlyIndexerObject<A, K> | $ReadOnlyArray<A> | string | void | null>(collection: T, iteratee?: ?IterateeWithResult<A, K, T, boolean | void>): T;
forEachRight<A, K, T: ReadOnlyIndexerObject<A, K> | $ReadOnlyArray<A> | string | void | null>(collection: T, iteratee?: ?IterateeWithResult<A, K, T, boolean | void>): T;
groupBy:
& (<V, T>(
array: $ReadOnlyArray<T>,
iteratee?: ?ValueOnlyIteratee<T>
) => { [key: V]: Array<T>, ... })
& ((array: void | null, iteratee?: ?ValueOnlyIteratee<any>) => {...})
& (<V, A, T: ReadOnlyIndexerObject<A>>(
object: T,
iteratee?: ValueOnlyIteratee<A>
) => { [key: V]: Array<A>, ... });
includes:
& (<T>(
array: $ReadOnlyArray<T>,
value: T,
fromIndex?: ?number
) => boolean)
& (<T>(array: void | null, value?: ?T, fromIndex?: ?number) => false)
& (<A>(object: ReadOnlyIndexerObject<A>, value: A, fromIndex?: number) => boolean)
& ((str: string, value: string, fromIndex?: number) => boolean);
invokeMap:
& (<T>(
array?: ?$ReadOnlyArray<T>,
path?: ?((value: T) => Path) | Path,
...args?: $ReadOnlyArray<any>
) => Array<any>)
& (<A>(
object: ReadOnlyIndexerObject<A>,
path: ((value: any) => Path) | Path,
...args?: $ReadOnlyArray<any>
) => Array<any>);
keyBy:
& (<T, V>(
array: $ReadOnlyArray<T>,
iteratee?: ?ValueOnlyIteratee<T>
) => { [key: V]: T, ... })
& ((array: void | null, iteratee?: ?ValueOnlyIteratee<*>) => {...})
& (<V, A, K, T: ReadOnlyIndexerObject<A, K>>(
object: T,
iteratee?: ?ValueOnlyIteratee<A>
) => { [key: V]: A, ... });
map:
& (<T, U>(
array?: ?$ReadOnlyArray<T>,
iteratee?: ?ReadOnlyMapIterator<T, U>
) => Array<U>)
& (<V, T: ReadOnlyIndexerObject<V>, U>(
object: ?T,
iteratee?: OMapIterator<V, T, U>
) => Array<U>)
& ((
str: ?string,
iteratee?: (char: string, index: number, str: string) => any
) => string);
orderBy:
& (<T>(
array: $ReadOnlyArray<T>,
iteratees?: ?$ReadOnlyArray<Iteratee<T>> | ?string,
orders?: ?$ReadOnlyArray<"asc" | "desc"> | ?string
) => Array<T>)
& (<T>(
array: null | void,
iteratees?: ?$ReadOnlyArray<Iteratee<T>> | ?string,
orders?: ?$ReadOnlyArray<"asc" | "desc"> | ?string
) => Array<T>)
& (<V, T: ReadOnlyIndexerObject<V>>(
object: T,
iteratees?: $ReadOnlyArray<OIteratee<*>> | string,
orders?: $ReadOnlyArray<"asc" | "desc"> | string
) => Array<V>);
partition:
& (<T>(
array?: ?$ReadOnlyArray<T>,
predicate?: ?Predicate<T>
) => [Array<T>, Array<T>])
& (<V, A, T: ReadOnlyIndexerObject<A>>(
object: T,
predicate?: OPredicate<A, T>
) => [Array<V>, Array<V>]);
reduce:
& (<T, U>(
array: $ReadOnlyArray<T>,
iteratee?: (
accumulator: U,
value: T,
index: number,
array: ?Array<T>
) => U,
accumulator?: U
) => U)
& (<T, U>(
array: void | null,
iteratee?: ?(
accumulator: U,
value: T,
index: any,
array: ?Array<T>
) => U,
accumulator?: U
) => U)
& (<A, T: ReadOnlyIndexerObject<A>, U>(
object: T,
iteratee?: (accumulator: U, value: any, key: string, object: T) => U,
accumulator?: U
) => U);
reduceRight:
& (<T, U>(
array: void | null,
iteratee?: ?(
accumulator: U,
value: T,
index: any,
array: ?Array<T>
) => U,
accumulator?: U
) => U)
& (<T, U>(
array: $ReadOnlyArray<T>,
iteratee?: ?(
accumulator: U,
value: T,
index: number,
array: ?Array<T>
) => U,
accumulator?: ?U
) => U)
& (<A, T: ReadOnlyIndexerObject<A>, U>(
object: T,
iteratee?: ?(accumulator: U, value: any, key: string, object: T) => U,
accumulator?: ?U
) => U);
reject:
& (<T>(array?: ?$ReadOnlyArray<T>, predicate?: ?Predicate<T>) => Array<T>)
& (<A, T: ReadOnlyIndexerObject<A>>(
object?: ?T,
predicate?: ?OPredicate<A, T>
) => Array<A>);
sample<T>(collection: ?Collection<T>): T;
sampleSize<T>(collection?: ?Collection<T>, n?: ?number): Array<T>;
shuffle<T>(array?: ?Collection<T>): Array<T>;
size(collection?: ?Collection<any> | string): number;
some:
& (<T>(array: void | null, predicate?: ?Predicate<T>) => false)
& (<T>(array: ?$ReadOnlyArray<T>, predicate?: Predicate<T>) => boolean)
& (<A, T: ReadOnlyIndexerObject<A>>(
object?: ?T,
predicate?: OPredicate<A, T>
) => boolean);
sortBy:
& (<T>(
array: ?$ReadOnlyArray<T>,
...iteratees?: $ReadOnlyArray<Iteratee<T>>
) => Array<T>)
& (<T>(
array: ?$ReadOnlyArray<T>,
iteratees?: $ReadOnlyArray<Iteratee<T>>
) => Array<T>)
& (<V, T: ReadOnlyIndexerObject<V>>(
object: T,
...iteratees?: $ReadOnlyArray<OIteratee<T>>
) => Array<V>)
& (<V, T: ReadOnlyIndexerObject<V>>(
object: T,
iteratees?: $ReadOnlyArray<OIteratee<T>>
) => Array<V>);
// Date
now(): number;
// Function
after(n: number, fn: Function): Function;
ary(func: Function, n?: number): Function;
before(n: number, fn: Function): Function;
bind<F:(...$ReadOnlyArray<any>) => any>(func: F, thisArg: any, ...partials: $ReadOnlyArray<any>): F;
bindKey(obj?: ?Object, key?: ?string, ...partials?: $ReadOnlyArray<?any>): Function;
curry:
& Curry
& ((func: Function, arity?: number) => Function);
curryRight(func: Function, arity?: number): Function;
debounce<F: (...$ReadOnlyArray<any>) => any>(
func: F,
wait?: number,
options?: DebounceOptions
): F & Cancelable;
defer(func: (...$ReadOnlyArray<any>) => any, ...args?: $ReadOnlyArray<any>): TimeoutID;
delay(func: Function, wait: number, ...args?: $ReadOnlyArray<any>): TimeoutID;
flip<R>(func: (...$ReadOnlyArray<any>) => R): (...Array<any>) => R;
memoize<A, R>(func: (...A) => R, resolver?: (...A) => any): (...A) => R;
negate<A, R>(predicate: (...A) => R): (...A) => boolean;
once<F: (...$ReadOnlyArray<any>) => any>(func: F): F;
overArgs:
& ((func?: ?Function, ...transforms?: $ReadOnlyArray<Function>) => Function)
& ((func?: ?Function, transforms?: ?$ReadOnlyArray<Function>) => Function);
partial<R>(func: (...$ReadOnlyArray<any>) => R, ...partials: $ReadOnlyArray<any>): (...Array<any>) => R;
partialRight:
& (<R>(func: (...$ReadOnlyArray<any>) => R, ...partials: $ReadOnlyArray<any>) => ((...Array<any>) => R))
& (<R>(func: (...$ReadOnlyArray<any>) => R, partials: $ReadOnlyArray<any>) => ((...Array<any>) => R));
rearg:
& ((func: Function, ...indexes: $ReadOnlyArray<number>) => Function)
& ((func: Function, indexes: $ReadOnlyArray<number>) => Function);
rest(func: Function, start?: number): Function;
spread(func: Function): Function;
throttle<F: (...$ReadOnlyArray<any>) => any>(
func: F,
wait?: number,
options?: ThrottleOptions
): F & Cancelable;
unary<F: (...$ReadOnlyArray<any>) => any>(func: F): F;
wrap(value?: any, wrapper?: ?Function): Function;
// Lang
castArray:
& (() => Array<any>)
& (<T: void | null | number | string | {...}>(value: T) => Array<T>)
& (<T: Array<any>>(value: T) => T);
clone<T>(value: T): T;
cloneDeep<T>(value: T): T;
cloneDeepWith<T, U>(
value: T,
customizer?: ?(value: T, key: number | string, object: T, stack: any) => U
): U;
cloneWith<T, U>(
value: T,
customizer?: ?(value: T, key: number | string, object: T, stack: any) => U
): U;
conformsTo<T: ReadOnlyIndexerObject<mixed>>(
source: T,
predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>
): boolean;
eq(value: any, other: any): boolean;
gt(value: any, other: any): boolean;
gte(value: any, other: any): boolean;
isArguments:
& ((value: void | null) => false)
& ((value: any) => boolean);
isArray:
& ((value: $ReadOnlyArray<any>) => true)
& ((value: any) => false);
isArrayBuffer:
& ((value: ArrayBuffer) => true)
& ((value: any) => false);
isArrayLike:
& ((value: $ReadOnlyArray<any> | string | { length: number, ... }) => true)
& ((value: any) => false);
isArrayLikeObject:
& ((value: { length: number, ... } | $ReadOnlyArray<any>) => true)
& ((value: any) => false);
isBoolean:
& ((value: boolean) => true)
& ((value: any) => false);
isBuffer:
& ((value: void | null) => false)
& ((value: any) => boolean);
isDate:
& ((value: Date) => true)
& ((value: any) => false);
isElement:
& ((value: Element) => true)
& ((value: any) => false);
isEmpty:
& ((value: void | null | "" | {...} | [] | number | boolean) => true)
& ((value: any) => boolean);
isEqual(value: any, other: any): boolean;
isEqualWith<T, U>(
value?: ?T,
other?: ?U,
customizer?: ?(
objValue: any,
otherValue: any,
key: number | string,
object: T,
other: U,
stack: any
) => boolean | void
): boolean;
isError:
& ((value: Error) => true)
& ((value: any) => false);
isFinite:
& ((value: number) => boolean)
& ((value: any) => false);
isFunction(value: any): boolean;
isInteger:
& ((value: number) => boolean)
& ((value: any) => false);
isLength:
& ((value: void | null) => false)
& ((value: any) => boolean);
isMap:
& ((value: Map<any, any>) => true)
& ((value: any) => false);
isMatch(object?: ?Object, source?: ?Object): boolean;
isMatchWith<T: Object, U: Object>(
object?: ?T,
source?: ?U,
customizer?: ?(
objValue: any,
srcValue: any,
key: number | string,
object: T,
source: U
) => boolean | void
): boolean;
isNaN:
& ((value: number) => boolean)
& ((value: any) => false);
isNative:
& ((value: number | string | void | null | Object) => false)
& ((value: any) => boolean);
isNil:
& ((value: void | null) => true)
& ((value: any) => false);
isNull:
& ((value: null) => true)
& ((value: any) => false);
isNumber:
& ((value: number) => true)
& ((value: any) => false);
isObject: (value: any) => boolean;
isObjectLike:
& ((value: void | null) => false)
& ((value: any) => boolean);
isPlainObject: (value: any) => boolean;
isRegExp:
& ((value: RegExp) => true)
& ((value: any) => false);
isSafeInteger:
& ((value: number) => boolean)
& ((value: any) => false);
isSet:
& ((value: Set<any>) => true)
& ((value: any) => false);
isString:
& ((value: string) => true)
& ((value: any) => false);
isSymbol:
& ((value: Symbol) => true)
& ((value: any) => false);
isTypedArray:
& ((value: $TypedArray) => true)
& ((value: any) => false);
isUndefined:
& ((value: void) => true)
& ((value: any) => false);
isWeakMap:
& ((value: WeakMap<any, any>) => true)
& ((value: any) => false);
isWeakSet:
& ((value: WeakSet<any>) => true)
& ((value: any) => false);
lt(value: any, other: any): boolean;
lte(value: any, other: any): boolean;
toArray(value: any): Array<any>;
toFinite:
& ((value: void | null) => 0)
& ((value: any) => number);
toInteger:
& ((value: void | null) => 0)
& ((value: any) => number);
toLength:
& ((value: void | null) => 0)
& ((value: any) => number);
toNumber:
& ((value: void | null) => 0)
& ((value: any) => number);
toPlainObject(value: any): Object;
toSafeInteger:
& ((value: void | null) => 0)
& ((value: any) => number);
toString:
& ((value: void | null) => "")
& ((value: any) => string);
// Math
add(augend: number, addend: number): number;
ceil(number: number, precision?: number): number;
divide(dividend: number, divisor: number): number;
floor(number: number, precision?: number): number;
max<T>(array: ?$ReadOnlyArray<T>): T;
maxBy<T>(array: ?$ReadOnlyArray<T>, iteratee?: Iteratee<T>): T;
mean(array: $ReadOnlyArray<*>): number;
meanBy<T>(array: $ReadOnlyArray<T>, iteratee?: Iteratee<T>): number;
min<T>(array: ?$ReadOnlyArray<T>): T;
minBy<T>(array: ?$ReadOnlyArray<T>, iteratee?: Iteratee<T>): T;
multiply(multiplier: number, multiplicand: number): number;
round(number: number, precision?: number): number;
subtract(minuend: number, subtrahend: number): number;
sum(array: $ReadOnlyArray<*>): number;
sumBy<T>(array: $ReadOnlyArray<T>, iteratee?: Iteratee<T>): number;
// number
clamp:
& ((number?: number, lower?: ?number, upper?: ?number) => number)
& ((number: ?number, lower?: ?number, upper?: ?number) => 0);
inRange(number: number, start?: number, end: number): boolean;
random(lower?: number, upper?: number, floating?: boolean): number;
// Object
assign(object?: ?Object, ...sources?: $ReadOnlyArray<?Object>): Object;
assignIn:
& (() => {...})
& (<A, B>(a: A, b: B) => A & B)
& (<A, B, C>(a: A, b: B, c: C) => A & B & C)
& (<A, B, C, D>(a: A, b: B, c: C, d: D) => A & B & C & D)
& (<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E) => A & B & C & D & E);
assignInWith:
& (() => {...})
& (<T: Object, A: Object>(
object: T,
s1: A,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void
) => Object)
& (<T: Object, A: Object, B: Object>(
object: T,
s1: A,
s2: B,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B
) => any | void
) => Object)
& (<T: Object, A: Object, B: Object, C: Object>(
object: T,
s1: A,
s2: B,
s3: C,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B | C
) => any | void
) => Object)
& (<T: Object, A: Object, B: Object, C: Object, D: Object>(
object: T,
s1: A,
s2: B,
s3: C,
s4: D,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B | C | D
) => any | void
) => Object);
assignWith:
& (() => {...})
& (<T: Object, A: Object>(
object: T,
s1: A,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void
) => Object)
& (<T: Object, A: Object, B: Object>(
object: T,
s1: A,
s2: B,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B
) => any | void
) => Object)
& (<T: Object, A: Object, B: Object, C: Object>(
object: T,
s1: A,
s2: B,
s3: C,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B | C
) => any | void
) => Object)
& (<T: Object, A: Object, B: Object, C: Object, D: Object>(
object: T,
s1: A,
s2: B,
s3: C,
s4: D,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B | C | D
) => any | void
) => Object);
at:
& ((object?: ?Object, ...paths: $ReadOnlyArray<string>) => Array<any>)
& ((object?: ?Object, paths: $ReadOnlyArray<string>) => Array<any>);
create:
& ((prototype: void | null, properties: void | null) => {...})
& (<T>(prototype: T, properties: Object) => T)
& ((prototype: any, properties: void | null) => {...});
defaults(object?: ?Object, ...sources?: $ReadOnlyArray<?Object>): Object;
defaultsDeep(object?: ?Object, ...sources?: $ReadOnlyArray<?Object>): Object;
// alias for _.toPairs
entries(object?: ?Object): Array<[string, any]>;
// alias for _.toPairsIn
entriesIn(object?: ?Object): Array<[string, any]>;
// alias for _.assignIn
extend:
& (<A, B>(a?: ?A, b?: ?B) => A & B)
& (<A, B, C>(a: A, b: B, c: C) => A & B & C)
& (<A, B, C, D>(a: A, b: B, c: C, d: D) => A & B & C & D)
& (<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E) => A & B & C & D & E);
// alias for _.assignInWith
extendWith:
& (<T: Object, A: Object>(
object?: ?T,
s1?: ?A,
customizer?: ?(
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void
) => Object)
& (<T: Object, A: Object, B: Object>(
object: T,
s1: A,
s2: B,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B
) => any | void
) => Object)
& (<T: Object, A: Object, B: Object, C: Object>(
object: T,
s1: A,
s2: B,
s3: C,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B | C
) => any | void
) => Object)
& (<T: Object, A: Object, B: Object, C: Object, D: Object>(
object: T,
s1: A,
s2: B,
s3: C,
s4: D,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B | C | D
) => any | void
) => Object);
findKey:
& (<A, T: ReadOnlyIndexerObject<A>>(
object: T,
predicate?: ?OPredicate<A, T>
) => string | void)
& (<A, T: ReadOnlyIndexerObject<A>>(
object: void | null,
predicate?: ?OPredicate<A, T>
) => void);
findLastKey:
& (<A, T: ReadOnlyIndexerObject<A>>(
object: T,
predicate?: ?OPredicate<A, T>
) => string | void)
& (<A, T: ReadOnlyIndexerObject<A>>(
object: void | null,
predicate?: ?OPredicate<A, T>
) => void);
forIn:
& ((object: Object, iteratee?: ?OIteratee<*>) => Object)
& ((object: void | null, iteratee?: ?OIteratee<*>) => null);
forInRight:
& ((object: Object, iteratee?: ?OIteratee<*>) => Object)
& ((object: void | null, iteratee?: ?OIteratee<*>) => null);
forOwn:
& ((object: Object, iteratee?: ?OIteratee<*>) => Object)
& ((object: void | null, iteratee?: ?OIteratee<*>) => null);
forOwnRight:
& ((object: Object, iteratee?: ?OIteratee<*>) => Object)
& ((object: void | null, iteratee?: ?OIteratee<*>) => null);
functions(object?: ?Object): Array<string>;
functionsIn(object?: ?Object): Array<string>;
get(
object?: ?Object | ?$ReadOnlyArray<any> | void | null,
path?: ?Path,
defaultValue?: any
): any;
has:
& ((object: Object, path: Path) => boolean)
& ((object: Object, path: void | null) => false)
& ((object: void | null, path?: ?Path) => false);
hasIn:
& ((object: Object, path: Path) => boolean)
& ((object: Object, path: void | null) => false)
& ((object: void | null, path?: ?Path) => false);
invert:
& ((object: Object, multiVal?: ?boolean) => Object)
& ((object: void | null, multiVal?: ?boolean) => {...});
invertBy:
& ((object: Object, iteratee?: ?Function) => Object)
& ((object: void | null, iteratee?: ?Function) => {...});
invoke(
object?: ?Object,
path?: ?Path,
...args?: $ReadOnlyArray<any>
): any;
keys:
& (<K>(object?: ?ReadOnlyIndexerObject<any, K>) => Array<K>)
& ((object?: ?Object) => Array<string>);
keysIn(object?: ?Object): Array<string>;
mapKeys:
& ((object: Object, iteratee?: ?OIteratee<*>) => Object)
& ((object: void | null, iteratee?: ?OIteratee<*>) => {...});
mapValues:
& ((object: Object, iteratee?: ?OIteratee<*>) => Object)
& ((object: void | null, iteratee?: ?OIteratee<*>) => {...});
merge(object?: ?Object, ...sources?: $ReadOnlyArray<?Object>): Object;
mergeWith:
& (() => {...})
& (<T: Object, A: Object>(
object: T,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void
) => Object)
& (<T: Object, A: Object, B: Object>(
object: T,
s1: A,
s2: B,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B
) => any | void
) => Object)
& (<T: Object, A: Object, B: Object, C: Object>(
object: T,
s1: A,
s2: B,
s3: C,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B | C
) => any | void
) => Object)
& (<T: Object, A: Object, B: Object, C: Object, D: Object>(
object: T,
s1: A,
s2: B,
s3: C,
s4: D,
customizer?: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B | C | D
) => any | void
) => Object);
omit:
& ((object?: ?Object, ...props: $ReadOnlyArray<string>) => Object)
& ((object?: ?Object, props: $ReadOnlyArray<string>) => Object);
omitBy:
& (<A, T: ReadOnlyIndexerObject<A>>(
object: $ReadOnly<T>,
predicate?: ?OPredicate<A, T>
) => Object)
& (<A, T>(object: void | null, predicate?: ?OPredicate<A, T>) => {...});
pick:
& ((object?: ?Object, ...props: $ReadOnlyArray<string>) => Object)
& ((object?: ?Object, props: $ReadOnlyArray<string>) => Object);
pickBy:
& (<A, T: ReadOnlyIndexerObject<A>>(
object: $ReadOnly<T>,
predicate?: ?OPredicate<A, T>
) => Object)
& (<A, T>(object: void | null, predicate?: ?OPredicate<A, T>) => {...});
result(
object?: ?Object,
path?: ?Path,
defaultValue?: any
): any;
set:
& ((object: Object, path?: ?Path, value: any) => Object)
& (<T: void | null>(
object: T,
path?: ?Path,
value?: ?any
) => T);
setWith:
& (<T>(
object: T,
path?: ?Path,
value: any,
customizer?: (nsValue: any, key: string, nsObject: T) => any
) => Object)
& (<T: void | null>(
object: T,
path?: ?Path,
value?: ?any,
customizer?: ?(nsValue: any, key: string, nsObject: T) => any
) => T);
toPairs(object?: ?Object | $ReadOnlyArray<*>): Array<[string, any]>;
toPairsIn(object?: ?Object): Array<[string, any]>;
transform:
& ((
collection: Object | $ReadOnlyArray<any>,
iteratee?: ?OIteratee<*>,
accumulator?: any
) => any)
& ((
collection: void | null,
iteratee?: ?OIteratee<*>,
accumulator?: ?any
) => {...});
unset:
& ((object: void | null, path?: ?Path) => true)
& ((object: Object, path?: ?Path) => boolean);
update:
& ((object: Object, path: Path, updater: Function) => Object)
& (<T: void | null>(
object: T,
path?: ?Path,
updater?: ?Function
) => T);
updateWith:
& ((
object: Object,
path?: ?Path,
updater?: ?Function,
customizer?: ?Function
) => Object)
& (<T: void | null>(
object: T,
path?: ?Path,
updater?: ?Function,
customizer?: ?Function
) => T);
values(object?: ?Object): Array<any>;
valuesIn(object?: ?Object): Array<any>;
// Seq
// harder to read, but this is _()
(value: any): any;
chain<T>(value: T): any;
tap<T>(value: T, interceptor: (value: T) => any): T;
thru<T1, T2>(value: T1, interceptor: (value: T1) => T2): T2;
// TODO: _.prototype.*
// String
camelCase:
& ((string: string) => string)
& ((string: void | null) => "");
capitalize:
& ((string: string) => string)
& ((string: void | null) => "");
deburr:
& ((string: string) => string)
& ((string: void | null) => "");
endsWith:
& ((string: string, target?: string, position?: ?number) => boolean)
& ((string: void | null, target?: ?string, position?: ?number) => false);
escape:
& ((string: string) => string)
& ((string: void | null) => "");
escapeRegExp:
& ((string: string) => string)
& ((string: void | null) => "");
kebabCase:
& ((string: string) => string)
& ((string: void | null) => "");
lowerCase:
& ((string: string) => string)
& ((string: void | null) => "");
lowerFirst:
& ((string: string) => string)
& ((string: void | null) => "");
pad(string?: ?string, length?: ?number, chars?: ?string): string;
padEnd(string?: ?string, length?: ?number, chars?: ?string): string;
padStart(string?: ?string, length?: ?number, chars?: ?string): string;
parseInt(string: string, radix?: ?number): number;
repeat:
& ((string: string, n?: ?number) => string)
& ((string: void | null, n?: ?number) => "");
replace:
& ((
string: string,
pattern: RegExp | string,
replacement: ((string: string) => string) | string
) => string)
& ((
string: void | null,
pattern?: ?RegExp | ?string,
replacement: ?((string: string) => string) | ?string
) => "");
snakeCase:
& ((string: string) => string)
& ((string: void | null) => "");
split(
string?: ?string,
separator?: ?RegExp | ?string,
limit?: ?number
): Array<string>;
startCase:
& ((string: string) => string)
& ((string: void | null) => "");
startsWith:
& ((string: string, target?: string, position?: number) => boolean)
& ((
string: void | null,
target?: ?string,
position?: ?number
) => false);
template(string?: ?string, options?: ?TemplateSettings): Function;
toLower:
& ((string: string) => string)
& ((string: void | null) => "");
toUpper:
& ((string: string) => string)
& ((string: void | null) => "");
trim:
& ((string: string, chars?: string) => string)
& ((string: void | null, chars?: ?string) => "");
trimEnd:
& ((string: string, chars?: ?string) => string)
& ((string: void | null, chars?: ?string) => "");
trimStart:
& ((string: string, chars?: ?string) => string)
& ((string: void | null, chars?: ?string) => "");
truncate:
& ((string: string, options?: TruncateOptions) => string)
& ((string: void | null, options?: ?TruncateOptions) => "");
unescape:
& ((string: string) => string)
& ((string: void | null) => "");
upperCase:
& ((string: string) => string)
& ((string: void | null) => "");
upperFirst:
& ((string: string) => string)
& ((string: void | null) => "");
words(string?: ?string, pattern?: ?RegExp | ?string): Array<string>;
// Util
attempt(func: Function, ...args: $ReadOnlyArray<any>): any;
bindAll:
& ((object: Object, methodNames?: ?$ReadOnlyArray<string>) => Object)
& (<T: void | null>(object: T, methodNames?: ?$ReadOnlyArray<string>) => T)
& ((object: Object, ...methodNames: $ReadOnlyArray<string>) => Object);
cond(pairs?: ?NestedArray<Function>): Function;
conforms(source?: ?Object): Function;
constant<T>(value: T): () => T;
defaultTo:
& (<T1: void | null, T2>(value: T1, defaultValue: T2) => T2)
& (<T1: string | boolean, T2>(
value: T1,
defaultValue: T2
) => T1)
// NaN is a number instead of its own type, otherwise it would behave like null/void
& (<T1: number, T2>(value: T1, defaultValue: T2) => T1 | T2);
flow: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
flowRight: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
identity<T>(value: T): T;
iteratee(func?: any): Function;
matches(source?: ?Object): Function;
matchesProperty(path?: ?Path, srcValue: any): Function;
method(path?: ?Path, ...args?: $ReadOnlyArray<any>): Function;
methodOf(object?: ?Object, ...args?: $ReadOnlyArray<any>): Function;
mixin<T: Function | Object>(
object?: T,
source: Object,
options?: { chain: boolean, ... }
): T;
noConflict(): Lodash;
noop(...args: $ReadOnlyArray<mixed>): void;
nthArg(n?: ?number): Function;
over:
& ((...iteratees: $ReadOnlyArray<Function>) => Function)
& ((iteratees: $ReadOnlyArray<Function>) => Function);
overEvery:
& ((...predicates: $ReadOnlyArray<Function>) => Function)
& ((predicates: $ReadOnlyArray<Function>) => Function);
overSome:
& ((...predicates: $ReadOnlyArray<Function>) => Function)
& ((predicates: $ReadOnlyArray<Function>) => Function);
property(path?: ?Path): Function;
propertyOf(object?: ?Object): Function;
range:
& ((start: number, end: number, step?: number) => Array<number>)
& ((end: number, step?: number) => Array<number>);
rangeRight:
& ((start?: ?number, end?: ?number, step?: ?number) => Array<number>)
& (end?: ?number, step?: ?number) => Array<number>;
runInContext(context?: ?Object): Function;
stubArray(): Array<*>;
stubFalse(): false;
stubObject(): {...};
stubString(): "";
stubTrue(): true;
times:
& ((n?: ?number, ...rest?: $ReadOnlyArray<void | null>) => Array<number>)
& (<T>(n: number, iteratee: (i: number) => T) => Array<T>);
toPath(value: any): Array<string>;
uniqueId(prefix?: ?string): string;
// Properties
VERSION: string;
templateSettings: TemplateSettings;
|}
declare module.exports: Lodash;
}
declare module "lodash/fp" {
declare type Path = $ReadOnlyArray<string | number> | string | number;
declare type __CurriedFunction1<A, R, AA: A> = (...r: [AA]) => R;
declare type CurriedFunction1<A, R> = __CurriedFunction1<A, R, *>;
declare type __CurriedFunction2<A, B, R, AA: A, BB: B> = ((
...r: [AA]
) => CurriedFunction1<BB, R>) &
((...r: [AA, BB]) => R);
declare type CurriedFunction2<A, B, R> = __CurriedFunction2<A, B, R, *, *>;
declare type __CurriedFunction3<A, B, C, R, AA: A, BB: B, CC: C> = ((
...r: [AA]
) => CurriedFunction2<BB, CC, R>) &
((...r: [AA, BB]) => CurriedFunction1<CC, R>) &
((...r: [AA, BB, CC]) => R);
declare type CurriedFunction3<A, B, C, R> = __CurriedFunction3<
A,
B,
C,
R,
*,
*,
*
>;
declare type __CurriedFunction4<
A,
B,
C,
D,
R,
AA: A,
BB: B,
CC: C,
DD: D
> = ((...r: [AA]) => CurriedFunction3<BB, CC, DD, R>) &
((...r: [AA, BB]) => CurriedFunction2<CC, DD, R>) &
((...r: [AA, BB, CC]) => CurriedFunction1<DD, R>) &
((...r: [AA, BB, CC, DD]) => R);
declare type CurriedFunction4<A, B, C, D, R> = __CurriedFunction4<
A,
B,
C,
D,
R,
*,
*,
*,
*
>;
declare type __CurriedFunction5<
A,
B,
C,
D,
E,
R,
AA: A,
BB: B,
CC: C,
DD: D,
EE: E
> = ((...r: [AA]) => CurriedFunction4<BB, CC, DD, EE, R>) &
((...r: [AA, BB]) => CurriedFunction3<CC, DD, EE, R>) &
((...r: [AA, BB, CC]) => CurriedFunction2<DD, EE, R>) &
((...r: [AA, BB, CC, DD]) => CurriedFunction1<EE, R>) &
((...r: [AA, BB, CC, DD, EE]) => R);
declare type CurriedFunction5<A, B, C, D, E, R> = __CurriedFunction5<
A,
B,
C,
D,
E,
R,
*,
*,
*,
*,
*
>;
declare type __CurriedFunction6<
A,
B,
C,
D,
E,
F,
R,
AA: A,
BB: B,
CC: C,
DD: D,
EE: E,
FF: F
> = ((...r: [AA]) => CurriedFunction5<BB, CC, DD, EE, FF, R>) &
((...r: [AA, BB]) => CurriedFunction4<CC, DD, EE, FF, R>) &
((...r: [AA, BB, CC]) => CurriedFunction3<DD, EE, FF, R>) &
((...r: [AA, BB, CC, DD]) => CurriedFunction2<EE, FF, R>) &
((...r: [AA, BB, CC, DD, EE]) => CurriedFunction1<FF, R>) &
((...r: [AA, BB, CC, DD, EE, FF]) => R);
declare type CurriedFunction6<A, B, C, D, E, F, R> = __CurriedFunction6<
A,
B,
C,
D,
E,
F,
R,
*,
*,
*,
*,
*,
*
>;
declare type Curry = (<A, R>((...r: [A]) => R) => CurriedFunction1<A, R>) &
(<A, B, R>((...r: [A, B]) => R) => CurriedFunction2<A, B, R>) &
(<A, B, C, R>((...r: [A, B, C]) => R) => CurriedFunction3<A, B, C, R>) &
(<A, B, C, D, R>(
(...r: [A, B, C, D]) => R
) => CurriedFunction4<A, B, C, D, R>) &
(<A, B, C, D, E, R>(
(...r: [A, B, C, D, E]) => R
) => CurriedFunction5<A, B, C, D, E, R>) &
(<A, B, C, D, E, F, R>(
(...r: [A, B, C, D, E, F]) => R
) => CurriedFunction6<A, B, C, D, E, F, R>);
declare type UnaryFn<A, R> = (a: A) => R;
declare type TemplateSettings = {
escape?: RegExp,
evaluate?: RegExp,
imports?: Object,
interpolate?: RegExp,
variable?: string,
...
};
declare type TruncateOptions = {
length?: number,
omission?: string,
separator?: RegExp | string,
...
};
declare type DebounceOptions = {
leading?: boolean,
maxWait?: number,
trailing?: boolean,
...
};
declare type ThrottleOptions = {
leading?: boolean,
trailing?: boolean,
...
};
declare type Key = string | number;
declare type ReadOnlyIndexerObject<V, K = Key> = $ReadOnly<{ [id: K]: V, ... }>
declare type NestedArray<V> = Array<Array<V>>;
declare type Collection<V, K = Key> = $ReadOnlyArray<V> | ReadOnlyIndexerObject<V, K>;
declare type matchesIterateeShorthand = { [Key]: any, ... };
declare type matchesPropertyIterateeShorthand = [string, any];
declare type propertyIterateeShorthand = string;
declare type OPredicate<A> =
| ((value: A) => any)
| matchesIterateeShorthand
| matchesPropertyIterateeShorthand
| propertyIterateeShorthand;
declare type IterateeWithResult<V, R> =
| ((value: V) => R)
| string;
declare type OIterateeWithResult<V, R> =
| ReadOnlyIndexerObject<V>
| IterateeWithResult<V, R>;
declare type OIteratee<O> = OIterateeWithResult<any, any>;
declare type Predicate<T> =
| ((value: T) => any)
| matchesIterateeShorthand
| matchesPropertyIterateeShorthand
| propertyIterateeShorthand;
declare type _ValueOnlyIteratee<T> = (value: T) => mixed;
declare type ValueOnlyIteratee<T> = _ValueOnlyIteratee<T> | string;
declare type _Iteratee<T> = (item: T) => mixed;
declare type Iteratee<T> = _Iteratee<T> | Object | string;
declare type AFlatMapIteratee<T, U> =
| ((item: T) => Array<U>)
| string;
declare type OFlatMapIteratee<T, U> = IterateeWithResult<T, Array<U>>;
declare type Comparator<T> = (item: T, item2: T) => boolean;
declare type MapIterator<T, U> = ((item: T) => U) | propertyIterateeShorthand;
declare type OMapIterator<T, U> =
| ((item: T) => U)
| propertyIterateeShorthand;
declare type Lodash = {|
// Array
chunk:
& (<T>(size: number) => ((array: $ReadOnlyArray<T>) => Array<Array<T>>))
& (<T>(size: number, array: $ReadOnlyArray<T>) => Array<Array<T>>);
compact<T, N: ?T>(array?: ?$ReadOnlyArray<N>): Array<T>;
concat:
& (<T, U, A: Array<T> | T, B: Array<U> | U>(
base: A
) => (elements: B) => Array<T | U>)
& (<T, U, A: Array<T> | T, B: Array<U> | U>(
base: A,
elements: B
) => Array<T | U>);
difference:
& (<T>(values: $ReadOnlyArray<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(values: $ReadOnlyArray<T>, array: $ReadOnlyArray<T>) => Array<T>);
differenceBy:
& (<T>(
iteratee: ValueOnlyIteratee<T>
) => (((values: $ReadOnlyArray<T>) => (array: $ReadOnlyArray<T>) => Array<T>) &
((values: $ReadOnlyArray<T>, array: $ReadOnlyArray<T>) => Array<T>)))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
values: $ReadOnlyArray<T>
) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
values: $ReadOnlyArray<T>,
array: $ReadOnlyArray<T>
) => Array<T>);
differenceWith:
& (<T>(
comparator: Comparator<T>
) => (((first: $ReadOnlyArray<T>) => (second: $ReadOnlyArray<T>) => Array<T>) &
((first: $ReadOnlyArray<T>, second: $ReadOnlyArray<T>) => Array<T>)))
& (<T>(
comparator: Comparator<T>,
first: $ReadOnlyArray<T>
) => ((second: $ReadOnlyArray<T>) => Array<T>))
& (<T>(
comparator: Comparator<T>,
first: $ReadOnlyArray<T>,
second: $ReadOnlyArray<T>
) => Array<T>);
drop:
& (<T>(n: number) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(n: number, array: $ReadOnlyArray<T>) => Array<T>);
dropLast:
& (<T>(n: number) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(n: number, array: $ReadOnlyArray<T>) => Array<T>);
dropRight:
& (<T>(n: number) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(n: number, array: $ReadOnlyArray<T>) => Array<T>);
dropRightWhile:
& (<T>(predicate: Predicate<T>) => (array: $ReadOnlyArray<T>) => Array<T>)
& (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => Array<T>);
dropWhile:
& (<T>(predicate: Predicate<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => Array<T>);
dropLastWhile:
& (<T>(predicate: Predicate<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => Array<T>);
fill:
& (<T, U>(
start: number
) => (((
end: number
) => ((value: U) => (array: Array<T>) => Array<T | U>) &
((value: U, array: Array<T>) => Array<T | U>)) &
((end: number, value: U) => (array: Array<T>) => Array<T | U>) &
((end: number, value: U, array: Array<T>) => Array<T | U>)))
& (<T, U>(
start: number,
end: number
) => (((value: U) => (array: Array<T>) => Array<T | U>) &
((value: U, array: Array<T>) => Array<T | U>)))
& (<T, U>(
start: number,
end: number,
value: U
) => ((array: Array<T>) => Array<T | U>))
& (<T, U>(
start: number,
end: number,
value: U,
array: Array<T>
) => Array<T | U>);
findIndex:
& (<T>(predicate: Predicate<T>) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => number);
findIndexFrom:
& (<T>(
predicate: Predicate<T>
) => (((fromIndex: number) => (array: $ReadOnlyArray<T>) => number) &
((fromIndex: number, array: $ReadOnlyArray<T>) => number)))
& (<T>(
predicate: Predicate<T>,
fromIndex: number
) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(
predicate: Predicate<T>,
fromIndex: number,
array: $ReadOnlyArray<T>
) => number);
findLastIndex:
& (<T>(
predicate: Predicate<T>
) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => number);
findLastIndexFrom:
& (<T>(
predicate: Predicate<T>
) => (((fromIndex: number) => (array: $ReadOnlyArray<T>) => number) &
((fromIndex: number, array: $ReadOnlyArray<T>) => number)))
& (<T>(
predicate: Predicate<T>,
fromIndex: number
) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(
predicate: Predicate<T>,
fromIndex: number,
array: $ReadOnlyArray<T>
) => number);
// alias of _.head
first<T>(array: $ReadOnlyArray<T>): T;
flatten<T, X>(array: $ReadOnlyArray<$ReadOnlyArray<T> | X>): Array<T | X>;
unnest<T, X>(array: $ReadOnlyArray<$ReadOnlyArray<T> | X>): Array<T | X>;
flattenDeep<T>(array: $ReadOnlyArray<any>): Array<T>;
flattenDepth:
& ((depth: number) => ((array: $ReadOnlyArray<any>) => Array<any>))
& ((depth: number, array: $ReadOnlyArray<any>) => Array<any>);
fromPairs<A, B>(pairs: $ReadOnlyArray<[A, B]>): {| [key: A]: B |};
head<T>(array: $ReadOnlyArray<T>): T;
indexOf:
& (<T>(value: T) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(value: T, array: $ReadOnlyArray<T>) => number);
indexOfFrom:
& (<T>(
value: T
) => (((fromIndex: number) => (array: $ReadOnlyArray<T>) => number) &
((fromIndex: number, array: $ReadOnlyArray<T>) => number)))
& (<T>(value: T, fromIndex: number) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(value: T, fromIndex: number, array: $ReadOnlyArray<T>) => number);
initial<T>(array: $ReadOnlyArray<T>): Array<T>;
init<T>(array: $ReadOnlyArray<T>): Array<T>;
intersection:
& (<T>(a1: $ReadOnlyArray<T>) => ((a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
intersectionBy:
& (<T>(
iteratee: ValueOnlyIteratee<T>
) => (((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>)))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
a1: $ReadOnlyArray<T>
) => ((a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>
) => Array<T>);
intersectionWith:
& (<T>(
comparator: Comparator<T>
) => ((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(
comparator: Comparator<T>,
a1: $ReadOnlyArray<T>
) => ((a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(
comparator: Comparator<T>,
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>
) => Array<T>);
join:
& (<T>(separator: string) => ((array: $ReadOnlyArray<T>) => string))
& (<T>(separator: string, array: $ReadOnlyArray<T>) => string);
last<T>(array: $ReadOnlyArray<T>): T;
lastIndexOf:
& (<T>(value: T) => (array: $ReadOnlyArray<T>) => number)
& (<T>(value: T, array: $ReadOnlyArray<T>) => number);
lastIndexOfFrom:
& (<T>(
value: T
) => (((fromIndex: number) => (array: $ReadOnlyArray<T>) => number) &
((fromIndex: number, array: $ReadOnlyArray<T>) => number)))
& (<T>(
value: T,
fromIndex: number
) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(value: T, fromIndex: number, array: $ReadOnlyArray<T>) => number);
nth:
& (<T>(n: number) => ((array: $ReadOnlyArray<T>) => T))
& (<T>(n: number, array: $ReadOnlyArray<T>) => T);
pull:
& (<T>(value: T) => ((array: Array<T>) => Array<T>))
& (<T>(value: T, array: Array<T>) => Array<T>);
pullAll:
& (<T>(values: $ReadOnlyArray<T>) => ((array: Array<T>) => Array<T>))
& (<T>(values: $ReadOnlyArray<T>, array: Array<T>) => Array<T>);
pullAllBy:
& (<T>(
iteratee: ValueOnlyIteratee<T>
) => (((values: $ReadOnlyArray<T>) => (array: Array<T>) => Array<T>) &
((values: $ReadOnlyArray<T>, array: Array<T>) => Array<T>)))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
values: $ReadOnlyArray<T>
) => ((array: Array<T>) => Array<T>))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
values: $ReadOnlyArray<T>,
array: Array<T>
) => Array<T>);
pullAllWith:
& (<T>(
comparator: Function
) => (((values: Array<T>) => (array: Array<T>) => Array<T>) &
((values: Array<T>, array: Array<T>) => Array<T>)))
& (<T>(comparator: Function, values: Array<T>) => ((array: Array<T>) => Array<T>))
& (<T>(comparator: Function, values: Array<T>, array: Array<T>) => Array<T>);
pullAt:
& (<T>(indexed: Array<number>) => ((array: Array<T>) => Array<T>))
& (<T>(indexed: Array<number>, array: Array<T>) => Array<T>);
remove:
& (<T>(predicate: Predicate<T>) => ((array: Array<T>) => Array<T>))
& (<T>(predicate: Predicate<T>, array: Array<T>) => Array<T>);
reverse<T>(array: Array<T>): Array<T>;
slice:
& (<T>(
start: number
) => (((end: number) => (array: $ReadOnlyArray<T>) => Array<T>) &
((end: number, array: $ReadOnlyArray<T>) => Array<T>)))
& (<T>(start: number, end: number) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(start: number, end: number, array: $ReadOnlyArray<T>) => Array<T>);
sortedIndex:
& (<T>(value: T) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(value: T, array: $ReadOnlyArray<T>) => number);
sortedIndexBy:
& (<T>(
iteratee: ValueOnlyIteratee<T>
) => (((value: T) => (array: $ReadOnlyArray<T>) => number) &
((value: T, array: $ReadOnlyArray<T>) => number)))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
value: T
) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
value: T,
array: $ReadOnlyArray<T>
) => number);
sortedIndexOf:
& (<T>(value: T) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(value: T, array: $ReadOnlyArray<T>) => number);
sortedLastIndex:
& (<T>(value: T) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(value: T, array: $ReadOnlyArray<T>) => number);
sortedLastIndexBy:
& (<T>(
iteratee: ValueOnlyIteratee<T>
) => (((value: T) => (array: $ReadOnlyArray<T>) => number) &
((value: T, array: $ReadOnlyArray<T>) => number)))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
value: T
) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
value: T,
array: $ReadOnlyArray<T>
) => number);
sortedLastIndexOf:
& (<T>(value: T) => ((array: $ReadOnlyArray<T>) => number))
& (<T>(value: T, array: $ReadOnlyArray<T>) => number);
sortedUniq<T>(array: $ReadOnlyArray<T>): Array<T>;
sortedUniqBy<T>(iteratee: ValueOnlyIteratee<T>, array: $ReadOnlyArray<T>): Array<T>;
tail<T>(array: $ReadOnlyArray<T>): Array<T>;
take:
& (<T>(n: number) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(n: number, array: $ReadOnlyArray<T>) => Array<T>);
takeRight:
& (<T>(n: number) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(n: number, array: $ReadOnlyArray<T>) => Array<T>);
takeLast:
& (<T>(n: number) => (array: $ReadOnlyArray<T>) => Array<T>)
& (<T>(n: number, array: $ReadOnlyArray<T>) => Array<T>);
takeRightWhile:
& (<T>(predicate: Predicate<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => Array<T>);
takeLastWhile:
& (<T>(predicate: Predicate<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => Array<T>);
takeWhile:
& (<T>(predicate: Predicate<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(predicate: Predicate<T>, array: $ReadOnlyArray<T>) => Array<T>);
union:
& (<T>(a1: $ReadOnlyArray<T>) => ((a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
unionBy:
& (<T>(
iteratee: ValueOnlyIteratee<T>
) => (((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>)))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
a1: $ReadOnlyArray<T>
) => ((a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>
) => Array<T>);
unionWith:
& (<T>(
comparator: Comparator<T>
) => (((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>)))
& (<T>(
comparator: Comparator<T>,
a1: $ReadOnlyArray<T>
) => ((a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(
comparator: Comparator<T>,
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>
) => Array<T>);
uniq<T>(array: $ReadOnlyArray<T>): Array<T>;
uniqBy:
& (<T>(iteratee: ValueOnlyIteratee<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(iteratee: ValueOnlyIteratee<T>, array: $ReadOnlyArray<T>) => Array<T>);
uniqWith:
& (<T>(comparator: Comparator<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(comparator: Comparator<T>, array: $ReadOnlyArray<T>) => Array<T>);
unzip<T>(array: $ReadOnlyArray<T>): Array<T>;
unzipWith:
& (<T>(iteratee: Iteratee<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(iteratee: Iteratee<T>, array: $ReadOnlyArray<T>) => Array<T>);
without:
& (<T>(values: $ReadOnlyArray<T>) => ((array: $ReadOnlyArray<T>) => Array<T>))
& (<T>(values: $ReadOnlyArray<T>, array: $ReadOnlyArray<T>) => Array<T>);
xor:
& (<T>(a1: $ReadOnlyArray<T>) => ((a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
symmetricDifference:
& (<T>(a1: $ReadOnlyArray<T>) => ((a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
xorBy:
& (<T>(
iteratee: ValueOnlyIteratee<T>
) => (((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>)))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
a1: $ReadOnlyArray<T>
) => ((a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>
) => Array<T>);
symmetricDifferenceBy:
& (<T>(
iteratee: ValueOnlyIteratee<T>
) => ((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
a1: $ReadOnlyArray<T>
) => (a2: $ReadOnlyArray<T>) => Array<T>)
& (<T>(
iteratee: ValueOnlyIteratee<T>,
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>
) => Array<T>);
xorWith:
& (<T>(
comparator: Comparator<T>
) => (((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>)))
& (<T>(
comparator: Comparator<T>,
a1: $ReadOnlyArray<T>
) => ((a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(comparator: Comparator<T>, a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>);
symmetricDifferenceWith:
& (<T>(
comparator: Comparator<T>
) => (((a1: $ReadOnlyArray<T>) => (a2: $ReadOnlyArray<T>) => Array<T>) &
((a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>) => Array<T>)))
& (<T>(
comparator: Comparator<T>,
a1: $ReadOnlyArray<T>
) => ((a2: $ReadOnlyArray<T>) => Array<T>))
& (<T>(
comparator: Comparator<T>,
a1: $ReadOnlyArray<T>,
a2: $ReadOnlyArray<T>
) => Array<T>);
zip:
& (<A, B>(a1: $ReadOnlyArray<A>) => ((a2: $ReadOnlyArray<B>) => Array<[A, B]>))
& (<A, B>(a1: $ReadOnlyArray<A>, a2: $ReadOnlyArray<B>) => Array<[A, B]>);
zipAll(arrays: $ReadOnlyArray<$ReadOnlyArray<any>>): Array<any>;
zipObject:
& (<K, V>(props?: $ReadOnlyArray<K>) => ((values?: $ReadOnlyArray<V>) => { [key: K]: V, ... }))
& (<K, V>(props?: $ReadOnlyArray<K>, values?: $ReadOnlyArray<V>) => { [key: K]: V, ... });
zipObj:
& ((props: $ReadOnlyArray<any>) => ((values: $ReadOnlyArray<any>) => Object))
& ((props: $ReadOnlyArray<any>, values: $ReadOnlyArray<any>) => Object);
zipObjectDeep:
& ((props: $ReadOnlyArray<any>) => ((values: any) => Object))
& ((props: $ReadOnlyArray<any>, values: any) => Object);
zipWith:
& (<T>(
iteratee: Iteratee<T>
) => (((a1: NestedArray<T>) => (a2: NestedArray<T>) => Array<T>) &
((a1: NestedArray<T>, a2: NestedArray<T>) => Array<T>)))
& (<T>(
iteratee: Iteratee<T>,
a1: NestedArray<T>
) => ((a2: NestedArray<T>) => Array<T>))
& (<T>(
iteratee: Iteratee<T>,
a1: NestedArray<T>,
a2: NestedArray<T>
) => Array<T>);
// Collection
countBy:
& (<T>(
iteratee: ValueOnlyIteratee<T>
) => ((collection: Collection<T>) => { [string]: number, ... }))
& (<T>(
iteratee: ValueOnlyIteratee<T>,
collection: Collection<T>
) => { [string]: number, ... });
// alias of _.forEach
each:
& (<T>(
iteratee: Iteratee<T> | OIteratee<T>
) => ((collection: Collection<T>) => Array<T>))
& (<T>(
iteratee: Iteratee<T> | OIteratee<T>,
collection: Collection<T>
) => Array<T>);
// alias of _.forEachRight
eachRight:
& (<T>(
iteratee: Iteratee<T> | OIteratee<T>
) => ((collection: Collection<T>) => Array<T>))
& (<T>(
iteratee: Iteratee<T> | OIteratee<T>,
collection: Collection<T>
) => Array<T>);
every:
& (<T>(
iteratee: Iteratee<T> | OIteratee<T>
) => ((collection: Collection<T>) => boolean))
& (<T>(
iteratee: Iteratee<T> | OIteratee<T>,
collection: Collection<T>
) => boolean);
all:
& (<T>(
iteratee: Iteratee<T> | OIteratee<T>
) => ((collection: Collection<T>) => boolean))
& (<T>(
iteratee: Iteratee<T> | OIteratee<T>,
collection: Collection<T>
) => boolean);
filter:
& (<T>(
predicate: Predicate<T> | OPredicate<T>
) => ((collection: Collection<T>) => Array<T>))
& (<T>(
predicate: Predicate<T> | OPredicate<T>,
collection: Collection<T>
) => Array<T>);
find:
& (<T>(
predicate: Predicate<T> | OPredicate<T>
) => ((collection: Collection<T>) => T | void))
& (<T>(
predicate: Predicate<T> | OPredicate<T>,
collection: Collection<T>
) => (T | void));
findFrom:
& (<T>(
predicate: Predicate<T> | OPredicate<T>
) => (((
fromIndex: number
) => (collection: Collection<T>) => T | void) &
((
fromIndex: number,
collection: Collection<T>
) => T | void)))
& (<T>(
predicate: Predicate<T> | OPredicate<T>,
fromIndex: number
) => ((collection: Collection<T>) => T | void))
& (<T>(
predicate: Predicate<T> | OPredicate<T>,
fromIndex: number,
collection: Collection<T>
) => (T | void));
findLast:
& (<T>(
predicate: Predicate<T> | OPredicate<T>
) => ((collection: Collection<T>) => T | void))
& (<T>(
predicate: Predicate<T> | OPredicate<T>,
collection: Collection<T>
) => (T | void));
findLastFrom:
& (<T>(
predicate: Predicate<T> | OPredicate<T>
) => (((
fromIndex: number
) => (collection: Collection<T>) => T | void) &
((
fromIndex: number,
collection: Collection<T>
) => T | void)))
& (<T>(
predicate: Predicate<T> | OPredicate<T>,
fromIndex: number
) => ((collection: Collection<T>) => T | void))
& (<T>(
predicate: Predicate<T> | OPredicate<T>,
fromIndex: number,
collection: Collection<T>
) => T | void);
flatMap:
& (<T, U>(
iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>
) => ((collection: Collection<T>) => Array<U>))
& (<T, U>(
iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>,
collection: Collection<T>
) => Array<U>);
flatMapDeep:
& (<T, U>(
iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>
) => ((collection: Collection<T>) => Array<U>))
& (<T, U>(
iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>,
collection: Collection<T>
) => Array<U>);
flatMapDepth:
& (<T, U>(
iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>
) => (((
depth: number
) => (collection: Collection<T>) => Array<U>) &
((depth: number, collection: Collection<T>) => Array<U>)))
& (<T, U>(
iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>,
depth: number
) => ((collection: Collection<T>) => Array<U>))
& (<T, U>(
iteratee: AFlatMapIteratee<T, U> | OFlatMapIteratee<T, U>,
depth: number,
collection: Collection<T>
) => Array<U>);
forEach:
& (<T>(
iteratee: Iteratee<T> | OIteratee<T>
) => ((collection: Collection<T>) => Array<T>))
& (<T>(
iteratee: Iteratee<T> | OIteratee<T>,
collection: Collection<T>
) => Array<T>);
forEachRight:
& (<T>(
iteratee: Iteratee<T> | OIteratee<T>
) => ((collection: Collection<T>) => Array<T>))
& (<T>(
iteratee: Iteratee<T> | OIteratee<T>,
collection: Collection<T>
) => Array<T>);
groupBy:
& (<V, T>(
iteratee: ValueOnlyIteratee<T>
) => ((
collection: Collection<T>
) => { [key: V]: Array<T>, ... }))
& (<V, T>(
iteratee: ValueOnlyIteratee<T>,
collection: Collection<T>
) => { [key: V]: Array<T>, ... });
includes:
& (<T>(value: T) => ((collection: Collection<T>) => boolean))
& (<T>(value: T, collection: Collection<T>) => boolean)
& ((value: string) => ((str: string) => boolean))
& ((value: string, str: string) => boolean);
contains:
& ((value: string) => ((str: string) => boolean))
& ((value: string, str: string) => boolean)
& (<T>(value: T) => ((collection: Collection<T>) => boolean))
& (<T>(value: T, collection: Collection<T>) => boolean);
includesFrom:
& ((
value: string
) => (((fromIndex: number) => (str: string) => boolean) &
((fromIndex: number, str: string) => boolean)))
& ((value: string, fromIndex: number) => ((str: string) => boolean))
& ((value: string, fromIndex: number, str: string) => boolean)
& (<T>(
value: T
) => (((fromIndex: number) => (collection: $ReadOnlyArray<T>) => boolean) &
((fromIndex: number, collection: $ReadOnlyArray<T>) => boolean)))
& (<T>(
value: T,
fromIndex: number
) => ((collection: $ReadOnlyArray<T>) => boolean))
& (<T>(value: T, fromIndex: number, collection: $ReadOnlyArray<T>) => boolean);
invokeMap:
& (<T>(
path: ((value: T) => Path) | Path
) => ((collection: Collection<T>) => Array<any>))
& (<T>(
path: ((value: T) => Path) | Path,
collection: Collection<T>
) => Array<any>);
invokeArgsMap:
& (<T>(
path: ((value: T) => Path) | Path
) => (((
collection: Collection<T>
) => (args: $ReadOnlyArray<any>) => Array<any>) &
((
collection: Collection<T>,
args: $ReadOnlyArray<any>
) => Array<any>)))
& (<T>(
path: ((value: T) => Path) | Path,
collection: Collection<T>
) => ((args: $ReadOnlyArray<any>) => Array<any>))
& (<T>(
path: ((value: T) => Path) | Path,
collection: Collection<T>,
args: $ReadOnlyArray<any>
) => Array<any>);
keyBy:
& (<T, V>(
iteratee: ValueOnlyIteratee<T>
) => ((collection: Collection<T>) => { [key: V]: T, ... }))
& (<T, V>(
iteratee: ValueOnlyIteratee<T>,
collection: Collection<T>
) => { [key: V]: T, ... });
indexBy:
& (<T, V>(
iteratee: ValueOnlyIteratee<T>
) => ((collection: Collection<T>) => { [key: V]: T, ... }))
& (<T, V>(
iteratee: ValueOnlyIteratee<T>,
collection: Collection<T>
) => { [key: V]: T, ... });
map:
& (<T, U>(
iteratee: MapIterator<T, U> | OMapIterator<T, U>
) => ((collection: Collection<T>) => Array<U>))
& (<T, U>(
iteratee: MapIterator<T, U> | OMapIterator<T, U>,
collection: Collection<T>
) => Array<U>)
& ((iteratee: (char: string) => any) => ((str: string) => string))
& ((iteratee: (char: string) => any, str: string) => string);
pluck:
& (<T, U>(
iteratee: MapIterator<T, U> | OMapIterator<T, U>
) => ((collection: Collection<T>) => Array<U>))
& (<T, U>(
iteratee: MapIterator<T, U> | OMapIterator<T, U>,
collection: Collection<T>
) => Array<U>)
& ((iteratee: (char: string) => any) => ((str: string) => string))
& ((iteratee: (char: string) => any, str: string) => string);
orderBy:
& (<T>(
iteratees: $ReadOnlyArray<Iteratee<T> | OIteratee<*>> | string
) => (((
orders: $ReadOnlyArray<"asc" | "desc"> | string
) => (collection: Collection<T>) => Array<T>) &
((
orders: $ReadOnlyArray<"asc" | "desc"> | string,
collection: Collection<T>
) => Array<T>)))
& (<T>(
iteratees: $ReadOnlyArray<Iteratee<T> | OIteratee<*>> | string,
orders: $ReadOnlyArray<"asc" | "desc"> | string
) => ((collection: Collection<T>) => Array<T>))
& <T>(
iteratees: $ReadOnlyArray<Iteratee<T> | OIteratee<*>> | string,
orders: $ReadOnlyArray<"asc" | "desc"> | string,
collection: Collection<T>
) => Array<T>;
partition:
& (<T>(
predicate: Predicate<T> | OPredicate<T>
) => ((collection: Collection<T>) => [Array<T>, Array<T>]))
& (<T>(
predicate: Predicate<T> | OPredicate<T>,
collection: Collection<T>
) => [Array<T>, Array<T>]);
reduce:
& (<T, U>(
iteratee: (accumulator: U, value: T) => U
) => (((accumulator: U) => (collection: Collection<T>) => U) &
((accumulator: U, collection: Collection<T>) => U)))
& (<T, U>(
iteratee: (accumulator: U, value: T) => U,
accumulator: U
) => ((collection: Collection<T>) => U))
& (<T, U>(
iteratee: (accumulator: U, value: T) => U,
accumulator: U,
collection: Collection<T>
) => U);
reduceRight:
& (<T, U>(
iteratee: (value: T, accumulator: U) => U
) => ((accumulator: U) => (collection: Collection<T>) => U) &
((accumulator: U, collection: Collection<T>) => U))
& (<T, U>(
iteratee: (value: T, accumulator: U) => U,
accumulator: U
) => (collection: Collection<T>) => U)
& (<T, U>(
iteratee: (value: T, accumulator: U) => U,
accumulator: U,
collection: Collection<T>
) => U);
reject:
& (<T>(
predicate: Predicate<T> | OPredicate<T>
) => ((collection: Collection<T>) => Array<T>))
& (<T>(
predicate: Predicate<T> | OPredicate<T>,
collection: Collection<T>
) => Array<T>);
sample<T>(collection: Collection<T>): T;
sampleSize:
& (<T>(
n: number
) => ((collection: Collection<T>) => Array<T>))
& (<T>(n: number, collection: Collection<T>) => Array<T>);
shuffle<T>(collection: Collection<T>): Array<T>;
size(collection: $ReadOnlyArray<any> | Object | string): number;
some:
& (<T>(
predicate: Predicate<T> | OPredicate<T>
) => (collection: Collection<T>) => boolean)
& (<T>(
predicate: Predicate<T> | OPredicate<T>,
collection: Collection<T>
) => boolean);
any:
& (<T>(
predicate: Predicate<T> | OPredicate<T>
) => ((collection: Collection<T>) => boolean))
& (<T>(
predicate: Predicate<T> | OPredicate<T>,
collection: Collection<T>
) => boolean);
sortBy:
& (<T>(
iteratees:
| $ReadOnlyArray<Iteratee<T> | OIteratee<T>>
| Iteratee<T>
| OIteratee<T>
) => ((collection: Collection<T>) => Array<T>))
& (<T>(
iteratees:
| $ReadOnlyArray<Iteratee<T> | OIteratee<T>>
| Iteratee<T>
| OIteratee<T>,
collection: Collection<T>
) => Array<T>);
// Date
now(): number;
// Function
after:
& ((fn: Function) => ((n: number) => Function))
& ((fn: Function, n: number) => Function);
ary(func: Function): Function;
nAry:
& ((n: number) => ((func: Function) => Function))
& ((n: number, func: Function) => Function);
before:
& ((fn: Function) => ((n: number) => Function))
& ((fn: Function, n: number) => Function);
bind:
& ((func: Function) => ((thisArg: any) => Function))
& ((func: Function, thisArg: any) => Function);
bindKey:
& ((obj: Object) => (key: string) => Function)
& ((obj: Object, key: string) => Function);
curry: Curry;
curryN:
& ((arity: number) => ((func: Function) => Function))
& ((arity: number, func: Function) => Function);
curryRight(func: Function): Function;
curryRightN:
& ((arity: number) => ((func: Function) => Function))
& ((arity: number, func: Function) => Function);
debounce:
& ((wait: number) => (<A, R>(func: (...A) => R) => (...A) => R))
& (<A, R>(wait: number, func: (...A) => R) => ((...A) => R));
defer(func: (...$ReadOnlyArray<any>) => any): TimeoutID;
delay:
& ((wait: number) => ((func: Function) => TimeoutID))
& ((wait: number, func: Function) => TimeoutID);
flip(func: Function): Function;
memoize<F: Function>(func: F): F;
negate<A, R>(predicate: (...A) => R): (...A) => boolean;
complement(predicate: Function): Function;
once(func: Function): Function;
overArgs:
& ((func: Function) => ((transforms: $ReadOnlyArray<Function>) => Function))
& ((func: Function, transforms: $ReadOnlyArray<Function>) => Function);
useWith:
& ((func: Function) => ((transforms: $ReadOnlyArray<Function>) => Function))
& ((func: Function, transforms: $ReadOnlyArray<Function>) => Function);
partial:
& ((func: Function) => ((partials: $ReadOnlyArray<any>) => Function))
& ((func: Function, partials: $ReadOnlyArray<any>) => Function);
partialRight:
& ((func: Function) => (partials: $ReadOnlyArray<any>) => Function)
& ((func: Function, partials: $ReadOnlyArray<any>) => Function);
rearg:
& ((indexes: $ReadOnlyArray<number>) => ((func: Function) => Function))
& ((indexes: $ReadOnlyArray<number>, func: Function) => Function);
rest(func: Function): Function;
unapply(func: Function): Function;
restFrom:
& ((start: number) => ((func: Function) => Function))
& ((start: number, func: Function) => Function);
spread(func: Function): Function;
apply(func: Function): Function;
spreadFrom:
& ((start: number) => ((func: Function) => Function))
& ((start: number, func: Function) => Function);
throttle:
& (<A, R>(wait: number) => ((func: (...A) => R) => (...A) => R))
& (<A, R>(wait: number, func: (...A) => R) => ((...A) => R));
unary<T, R>(func: (T, ...$ReadOnlyArray<any>) => R): (T) => R;
wrap:
& ((wrapper: Function) => ((value: any) => Function))
& ((wrapper: Function, value: any) => Function);
// Lang
castArray:
& (() => Array<any>)
& (<T: void | null | number | string | {...}>(value: T) => Array<T>)
& (<T: Array<any>>(value: T) => T);
clone<T>(value: T): T;
cloneDeep<T>(value: T): T;
cloneDeepWith:
& (<T, U>(
customizer: (value: T, key: number | string, object: T, stack: any) => U
) => ((value: T) => U))
& (<T, U>(
customizer: (value: T, key: number | string, object: T, stack: any) => U,
value: T
) => U);
cloneWith:
& (<T, U>(
customizer: (value: T, key: number | string, object: T, stack: any) => U
) => ((value: T) => U))
& (<T, U>(
customizer: (value: T, key: number | string, object: T, stack: any) => U,
value: T
) => U);
conformsTo:
& (<T: ReadOnlyIndexerObject<mixed>>(
predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>
) => ((source: T) => boolean))
& (<T: ReadOnlyIndexerObject<mixed>>(
predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>,
source: T
) => boolean);
where:
& (<T: ReadOnlyIndexerObject<mixed>>(
predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>
) => ((source: T) => boolean))
& (<T: ReadOnlyIndexerObject<mixed>>(
predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>,
source: T
) => boolean);
conforms:
& (<T: ReadOnlyIndexerObject<mixed>>(
predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>
) => ((source: T) => boolean))
& (<T: ReadOnlyIndexerObject<mixed>>(
predicates: T & $ReadOnly<{ [key: string]: (x: any) => boolean, ... }>,
source: T
) => boolean);
eq:
& ((value: any) => ((other: any) => boolean))
& ((value: any, other: any) => boolean);
identical:
& ((value: any) => ((other: any) => boolean))
& ((value: any, other: any) => boolean);
gt:
& ((value: any) => (other: any) => boolean)
& ((value: any, other: any) => boolean);
gte:
& ((value: any) => ((other: any) => boolean))
& ((value: any, other: any) => boolean);
isArguments(value: any): boolean;
isArray(value: any): boolean;
isArrayBuffer(value: any): boolean;
isArrayLike(value: any): boolean;
isArrayLikeObject(value: any): boolean;
isBoolean(value: any): boolean;
isBuffer(value: any): boolean;
isDate(value: any): boolean;
isElement(value: any): boolean;
isEmpty(value: any): boolean;
isEqual:
& ((value: any) => ((other: any) => boolean))
& ((value: any, other: any) => boolean);
equals:
& ((value: any) => (other: any) => boolean)
& ((value: any, other: any) => boolean);
isEqualWith:
& (<T, U>(
customizer: (
objValue: any,
otherValue: any,
key: number | string,
object: T,
other: U,
stack: any
) => boolean | void
) => (((value: T) => (other: U) => boolean) &
((value: T, other: U) => boolean)))
& (<T, U>(
customizer: (
objValue: any,
otherValue: any,
key: number | string,
object: T,
other: U,
stack: any
) => boolean | void,
value: T
) => ((other: U) => boolean))
& (<T, U>(
customizer: (
objValue: any,
otherValue: any,
key: number | string,
object: T,
other: U,
stack: any
) => boolean | void,
value: T,
other: U
) => boolean);
isError(value: any): boolean;
isFinite(value: any): boolean;
isFunction(value: any): boolean;
isInteger(value: any): boolean;
isLength(value: any): boolean;
isMap(value: any): boolean;
isMatch:
& ((source: Object) => (object: Object) => boolean)
& ((source: Object, object: Object) => boolean);
whereEq:
& ((source: Object) => (object: Object) => boolean)
& ((source: Object, object: Object) => boolean);
isMatchWith:
& (<T: Object, U: Object>(
customizer: (
objValue: any,
srcValue: any,
key: number | string,
object: T,
source: U
) => boolean | void
) => (((source: U) => (object: T) => boolean) &
((source: U, object: T) => boolean)))
& (<T: Object, U: Object>(
customizer: (
objValue: any,
srcValue: any,
key: number | string,
object: T,
source: U
) => boolean | void,
source: U
) => ((object: T) => boolean))
& (<T: Object, U: Object>(
customizer: (
objValue: any,
srcValue: any,
key: number | string,
object: T,
source: U
) => boolean | void,
source: U,
object: T
) => boolean);
isNaN(value: any): boolean;
isNative(value: any): boolean;
isNil(value: any): boolean;
isNull(value: any): boolean;
isNumber(value: any): boolean;
isObject(value: any): boolean;
isObjectLike(value: any): boolean;
isPlainObject(value: any): boolean;
isRegExp(value: any): boolean;
isSafeInteger(value: any): boolean;
isSet(value: any): boolean;
isString:
& ((value: string) => true)
& ((value: any) => false);
isSymbol(value: any): boolean;
isTypedArray(value: any): boolean;
isUndefined(value: any): boolean;
isWeakMap(value: any): boolean;
isWeakSet(value: any): boolean;
lt:
& ((value: any) => ((other: any) => boolean))
& ((value: any, other: any) => boolean);
lte:
& ((value: any) => ((other: any) => boolean))
& ((value: any, other: any) => boolean);
toArray(value: any): Array<any>;
toFinite(value: any): number;
toInteger(value: any): number;
toLength(value: any): number;
toNumber(value: any): number;
toPlainObject(value: any): Object;
toSafeInteger(value: any): number;
toString(value: any): string;
// Math
add(augend: number): (addend: number) => number;
add(augend: number, addend: number): number;
ceil(number: number): number;
divide(dividend: number): (divisor: number) => number;
divide(dividend: number, divisor: number): number;
floor(number: number): number;
max<T>(array: $ReadOnlyArray<T>): T;
maxBy<T>(iteratee: Iteratee<T>): (array: $ReadOnlyArray<T>) => T;
maxBy<T>(iteratee: Iteratee<T>, array: $ReadOnlyArray<T>): T;
mean(array: $ReadOnlyArray<*>): number;
meanBy<T>(iteratee: Iteratee<T>): (array: $ReadOnlyArray<T>) => number;
meanBy<T>(iteratee: Iteratee<T>, array: $ReadOnlyArray<T>): number;
min<T>(array: $ReadOnlyArray<T>): T;
minBy<T>(iteratee: Iteratee<T>): (array: $ReadOnlyArray<T>) => T;
minBy<T>(iteratee: Iteratee<T>, array: $ReadOnlyArray<T>): T;
multiply(multiplier: number): (multiplicand: number) => number;
multiply(multiplier: number, multiplicand: number): number;
round(number: number): number;
subtract(minuend: number): (subtrahend: number) => number;
subtract(minuend: number, subtrahend: number): number;
sum(array: $ReadOnlyArray<*>): number;
sumBy<T>(iteratee: Iteratee<T>): (array: $ReadOnlyArray<T>) => number;
sumBy<T>(iteratee: Iteratee<T>, array: $ReadOnlyArray<T>): number;
// number
clamp:
& ((
lower: number
) => (((upper: number) => (number: number) => number) &
((upper: number, number: number) => number)))
& ((lower: number, upper: number) => ((number: number) => number))
& ((lower: number, upper: number, number: number) => number);
inRange:
& ((
start: number
) => (((end: number) => (number: number) => boolean) &
((end: number, number: number) => boolean)))
& ((start: number, end: number) => ((number: number) => boolean))
& ((start: number, end: number, number: number) => boolean);
random:
& ((lower: number) => ((upper: number) => number))
& ((lower: number, upper: number) => number);
// Object
assign:
& ((object: Object) => ((source: Object) => Object))
& ((object: Object, source: Object) => Object);
assignAll(objects: Array<Object>): Object;
assignInAll(objects: Array<Object>): Object;
extendAll(objects: Array<Object>): Object;
assignIn:
& (<A, B>(a: A) => ((b: B) => A & B))
& (<A, B>(a: A, b: B) => A & B);
assignInWith:
& (<T: Object, A: Object>(
customizer: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void
) => (((object: T) => (s1: A) => Object) & ((object: T, s1: A) => Object)))
& (<T: Object, A: Object>(
customizer: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void,
object: T
) => ((s1: A) => Object))
& (<T: Object, A: Object>(
customizer: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void,
object: T,
s1: A
) => Object);
assignWith:
& (<T: Object, A: Object>(
customizer: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void
) => (((object: T) => (s1: A) => Object) & ((object: T, s1: A) => Object)))
& (<T: Object, A: Object>(
customizer: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void,
object: T
) => ((s1: A) => Object))
& (<T: Object, A: Object>(
customizer: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void,
object: T,
s1: A
) => Object);
assignInAllWith:
& ((
customizer: (
objValue: any,
srcValue: any,
key: string,
object: Object,
source: Object
) => any | void
) => ((objects: Array<Object>) => Object))
& ((
customizer: (
objValue: any,
srcValue: any,
key: string,
object: Object,
source: Object
) => any | void,
objects: Array<Object>
) => Object);
extendAllWith:
& ((
customizer: (
objValue: any,
srcValue: any,
key: string,
object: Object,
source: Object
) => any | void
) => ((objects: Array<Object>) => Object))
& ((
customizer: (
objValue: any,
srcValue: any,
key: string,
object: Object,
source: Object
) => any | void,
objects: Array<Object>
) => Object);
assignAllWith:
& ((
customizer: (
objValue: any,
srcValue: any,
key: string,
object: Object,
source: Object
) => any | void
) => ((objects: Array<Object>) => Object))
& ((
customizer: (
objValue: any,
srcValue: any,
key: string,
object: Object,
source: Object
) => any | void,
objects: Array<Object>
) => Object);
at:
& ((paths: $ReadOnlyArray<string>) => ((object: Object) => Array<any>))
& ((paths: $ReadOnlyArray<string>, object: Object) => Array<any>);
props:
& ((paths: $ReadOnlyArray<string>) => ((object: Object) => Array<any>))
& ((paths: $ReadOnlyArray<string>, object: Object) => Array<any>);
paths:
& ((paths: $ReadOnlyArray<string>) => ((object: Object) => Array<any>))
& ((paths: $ReadOnlyArray<string>, object: Object) => Array<any>);
create<T>(prototype: T): T;
defaults:
& ((source: Object) => ((object: Object) => Object))
& ((source: Object, object: Object) => Object);
defaultsAll(objects: Array<Object>): Object;
defaultsDeep:
& ((source: Object) => ((object: Object) => Object))
& ((source: Object, object: Object) => Object);
defaultsDeepAll(objects: Array<Object>): Object;
// alias for _.toPairs
entries(object: Object): Array<[string, any]>;
// alias for _.toPairsIn
entriesIn(object: Object): Array<[string, any]>;
// alias for _.assignIn
extend:
& (<A, B>(a: A) => ((b: B) => A & B))
& (<A, B>(a: A, b: B) => A & B);
// alias for _.assignInWith
extendWith:
& (<T: Object, A: Object>(
customizer: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void
) => (((object: T) => (s1: A) => Object) & ((object: T, s1: A) => Object)))
& (<T: Object, A: Object>(
customizer: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void,
object: T
) => ((s1: A) => Object))
& (<T: Object, A: Object>(
customizer: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A
) => any | void,
object: T,
s1: A
) => Object);
findKey:
& (<A, T: ReadOnlyIndexerObject<A>>(
predicate: OPredicate<A>
) => ((object: T) => string | void))
& (<A, T: ReadOnlyIndexerObject<A>>(
predicate: OPredicate<A>,
object: T
) => string | void);
findLastKey:
& (<A, T: ReadOnlyIndexerObject<A>>(
predicate: OPredicate<A>
) => ((object: T) => string | void))
& (<A, T: ReadOnlyIndexerObject<A>>(
predicate: OPredicate<A>,
object: T
) => string | void);
forIn:
& ((iteratee: OIteratee<*>) => ((object: Object) => Object))
& ((iteratee: OIteratee<*>, object: Object) => Object);
forInRight:
& ((iteratee: OIteratee<*>) => ((object: Object) => Object))
& ((iteratee: OIteratee<*>, object: Object) => Object);
forOwn:
& ((iteratee: OIteratee<*>) => ((object: Object) => Object))
& ((iteratee: OIteratee<*>, object: Object) => Object);
forOwnRight:
& ((iteratee: OIteratee<*>) => ((object: Object) => Object))
& ((iteratee: OIteratee<*>, object: Object) => Object);
functions(object: Object): Array<string>;
functionsIn(object: Object): Array<string>;
get:
& ((
path: Path
) => ((object: Object | $ReadOnlyArray<any> | void | null) => any))
& ((
path: Path,
object: Object | $ReadOnlyArray<any> | void | null
) => any);
prop:
& ((path: Path) => ((object: Object | $ReadOnlyArray<any>) => any))
& ((path: Path, object: Object | $ReadOnlyArray<any>) => any);
path:
& ((path: Path) => ((object: Object | $ReadOnlyArray<any>) => any))
& ((path: Path, object: Object | $ReadOnlyArray<any>) => any);
getOr:
& ((
defaultValue: any
) => (((
path: Path
) => (object: Object | $ReadOnlyArray<any>) => any) &
((
path: Path,
object: Object | $ReadOnlyArray<any> | void | null
) => any)))
& ((
defaultValue: any,
path: Path
) => ((object: Object | $ReadOnlyArray<any> | void | null) => any))
& ((
defaultValue: any,
path: Path,
object: Object | $ReadOnlyArray<any> | void | null
) => any);
propOr:
& ((
defaultValue: any
) => (((
path: Path
) => (object: Object | $ReadOnlyArray<any>) => any) &
((path: Path, object: Object | $ReadOnlyArray<any>) => any)))
& ((
defaultValue: any,
path: Path
) => ((object: Object | $ReadOnlyArray<any>) => any))
& ((
defaultValue: any,
path: Path,
object: Object | $ReadOnlyArray<any>
) => any);
pathOr:
& ((
defaultValue: any
) => (((
path: Path
) => (object: Object | $ReadOnlyArray<any>) => any) &
((path: Path, object: Object | $ReadOnlyArray<any>) => any)))
& ((
defaultValue: any,
path: Path
) => ((object: Object | $ReadOnlyArray<any>) => any))
& ((
defaultValue: any,
path: Path,
object: Object | $ReadOnlyArray<any>
) => any);
has:
& ((path: Path) => ((object: Object) => boolean))
& ((path: Path, object: Object) => boolean);
hasIn:
& ((path: Path) => ((object: Object) => boolean))
& ((path: Path, object: Object) => boolean);
invert(object: Object): Object;
invertObj(object: Object): Object;
invertBy:
& ((iteratee: Function) => ((object: Object) => Object))
& ((iteratee: Function, object: Object) => Object);
invoke:
& ((path: Path) => ((object: Object) => any))
& ((path: Path, object: Object) => any);
invokeArgs:
& ((
path: Path
) => (((object: Object) => (args: Array<any>) => any) &
((object: Object, args: Array<any>) => any)))
& ((
path: Path,
object: Object
) => ((args: Array<any>) => any))
& (
path: Path,
object: Object,
args: Array<any>
) => any;
keys:
& (<K>(object: ReadOnlyIndexerObject<any, K>) => Array<K>)
& ((object: Object) => Array<string>);
keysIn(object: Object): Array<string>;
mapKeys:
& ((iteratee: OIteratee<*>) => ((object: Object) => Object))
& ((iteratee: OIteratee<*>, object: Object) => Object);
mapValues:
& ((iteratee: OIteratee<*>) => ((object: Object) => Object))
& ((iteratee: OIteratee<*>, object: Object) => Object);
merge:
& ((object: Object) => ((source: Object) => Object))
& ((object: Object, source: Object) => Object);
mergeAll(objects: $ReadOnlyArray<Object>): Object;
mergeWith:
& (<T: Object, A: Object, B: Object>(
customizer: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B
) => any | void
) => (((object: T) => (s1: A) => Object) & ((object: T, s1: A) => Object)))
& (<T: Object, A: Object, B: Object>(
customizer: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B
) => any | void,
object: T
) => ((s1: A) => Object))
& (<T: Object, A: Object, B: Object>(
customizer: (
objValue: any,
srcValue: any,
key: string,
object: T,
source: A | B
) => any | void,
object: T,
s1: A
) => Object);
mergeAllWith:
& ((
customizer: (
objValue: any,
srcValue: any,
key: string,
object: Object,
source: Object
) => any | void
) => ((objects: $ReadOnlyArray<Object>) => Object))
& ((
customizer: (
objValue: any,
srcValue: any,
key: string,
object: Object,
source: Object
) => any | void,
objects: $ReadOnlyArray<Object>
) => Object);
omit:
& ((props: $ReadOnlyArray<string>) => ((object: Object) => Object))
& ((props: $ReadOnlyArray<string>, object: Object) => Object);
omitAll:
& ((props: $ReadOnlyArray<string>) => ((object: Object) => Object))
& ((props: $ReadOnlyArray<string>, object: Object) => Object);
omitBy:
& (<A, T: ReadOnlyIndexerObject<A>>(
predicate: OPredicate<A>
) => ((object: T) => Object))
& (<A, T: ReadOnlyIndexerObject<A>>(predicate: OPredicate<A>, object: T) => Object);
pick:
& ((...props: $ReadOnlyArray<string | {...}>) => Object)
& ((props: $ReadOnlyArray<string>, object: Object) => Object)
& ((...props: $ReadOnlyArray<string>) => ((object: Object) => Object))
& ((props: $ReadOnlyArray<string>) => ((object: Object) => Object));
pickAll:
& ((props: $ReadOnlyArray<string>) => ((object: Object) => Object))
& ((props: $ReadOnlyArray<string>, object: Object) => Object);
pickBy:
& (<A, T: ReadOnlyIndexerObject<A>>(
predicate: OPredicate<A>
) => ((object: T) => Object))
& (<A, T: ReadOnlyIndexerObject<A>>(predicate: OPredicate<A>, object: T) => Object);
result:
& ((path: Path) => ((object: Object) => any))
& ((path: Path, object: Object) => any);
set:
& ((
path: Path
) => (((value: any) => (object: Object) => Object) &
((value: any, object: Object) => Object)))
& ((path: Path, value: any) => ((object: Object) => Object))
& ((path: Path, value: any, object: Object) => Object);
assoc:
& ((
path: Path
) => (((value: any) => (object: Object) => Object) &
((value: any, object: Object) => Object)))
& ((path: Path, value: any) => ((object: Object) => Object))
& ((path: Path, value: any, object: Object) => Object);
assocPath:
& ((
path: Path
) => (((value: any) => (object: Object) => Object) &
((value: any, object: Object) => Object)))
& ((
path: Path,
value: any
) => ((object: Object) => Object))
& ((path: Path, value: any, object: Object) => Object);
setWith:
& (<T>(
customizer: (nsValue: any, key: string, nsObject: T) => any
) => (((
path: Path
) => ((value: any) => (object: T) => Object) &
((value: any, object: T) => Object)) &
((path: Path, value: any) => (object: T) => Object) &
((path: Path, value: any, object: T) => Object)))
& (<T>(
customizer: (nsValue: any, key: string, nsObject: T) => any,
path: Path
) => (((value: any) => (object: T) => Object) &
((value: any, object: T) => Object)))
& (<T>(
customizer: (nsValue: any, key: string, nsObject: T) => any,
path: Path,
value: any
) => ((object: T) => Object))
& (<T>(
customizer: (nsValue: any, key: string, nsObject: T) => any,
path: Path,
value: any,
object: T
) => Object);
toPairs(object: Object | $ReadOnlyArray<*>): Array<[string, any]>;
toPairsIn(object: Object): Array<[string, any]>;
transform:
& ((
iteratee: OIteratee<*>
) => (((
accumulator: any
) => (collection: Object | $ReadOnlyArray<any>) => any) &
((accumulator: any, collection: Object | $ReadOnlyArray<any>) => any)))
& ((
iteratee: OIteratee<*>,
accumulator: any
) => ((collection: Object | $ReadOnlyArray<any>) => any))
& ((
iteratee: OIteratee<*>,
accumulator: any,
collection: Object | $ReadOnlyArray<any>
) => any);
unset:
& ((path: Path) => ((object: Object) => Object))
& ((path: Path, object: Object) => Object);
update:
& ((
path: Path
) => (((updater: Function) => (object: Object) => Object) &
((updater: Function, object: Object) => Object)))
& ((
path: Path,
updater: Function
) => ((object: Object) => Object))
& ((path: Path, updater: Function, object: Object) => Object);
updateWith:
& ((
customizer: Function
) => (((
path: Path
) => ((updater: Function) => (object: Object) => Object) &
((updater: Function, object: Object) => Object)) &
((
path: Path,
updater: Function
) => (object: Object) => Object) &
((path: Path, updater: Function, object: Object) => Object)))
& ((
customizer: Function,
path: Path
) => (((updater: Function) => (object: Object) => Object) &
((updater: Function, object: Object) => Object)))
& ((
customizer: Function,
path: Path,
updater: Function
) => ((object: Object) => Object))
& ((
customizer: Function,
path: Path,
updater: Function,
object: Object
) => Object);
values(object: Object): Array<any>;
valuesIn(object: Object): Array<any>;
tap:
& (<T>(interceptor: (value: T) => any) => ((value: T) => T))
& (<T>(interceptor: (value: T) => any, value: T) => T);
thru:
& (<T1, T2>(interceptor: (value: T1) => T2) => ((value: T1) => T2))
& (<T1, T2>(interceptor: (value: T1) => T2, value: T1) => T2);
// String
camelCase(string: string): string;
capitalize(string: string): string;
deburr(string: string): string;
endsWith:
& ((target: string) => ((string: string) => boolean))
& ((target: string, string: string) => boolean);
escape(string: string): string;
escapeRegExp(string: string): string;
kebabCase(string: string): string;
lowerCase(string: string): string;
lowerFirst(string: string): string;
pad:
& ((length: number) => ((string: string) => string))
& ((length: number, string: string) => string);
padChars:
& ((
chars: string
) => (((length: number) => (string: string) => string) &
((length: number, string: string) => string)))
& ((chars: string, length: number) => ((string: string) => string))
& ((chars: string, length: number, string: string) => string);
padEnd:
& ((length: number) => ((string: string) => string))
& ((length: number, string: string) => string);
padCharsEnd:
& ((
chars: string
) => (((length: number) => (string: string) => string) &
((length: number, string: string) => string)))
& ((chars: string, length: number) => ((string: string) => string))
& ((chars: string, length: number, string: string) => string);
padStart:
& ((length: number) => ((string: string) => string))
& ((length: number, string: string) => string);
padCharsStart:
& ((
chars: string
) => (((length: number) => (string: string) => string) &
((length: number, string: string) => string)))
& ((chars: string, length: number) => ((string: string) => string))
& ((chars: string, length: number, string: string) => string);
parseInt:
& ((radix: number) => ((string: string) => number))
& ((radix: number, string: string) => number);
repeat:
& ((n: number) => (string: string) => string)
& ((n: number, string: string) => string);
replace:
& ((
pattern: RegExp | string
) => (((
replacement: ((string: string) => string) | string
) => (string: string) => string) &
((
replacement: ((string: string) => string) | string,
string: string
) => string)))
& ((
pattern: RegExp | string,
replacement: ((string: string) => string) | string
) => ((string: string) => string))
& ((
pattern: RegExp | string,
replacement: ((string: string) => string) | string,
string: string
) => string);
snakeCase(string: string): string;
split:
& ((separator: RegExp | string) => ((string: string) => Array<string>))
& ((separator: RegExp | string, string: string) => Array<string>);
startCase(string: string): string;
startsWith:
& ((target: string) => ((string: string) => boolean))
& ((target: string, string: string) => boolean);
template(string: string): Function;
toLower(string: string): string;
toUpper(string: string): string;
trim(string: string): string;
trimChars:
& ((chars: string) => ((string: string) => string))
& ((chars: string, string: string) => string);
trimEnd(string: string): string;
trimCharsEnd:
& ((chars: string) => ((string: string) => string))
& ((chars: string, string: string) => string);
trimStart(string: string): string;
trimCharsStart:
& ((chars: string) => ((string: string) => string))
& ((chars: string, string: string) => string);
truncate:
& ((options: TruncateOptions) => ((string: string) => string))
& ((options: TruncateOptions, string: string) => string);
unescape(string: string): string;
upperCase(string: string): string;
upperFirst(string: string): string;
words(string: string): Array<string>;
// Util
attempt(func: Function): any;
bindAll:
& ((methodNames: $ReadOnlyArray<string>) => ((object: Object) => Object))
& ((methodNames: $ReadOnlyArray<string>, object: Object) => Object);
cond(pairs: NestedArray<Function>): Function;
constant<T>(value: T): () => T;
always<T>(value: T): () => T;
defaultTo:
& (<T1: void | null, T2>(defaultValue: T2) => ((value: T1) => T2))
& (<T1: void | null, T2>(defaultValue: T2, value: T1) => T2)
& (<T1: string | boolean, T2>(
defaultValue: T2
) => ((value: T1) => T1))
& (<T1: string | boolean, T2>(
defaultValue: T2,
value: T1
) => T1)
// NaN is a number instead of its own type, otherwise it would behave like null/void
& (<T1: number, T2>(defaultValue: T2) => ((value: T1) => T1 | T2))
& (<T1: number, T2>(defaultValue: T2, value: T1) => T1 | T2);
flow: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
pipe: $ComposeReverse & ((funcs: $ReadOnlyArray<Function>) => Function);
flowRight: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
compose: $Compose & ((funcs: $ReadOnlyArray<Function>) => Function);
identity<T>(value: T): T;
iteratee(func: any): Function;
matches:
& ((source: Object) => ((object: Object) => boolean))
& ((source: Object, object: Object) => boolean);
matchesProperty:
& ((path: Path) => ((srcValue: any) => Function))
& ((path: Path, srcValue: any) => Function);
propEq:
& ((path: Path) => ((srcValue: any) => Function))
& ((path: Path, srcValue: any) => Function);
pathEq:
& ((path: Path) => ((srcValue: any) => Function))
& ((path: Path, srcValue: any) => Function);
method(path: Path): Function;
methodOf(object: Object): Function;
mixin:
& (<T: Function | Object>(
object: T
) => (((source: Object) => (options: { chain: boolean, ... }) => T) &
((source: Object, options: { chain: boolean, ... }) => T)))
& (<T: Function | Object>(
object: T,
source: Object
) => ((options: { chain: boolean, ... }) => T))
& (<T: Function | Object>(
object: T,
source: Object,
options: { chain: boolean, ... }
) => T);
noConflict(): Lodash;
noop(...args: $ReadOnlyArray<mixed>): void;
nthArg(n: number): Function;
over(iteratees: $ReadOnlyArray<Function>): Function;
juxt(iteratees: $ReadOnlyArray<Function>): Function;
overEvery(predicates: $ReadOnlyArray<Function>): Function;
allPass(predicates: $ReadOnlyArray<Function>): Function;
overSome(predicates: $ReadOnlyArray<Function>): Function;
anyPass(predicates: $ReadOnlyArray<Function>): Function;
property:
& ((
path: Path
) => ((object: Object | $ReadOnlyArray<any>) => any))
& ((path: Path, object: Object | $ReadOnlyArray<any>) => any);
propertyOf:
& ((object: Object) => ((path: Path) => Function))
& ((object: Object, path: Path) => Function);
range:
& ((start: number) => ((end: number) => Array<number>))
& (start: number, end: number) => Array<number>;
rangeStep:
& ((
step: number
) => (((start: number) => (end: number) => Array<number>) &
((start: number, end: number) => Array<number>)))
& ((step: number, start: number) => ((end: number) => Array<number>))
& ((step: number, start: number, end: number) => Array<number>);
rangeRight:
& ((start: number) => ((end: number) => Array<number>))
& ((start: number, end: number) => Array<number>);
rangeStepRight:
& ((
step: number
) => (((start: number) => (end: number) => Array<number>) &
((start: number, end: number) => Array<number>)))
& ((step: number, start: number) => ((end: number) => Array<number>))
& ((step: number, start: number, end: number) => Array<number>);
runInContext(context: Object): Function;
stubArray(): Array<*>;
stubFalse(): false;
F(): false;
stubObject(): {...};
stubString(): "";
stubTrue(): true;
T(): true;
times:
& (<T>(iteratee: (i: number) => T) => ((n: number) => Array<T>))
& (<T>(iteratee: (i: number) => T, n: number) => Array<T>);
toPath(value: any): Array<string>;
uniqueId(prefix: string): string;
__: any;
placeholder: any;
convert(options: {
cap?: boolean,
curry?: boolean,
fixed?: boolean,
immutable?: boolean,
rearg?: boolean,
...
}): void;
// Properties
VERSION: string;
templateSettings: TemplateSettings;
|}
declare module.exports: Lodash;
}
declare module "lodash/chunk" {
declare module.exports: $Exports<"lodash">["chunk"];
}
declare module "lodash/compact" {
declare module.exports: $Exports<"lodash">["compact"];
}
declare module "lodash/concat" {
declare module.exports: $Exports<"lodash">["concat"];
}
declare module "lodash/difference" {
declare module.exports: $Exports<"lodash">["difference"];
}
declare module "lodash/differenceBy" {
declare module.exports: $Exports<"lodash">["differenceBy"];
}
declare module "lodash/differenceWith" {
declare module.exports: $Exports<"lodash">["differenceWith"];
}
declare module "lodash/drop" {
declare module.exports: $Exports<"lodash">["drop"];
}
declare module "lodash/dropRight" {
declare module.exports: $Exports<"lodash">["dropRight"];
}
declare module "lodash/dropRightWhile" {
declare module.exports: $Exports<"lodash">["dropRightWhile"];
}
declare module "lodash/dropWhile" {
declare module.exports: $Exports<"lodash">["dropWhile"];
}
declare module "lodash/fill" {
declare module.exports: $Exports<"lodash">["fill"];
}
declare module "lodash/findIndex" {
declare module.exports: $Exports<"lodash">["findIndex"];
}
declare module "lodash/findLastIndex" {
declare module.exports: $Exports<"lodash">["findLastIndex"];
}
declare module "lodash/first" {
declare module.exports: $Exports<"lodash">["first"];
}
declare module "lodash/flatten" {
declare module.exports: $Exports<"lodash">["flatten"];
}
declare module "lodash/flattenDeep" {
declare module.exports: $Exports<"lodash">["flattenDeep"];
}
declare module "lodash/flattenDepth" {
declare module.exports: $Exports<"lodash">["flattenDepth"];
}
declare module "lodash/fromPairs" {
declare module.exports: $Exports<"lodash">["fromPairs"];
}
declare module "lodash/head" {
declare module.exports: $Exports<"lodash">["head"];
}
declare module "lodash/indexOf" {
declare module.exports: $Exports<"lodash">["indexOf"];
}
declare module "lodash/initial" {
declare module.exports: $Exports<"lodash">["initial"];
}
declare module "lodash/intersection" {
declare module.exports: $Exports<"lodash">["intersection"];
}
declare module "lodash/intersectionBy" {
declare module.exports: $Exports<"lodash">["intersectionBy"];
}
declare module "lodash/intersectionWith" {
declare module.exports: $Exports<"lodash">["intersectionWith"];
}
declare module "lodash/join" {
declare module.exports: $Exports<"lodash">["join"];
}
declare module "lodash/last" {
declare module.exports: $Exports<"lodash">["last"];
}
declare module "lodash/lastIndexOf" {
declare module.exports: $Exports<"lodash">["lastIndexOf"];
}
declare module "lodash/nth" {
declare module.exports: $Exports<"lodash">["nth"];
}
declare module "lodash/pull" {
declare module.exports: $Exports<"lodash">["pull"];
}
declare module "lodash/pullAll" {
declare module.exports: $Exports<"lodash">["pullAll"];
}
declare module "lodash/pullAllBy" {
declare module.exports: $Exports<"lodash">["pullAllBy"];
}
declare module "lodash/pullAllWith" {
declare module.exports: $Exports<"lodash">["pullAllWith"];
}
declare module "lodash/pullAt" {
declare module.exports: $Exports<"lodash">["pullAt"];
}
declare module "lodash/remove" {
declare module.exports: $Exports<"lodash">["remove"];
}
declare module "lodash/reverse" {
declare module.exports: $Exports<"lodash">["reverse"];
}
declare module "lodash/slice" {
declare module.exports: $Exports<"lodash">["slice"];
}
declare module "lodash/sortedIndex" {
declare module.exports: $Exports<"lodash">["sortedIndex"];
}
declare module "lodash/sortedIndexBy" {
declare module.exports: $Exports<"lodash">["sortedIndexBy"];
}
declare module "lodash/sortedIndexOf" {
declare module.exports: $Exports<"lodash">["sortedIndexOf"];
}
declare module "lodash/sortedLastIndex" {
declare module.exports: $Exports<"lodash">["sortedLastIndex"];
}
declare module "lodash/sortedLastIndexBy" {
declare module.exports: $Exports<"lodash">["sortedLastIndexBy"];
}
declare module "lodash/sortedLastIndexOf" {
declare module.exports: $Exports<"lodash">["sortedLastIndexOf"];
}
declare module "lodash/sortedUniq" {
declare module.exports: $Exports<"lodash">["sortedUniq"];
}
declare module "lodash/sortedUniqBy" {
declare module.exports: $Exports<"lodash">["sortedUniqBy"];
}
declare module "lodash/tail" {
declare module.exports: $Exports<"lodash">["tail"];
}
declare module "lodash/take" {
declare module.exports: $Exports<"lodash">["take"];
}
declare module "lodash/takeRight" {
declare module.exports: $Exports<"lodash">["takeRight"];
}
declare module "lodash/takeRightWhile" {
declare module.exports: $Exports<"lodash">["takeRightWhile"];
}
declare module "lodash/takeWhile" {
declare module.exports: $Exports<"lodash">["takeWhile"];
}
declare module "lodash/union" {
declare module.exports: $Exports<"lodash">["union"];
}
declare module "lodash/unionBy" {
declare module.exports: $Exports<"lodash">["unionBy"];
}
declare module "lodash/unionWith" {
declare module.exports: $Exports<"lodash">["unionWith"];
}
declare module "lodash/uniq" {
declare module.exports: $Exports<"lodash">["uniq"];
}
declare module "lodash/uniqBy" {
declare module.exports: $Exports<"lodash">["uniqBy"];
}
declare module "lodash/uniqWith" {
declare module.exports: $Exports<"lodash">["uniqWith"];
}
declare module "lodash/unzip" {
declare module.exports: $Exports<"lodash">["unzip"];
}
declare module "lodash/unzipWith" {
declare module.exports: $Exports<"lodash">["unzipWith"];
}
declare module "lodash/without" {
declare module.exports: $Exports<"lodash">["without"];
}
declare module "lodash/xor" {
declare module.exports: $Exports<"lodash">["xor"];
}
declare module "lodash/xorBy" {
declare module.exports: $Exports<"lodash">["xorBy"];
}
declare module "lodash/xorWith" {
declare module.exports: $Exports<"lodash">["xorWith"];
}
declare module "lodash/zip" {
declare module.exports: $Exports<"lodash">["zip"];
}
declare module "lodash/zipObject" {
declare module.exports: $Exports<"lodash">["zipObject"];
}
declare module "lodash/zipObjectDeep" {
declare module.exports: $Exports<"lodash">["zipObjectDeep"];
}
declare module "lodash/zipWith" {
declare module.exports: $Exports<"lodash">["zipWith"];
}
declare module "lodash/countBy" {
declare module.exports: $Exports<"lodash">["countBy"];
}
declare module "lodash/each" {
declare module.exports: $Exports<"lodash">["each"];
}
declare module "lodash/eachRight" {
declare module.exports: $Exports<"lodash">["eachRight"];
}
declare module "lodash/every" {
declare module.exports: $Exports<"lodash">["every"];
}
declare module "lodash/filter" {
declare module.exports: $Exports<"lodash">["filter"];
}
declare module "lodash/find" {
declare module.exports: $Exports<"lodash">["find"];
}
declare module "lodash/findLast" {
declare module.exports: $Exports<"lodash">["findLast"];
}
declare module "lodash/flatMap" {
declare module.exports: $Exports<"lodash">["flatMap"];
}
declare module "lodash/flatMapDeep" {
declare module.exports: $Exports<"lodash">["flatMapDeep"];
}
declare module "lodash/flatMapDepth" {
declare module.exports: $Exports<"lodash">["flatMapDepth"];
}
declare module "lodash/forEach" {
declare module.exports: $Exports<"lodash">["forEach"];
}
declare module "lodash/forEachRight" {
declare module.exports: $Exports<"lodash">["forEachRight"];
}
declare module "lodash/groupBy" {
declare module.exports: $Exports<"lodash">["groupBy"];
}
declare module "lodash/includes" {
declare module.exports: $Exports<"lodash">["includes"];
}
declare module "lodash/invokeMap" {
declare module.exports: $Exports<"lodash">["invokeMap"];
}
declare module "lodash/keyBy" {
declare module.exports: $Exports<"lodash">["keyBy"];
}
declare module "lodash/map" {
declare module.exports: $Exports<"lodash">["map"];
}
declare module "lodash/orderBy" {
declare module.exports: $Exports<"lodash">["orderBy"];
}
declare module "lodash/partition" {
declare module.exports: $Exports<"lodash">["partition"];
}
declare module "lodash/reduce" {
declare module.exports: $Exports<"lodash">["reduce"];
}
declare module "lodash/reduceRight" {
declare module.exports: $Exports<"lodash">["reduceRight"];
}
declare module "lodash/reject" {
declare module.exports: $Exports<"lodash">["reject"];
}
declare module "lodash/sample" {
declare module.exports: $Exports<"lodash">["sample"];
}
declare module "lodash/sampleSize" {
declare module.exports: $Exports<"lodash">["sampleSize"];
}
declare module "lodash/shuffle" {
declare module.exports: $Exports<"lodash">["shuffle"];
}
declare module "lodash/size" {
declare module.exports: $Exports<"lodash">["size"];
}
declare module "lodash/some" {
declare module.exports: $Exports<"lodash">["some"];
}
declare module "lodash/sortBy" {
declare module.exports: $Exports<"lodash">["sortBy"];
}
declare module "lodash/now" {
declare module.exports: $Exports<"lodash">["now"];
}
declare module "lodash/after" {
declare module.exports: $Exports<"lodash">["after"];
}
declare module "lodash/ary" {
declare module.exports: $Exports<"lodash">["ary"];
}
declare module "lodash/before" {
declare module.exports: $Exports<"lodash">["before"];
}
declare module "lodash/bind" {
declare module.exports: $Exports<"lodash">["bind"];
}
declare module "lodash/bindKey" {
declare module.exports: $Exports<"lodash">["bindKey"];
}
declare module "lodash/curry" {
declare module.exports: $Exports<"lodash">["curry"];
}
declare module "lodash/curryRight" {
declare module.exports: $Exports<"lodash">["curryRight"];
}
declare module "lodash/debounce" {
declare module.exports: $Exports<"lodash">["debounce"];
}
declare module "lodash/defer" {
declare module.exports: $Exports<"lodash">["defer"];
}
declare module "lodash/delay" {
declare module.exports: $Exports<"lodash">["delay"];
}
declare module "lodash/flip" {
declare module.exports: $Exports<"lodash">["flip"];
}
declare module "lodash/memoize" {
declare module.exports: $Exports<"lodash">["memoize"];
}
declare module "lodash/negate" {
declare module.exports: $Exports<"lodash">["negate"];
}
declare module "lodash/once" {
declare module.exports: $Exports<"lodash">["once"];
}
declare module "lodash/overArgs" {
declare module.exports: $Exports<"lodash">["overArgs"];
}
declare module "lodash/partial" {
declare module.exports: $Exports<"lodash">["partial"];
}
declare module "lodash/partialRight" {
declare module.exports: $Exports<"lodash">["partialRight"];
}
declare module "lodash/rearg" {
declare module.exports: $Exports<"lodash">["rearg"];
}
declare module "lodash/rest" {
declare module.exports: $Exports<"lodash">["rest"];
}
declare module "lodash/spread" {
declare module.exports: $Exports<"lodash">["spread"];
}
declare module "lodash/throttle" {
declare module.exports: $Exports<"lodash">["throttle"];
}
declare module "lodash/unary" {
declare module.exports: $Exports<"lodash">["unary"];
}
declare module "lodash/wrap" {
declare module.exports: $Exports<"lodash">["wrap"];
}
declare module "lodash/castArray" {
declare module.exports: $Exports<"lodash">["castArray"];
}
declare module "lodash/clone" {
declare module.exports: $Exports<"lodash">["clone"];
}
declare module "lodash/cloneDeep" {
declare module.exports: $Exports<"lodash">["cloneDeep"];
}
declare module "lodash/cloneDeepWith" {
declare module.exports: $Exports<"lodash">["cloneDeepWith"];
}
declare module "lodash/cloneWith" {
declare module.exports: $Exports<"lodash">["cloneWith"];
}
declare module "lodash/conformsTo" {
declare module.exports: $Exports<"lodash">["conformsTo"];
}
declare module "lodash/eq" {
declare module.exports: $Exports<"lodash">["eq"];
}
declare module "lodash/gt" {
declare module.exports: $Exports<"lodash">["gt"];
}
declare module "lodash/gte" {
declare module.exports: $Exports<"lodash">["gte"];
}
declare module "lodash/isArguments" {
declare module.exports: $Exports<"lodash">["isArguments"];
}
declare module "lodash/isArray" {
declare module.exports: $Exports<"lodash">["isArray"];
}
declare module "lodash/isArrayBuffer" {
declare module.exports: $Exports<"lodash">["isArrayBuffer"];
}
declare module "lodash/isArrayLike" {
declare module.exports: $Exports<"lodash">["isArrayLike"];
}
declare module "lodash/isArrayLikeObject" {
declare module.exports: $Exports<"lodash">["isArrayLikeObject"];
}
declare module "lodash/isBoolean" {
declare module.exports: $Exports<"lodash">["isBoolean"];
}
declare module "lodash/isBuffer" {
declare module.exports: $Exports<"lodash">["isBuffer"];
}
declare module "lodash/isDate" {
declare module.exports: $Exports<"lodash">["isDate"];
}
declare module "lodash/isElement" {
declare module.exports: $Exports<"lodash">["isElement"];
}
declare module "lodash/isEmpty" {
declare module.exports: $Exports<"lodash">["isEmpty"];
}
declare module "lodash/isEqual" {
declare module.exports: $Exports<"lodash">["isEqual"];
}
declare module "lodash/isEqualWith" {
declare module.exports: $Exports<"lodash">["isEqualWith"];
}
declare module "lodash/isError" {
declare module.exports: $Exports<"lodash">["isError"];
}
declare module "lodash/isFinite" {
declare module.exports: $Exports<"lodash">["isFinite"];
}
declare module "lodash/isFunction" {
declare module.exports: $Exports<"lodash">["isFunction"];
}
declare module "lodash/isInteger" {
declare module.exports: $Exports<"lodash">["isInteger"];
}
declare module "lodash/isLength" {
declare module.exports: $Exports<"lodash">["isLength"];
}
declare module "lodash/isMap" {
declare module.exports: $Exports<"lodash">["isMap"];
}
declare module "lodash/isMatch" {
declare module.exports: $Exports<"lodash">["isMatch"];
}
declare module "lodash/isMatchWith" {
declare module.exports: $Exports<"lodash">["isMatchWith"];
}
declare module "lodash/isNaN" {
declare module.exports: $Exports<"lodash">["isNaN"];
}
declare module "lodash/isNative" {
declare module.exports: $Exports<"lodash">["isNative"];
}
declare module "lodash/isNil" {
declare module.exports: $Exports<"lodash">["isNil"];
}
declare module "lodash/isNull" {
declare module.exports: $Exports<"lodash">["isNull"];
}
declare module "lodash/isNumber" {
declare module.exports: $Exports<"lodash">["isNumber"];
}
declare module "lodash/isObject" {
declare module.exports: $Exports<"lodash">["isObject"];
}
declare module "lodash/isObjectLike" {
declare module.exports: $Exports<"lodash">["isObjectLike"];
}
declare module "lodash/isPlainObject" {
declare module.exports: $Exports<"lodash">["isPlainObject"];
}
declare module "lodash/isRegExp" {
declare module.exports: $Exports<"lodash">["isRegExp"];
}
declare module "lodash/isSafeInteger" {
declare module.exports: $Exports<"lodash">["isSafeInteger"];
}
declare module "lodash/isSet" {
declare module.exports: $Exports<"lodash">["isSet"];
}
declare module "lodash/isString" {
declare module.exports: $Exports<"lodash">["isString"];
}
declare module "lodash/isSymbol" {
declare module.exports: $Exports<"lodash">["isSymbol"];
}
declare module "lodash/isTypedArray" {
declare module.exports: $Exports<"lodash">["isTypedArray"];
}
declare module "lodash/isUndefined" {
declare module.exports: $Exports<"lodash">["isUndefined"];
}
declare module "lodash/isWeakMap" {
declare module.exports: $Exports<"lodash">["isWeakMap"];
}
declare module "lodash/isWeakSet" {
declare module.exports: $Exports<"lodash">["isWeakSet"];
}
declare module "lodash/lt" {
declare module.exports: $Exports<"lodash">["lt"];
}
declare module "lodash/lte" {
declare module.exports: $Exports<"lodash">["lte"];
}
declare module "lodash/toArray" {
declare module.exports: $Exports<"lodash">["toArray"];
}
declare module "lodash/toFinite" {
declare module.exports: $Exports<"lodash">["toFinite"];
}
declare module "lodash/toInteger" {
declare module.exports: $Exports<"lodash">["toInteger"];
}
declare module "lodash/toLength" {
declare module.exports: $Exports<"lodash">["toLength"];
}
declare module "lodash/toNumber" {
declare module.exports: $Exports<"lodash">["toNumber"];
}
declare module "lodash/toPlainObject" {
declare module.exports: $Exports<"lodash">["toPlainObject"];
}
declare module "lodash/toSafeInteger" {
declare module.exports: $Exports<"lodash">["toSafeInteger"];
}
declare module "lodash/toString" {
declare module.exports: $Exports<"lodash">["toString"];
}
declare module "lodash/add" {
declare module.exports: $Exports<"lodash">["add"];
}
declare module "lodash/ceil" {
declare module.exports: $Exports<"lodash">["ceil"];
}
declare module "lodash/divide" {
declare module.exports: $Exports<"lodash">["divide"];
}
declare module "lodash/floor" {
declare module.exports: $Exports<"lodash">["floor"];
}
declare module "lodash/max" {
declare module.exports: $Exports<"lodash">["max"];
}
declare module "lodash/maxBy" {
declare module.exports: $Exports<"lodash">["maxBy"];
}
declare module "lodash/mean" {
declare module.exports: $Exports<"lodash">["mean"];
}
declare module "lodash/meanBy" {
declare module.exports: $Exports<"lodash">["meanBy"];
}
declare module "lodash/min" {
declare module.exports: $Exports<"lodash">["min"];
}
declare module "lodash/minBy" {
declare module.exports: $Exports<"lodash">["minBy"];
}
declare module "lodash/multiply" {
declare module.exports: $Exports<"lodash">["multiply"];
}
declare module "lodash/round" {
declare module.exports: $Exports<"lodash">["round"];
}
declare module "lodash/subtract" {
declare module.exports: $Exports<"lodash">["subtract"];
}
declare module "lodash/sum" {
declare module.exports: $Exports<"lodash">["sum"];
}
declare module "lodash/sumBy" {
declare module.exports: $Exports<"lodash">["sumBy"];
}
declare module "lodash/clamp" {
declare module.exports: $Exports<"lodash">["clamp"];
}
declare module "lodash/inRange" {
declare module.exports: $Exports<"lodash">["inRange"];
}
declare module "lodash/random" {
declare module.exports: $Exports<"lodash">["random"];
}
declare module "lodash/assign" {
declare module.exports: $Exports<"lodash">["assign"];
}
declare module "lodash/assignIn" {
declare module.exports: $Exports<"lodash">["assignIn"];
}
declare module "lodash/assignInWith" {
declare module.exports: $Exports<"lodash">["assignInWith"];
}
declare module "lodash/assignWith" {
declare module.exports: $Exports<"lodash">["assignWith"];
}
declare module "lodash/at" {
declare module.exports: $Exports<"lodash">["at"];
}
declare module "lodash/create" {
declare module.exports: $Exports<"lodash">["create"];
}
declare module "lodash/defaults" {
declare module.exports: $Exports<"lodash">["defaults"];
}
declare module "lodash/defaultsDeep" {
declare module.exports: $Exports<"lodash">["defaultsDeep"];
}
declare module "lodash/entries" {
declare module.exports: $Exports<"lodash">["entries"];
}
declare module "lodash/entriesIn" {
declare module.exports: $Exports<"lodash">["entriesIn"];
}
declare module "lodash/extend" {
declare module.exports: $Exports<"lodash">["extend"];
}
declare module "lodash/extendWith" {
declare module.exports: $Exports<"lodash">["extendWith"];
}
declare module "lodash/findKey" {
declare module.exports: $Exports<"lodash">["findKey"];
}
declare module "lodash/findLastKey" {
declare module.exports: $Exports<"lodash">["findLastKey"];
}
declare module "lodash/forIn" {
declare module.exports: $Exports<"lodash">["forIn"];
}
declare module "lodash/forInRight" {
declare module.exports: $Exports<"lodash">["forInRight"];
}
declare module "lodash/forOwn" {
declare module.exports: $Exports<"lodash">["forOwn"];
}
declare module "lodash/forOwnRight" {
declare module.exports: $Exports<"lodash">["forOwnRight"];
}
declare module "lodash/functions" {
declare module.exports: $Exports<"lodash">["functions"];
}
declare module "lodash/functionsIn" {
declare module.exports: $Exports<"lodash">["functionsIn"];
}
declare module "lodash/get" {
declare module.exports: $Exports<"lodash">["get"];
}
declare module "lodash/has" {
declare module.exports: $Exports<"lodash">["has"];
}
declare module "lodash/hasIn" {
declare module.exports: $Exports<"lodash">["hasIn"];
}
declare module "lodash/invert" {
declare module.exports: $Exports<"lodash">["invert"];
}
declare module "lodash/invertBy" {
declare module.exports: $Exports<"lodash">["invertBy"];
}
declare module "lodash/invoke" {
declare module.exports: $Exports<"lodash">["invoke"];
}
declare module "lodash/keys" {
declare module.exports: $Exports<"lodash">["keys"];
}
declare module "lodash/keysIn" {
declare module.exports: $Exports<"lodash">["keysIn"];
}
declare module "lodash/mapKeys" {
declare module.exports: $Exports<"lodash">["mapKeys"];
}
declare module "lodash/mapValues" {
declare module.exports: $Exports<"lodash">["mapValues"];
}
declare module "lodash/merge" {
declare module.exports: $Exports<"lodash">["merge"];
}
declare module "lodash/mergeWith" {
declare module.exports: $Exports<"lodash">["mergeWith"];
}
declare module "lodash/omit" {
declare module.exports: $Exports<"lodash">["omit"];
}
declare module "lodash/omitBy" {
declare module.exports: $Exports<"lodash">["omitBy"];
}
declare module "lodash/pick" {
declare module.exports: $Exports<"lodash">["pick"];
}
declare module "lodash/pickBy" {
declare module.exports: $Exports<"lodash">["pickBy"];
}
declare module "lodash/result" {
declare module.exports: $Exports<"lodash">["result"];
}
declare module "lodash/set" {
declare module.exports: $Exports<"lodash">["set"];
}
declare module "lodash/setWith" {
declare module.exports: $Exports<"lodash">["setWith"];
}
declare module "lodash/toPairs" {
declare module.exports: $Exports<"lodash">["toPairs"];
}
declare module "lodash/toPairsIn" {
declare module.exports: $Exports<"lodash">["toPairsIn"];
}
declare module "lodash/transform" {
declare module.exports: $Exports<"lodash">["transform"];
}
declare module "lodash/unset" {
declare module.exports: $Exports<"lodash">["unset"];
}
declare module "lodash/update" {
declare module.exports: $Exports<"lodash">["update"];
}
declare module "lodash/updateWith" {
declare module.exports: $Exports<"lodash">["updateWith"];
}
declare module "lodash/values" {
declare module.exports: $Exports<"lodash">["values"];
}
declare module "lodash/valuesIn" {
declare module.exports: $Exports<"lodash">["valuesIn"];
}
declare module "lodash/chain" {
declare module.exports: $Exports<"lodash">["chain"];
}
declare module "lodash/tap" {
declare module.exports: $Exports<"lodash">["tap"];
}
declare module "lodash/thru" {
declare module.exports: $Exports<"lodash">["thru"];
}
declare module "lodash/camelCase" {
declare module.exports: $Exports<"lodash">["camelCase"];
}
declare module "lodash/capitalize" {
declare module.exports: $Exports<"lodash">["capitalize"];
}
declare module "lodash/deburr" {
declare module.exports: $Exports<"lodash">["deburr"];
}
declare module "lodash/endsWith" {
declare module.exports: $Exports<"lodash">["endsWith"];
}
declare module "lodash/escape" {
declare module.exports: $Exports<"lodash">["escape"];
}
declare module "lodash/escapeRegExp" {
declare module.exports: $Exports<"lodash">["escapeRegExp"];
}
declare module "lodash/kebabCase" {
declare module.exports: $Exports<"lodash">["kebabCase"];
}
declare module "lodash/lowerCase" {
declare module.exports: $Exports<"lodash">["lowerCase"];
}
declare module "lodash/lowerFirst" {
declare module.exports: $Exports<"lodash">["lowerFirst"];
}
declare module "lodash/pad" {
declare module.exports: $Exports<"lodash">["pad"];
}
declare module "lodash/padEnd" {
declare module.exports: $Exports<"lodash">["padEnd"];
}
declare module "lodash/padStart" {
declare module.exports: $Exports<"lodash">["padStart"];
}
declare module "lodash/parseInt" {
declare module.exports: $Exports<"lodash">["parseInt"];
}
declare module "lodash/repeat" {
declare module.exports: $Exports<"lodash">["repeat"];
}
declare module "lodash/replace" {
declare module.exports: $Exports<"lodash">["replace"];
}
declare module "lodash/snakeCase" {
declare module.exports: $Exports<"lodash">["snakeCase"];
}
declare module "lodash/split" {
declare module.exports: $Exports<"lodash">["split"];
}
declare module "lodash/startCase" {
declare module.exports: $Exports<"lodash">["startCase"];
}
declare module "lodash/startsWith" {
declare module.exports: $Exports<"lodash">["startsWith"];
}
declare module "lodash/template" {
declare module.exports: $Exports<"lodash">["template"];
}
declare module "lodash/toLower" {
declare module.exports: $Exports<"lodash">["toLower"];
}
declare module "lodash/toUpper" {
declare module.exports: $Exports<"lodash">["toUpper"];
}
declare module "lodash/trim" {
declare module.exports: $Exports<"lodash">["trim"];
}
declare module "lodash/trimEnd" {
declare module.exports: $Exports<"lodash">["trimEnd"];
}
declare module "lodash/trimStart" {
declare module.exports: $Exports<"lodash">["trimStart"];
}
declare module "lodash/truncate" {
declare module.exports: $Exports<"lodash">["truncate"];
}
declare module "lodash/unescape" {
declare module.exports: $Exports<"lodash">["unescape"];
}
declare module "lodash/upperCase" {
declare module.exports: $Exports<"lodash">["upperCase"];
}
declare module "lodash/upperFirst" {
declare module.exports: $Exports<"lodash">["upperFirst"];
}
declare module "lodash/words" {
declare module.exports: $Exports<"lodash">["words"];
}
declare module "lodash/attempt" {
declare module.exports: $Exports<"lodash">["attempt"];
}
declare module "lodash/bindAll" {
declare module.exports: $Exports<"lodash">["bindAll"];
}
declare module "lodash/cond" {
declare module.exports: $Exports<"lodash">["cond"];
}
declare module "lodash/conforms" {
declare module.exports: $Exports<"lodash">["conforms"];
}
declare module "lodash/constant" {
declare module.exports: $Exports<"lodash">["constant"];
}
declare module "lodash/defaultTo" {
declare module.exports: $Exports<"lodash">["defaultTo"];
}
declare module "lodash/flow" {
declare module.exports: $Exports<"lodash">["flow"];
}
declare module "lodash/flowRight" {
declare module.exports: $Exports<"lodash">["flowRight"];
}
declare module "lodash/identity" {
declare module.exports: $Exports<"lodash">["identity"];
}
declare module "lodash/iteratee" {
declare module.exports: $Exports<"lodash">["iteratee"];
}
declare module "lodash/matches" {
declare module.exports: $Exports<"lodash">["matches"];
}
declare module "lodash/matchesProperty" {
declare module.exports: $Exports<"lodash">["matchesProperty"];
}
declare module "lodash/method" {
declare module.exports: $Exports<"lodash">["method"];
}
declare module "lodash/methodOf" {
declare module.exports: $Exports<"lodash">["methodOf"];
}
declare module "lodash/mixin" {
declare module.exports: $Exports<"lodash">["mixin"];
}
declare module "lodash/noConflict" {
declare module.exports: $Exports<"lodash">["noConflict"];
}
declare module "lodash/noop" {
declare module.exports: $Exports<"lodash">["noop"];
}
declare module "lodash/nthArg" {
declare module.exports: $Exports<"lodash">["nthArg"];
}
declare module "lodash/over" {
declare module.exports: $Exports<"lodash">["over"];
}
declare module "lodash/overEvery" {
declare module.exports: $Exports<"lodash">["overEvery"];
}
declare module "lodash/overSome" {
declare module.exports: $Exports<"lodash">["overSome"];
}
declare module "lodash/property" {
declare module.exports: $Exports<"lodash">["property"];
}
declare module "lodash/propertyOf" {
declare module.exports: $Exports<"lodash">["propertyOf"];
}
declare module "lodash/range" {
declare module.exports: $Exports<"lodash">["range"];
}
declare module "lodash/rangeRight" {
declare module.exports: $Exports<"lodash">["rangeRight"];
}
declare module "lodash/runInContext" {
declare module.exports: $Exports<"lodash">["runInContext"];
}
declare module "lodash/stubArray" {
declare module.exports: $Exports<"lodash">["stubArray"];
}
declare module "lodash/stubFalse" {
declare module.exports: $Exports<"lodash">["stubFalse"];
}
declare module "lodash/stubObject" {
declare module.exports: $Exports<"lodash">["stubObject"];
}
declare module "lodash/stubString" {
declare module.exports: $Exports<"lodash">["stubString"];
}
declare module "lodash/stubTrue" {
declare module.exports: $Exports<"lodash">["stubTrue"];
}
declare module "lodash/times" {
declare module.exports: $Exports<"lodash">["times"];
}
declare module "lodash/toPath" {
declare module.exports: $Exports<"lodash">["toPath"];
}
declare module "lodash/uniqueId" {
declare module.exports: $Exports<"lodash">["uniqueId"];
}
declare module "lodash/fp/chunk" {
declare module.exports: $Exports<"lodash/fp">["chunk"];
}
declare module "lodash/fp/compact" {
declare module.exports: $Exports<"lodash/fp">["compact"];
}
declare module "lodash/fp/concat" {
declare module.exports: $Exports<"lodash/fp">["concat"];
}
declare module "lodash/fp/difference" {
declare module.exports: $Exports<"lodash/fp">["difference"];
}
declare module "lodash/fp/differenceBy" {
declare module.exports: $Exports<"lodash/fp">["differenceBy"];
}
declare module "lodash/fp/differenceWith" {
declare module.exports: $Exports<"lodash/fp">["differenceWith"];
}
declare module "lodash/fp/drop" {
declare module.exports: $Exports<"lodash/fp">["drop"];
}
declare module "lodash/fp/dropLast" {
declare module.exports: $Exports<"lodash/fp">["dropLast"];
}
declare module "lodash/fp/dropRight" {
declare module.exports: $Exports<"lodash/fp">["dropRight"];
}
declare module "lodash/fp/dropRightWhile" {
declare module.exports: $Exports<"lodash/fp">["dropRightWhile"];
}
declare module "lodash/fp/dropWhile" {
declare module.exports: $Exports<"lodash/fp">["dropWhile"];
}
declare module "lodash/fp/dropLastWhile" {
declare module.exports: $Exports<"lodash/fp">["dropLastWhile"];
}
declare module "lodash/fp/fill" {
declare module.exports: $Exports<"lodash/fp">["fill"];
}
declare module "lodash/fp/findIndex" {
declare module.exports: $Exports<"lodash/fp">["findIndex"];
}
declare module "lodash/fp/findIndexFrom" {
declare module.exports: $Exports<"lodash/fp">["findIndexFrom"];
}
declare module "lodash/fp/findLastIndex" {
declare module.exports: $Exports<"lodash/fp">["findLastIndex"];
}
declare module "lodash/fp/findLastIndexFrom" {
declare module.exports: $Exports<"lodash/fp">["findLastIndexFrom"];
}
declare module "lodash/fp/first" {
declare module.exports: $Exports<"lodash/fp">["first"];
}
declare module "lodash/fp/flatten" {
declare module.exports: $Exports<"lodash/fp">["flatten"];
}
declare module "lodash/fp/unnest" {
declare module.exports: $Exports<"lodash/fp">["unnest"];
}
declare module "lodash/fp/flattenDeep" {
declare module.exports: $Exports<"lodash/fp">["flattenDeep"];
}
declare module "lodash/fp/flattenDepth" {
declare module.exports: $Exports<"lodash/fp">["flattenDepth"];
}
declare module "lodash/fp/fromPairs" {
declare module.exports: $Exports<"lodash/fp">["fromPairs"];
}
declare module "lodash/fp/head" {
declare module.exports: $Exports<"lodash/fp">["head"];
}
declare module "lodash/fp/indexOf" {
declare module.exports: $Exports<"lodash/fp">["indexOf"];
}
declare module "lodash/fp/indexOfFrom" {
declare module.exports: $Exports<"lodash/fp">["indexOfFrom"];
}
declare module "lodash/fp/initial" {
declare module.exports: $Exports<"lodash/fp">["initial"];
}
declare module "lodash/fp/init" {
declare module.exports: $Exports<"lodash/fp">["init"];
}
declare module "lodash/fp/intersection" {
declare module.exports: $Exports<"lodash/fp">["intersection"];
}
declare module "lodash/fp/intersectionBy" {
declare module.exports: $Exports<"lodash/fp">["intersectionBy"];
}
declare module "lodash/fp/intersectionWith" {
declare module.exports: $Exports<"lodash/fp">["intersectionWith"];
}
declare module "lodash/fp/join" {
declare module.exports: $Exports<"lodash/fp">["join"];
}
declare module "lodash/fp/last" {
declare module.exports: $Exports<"lodash/fp">["last"];
}
declare module "lodash/fp/lastIndexOf" {
declare module.exports: $Exports<"lodash/fp">["lastIndexOf"];
}
declare module "lodash/fp/lastIndexOfFrom" {
declare module.exports: $Exports<"lodash/fp">["lastIndexOfFrom"];
}
declare module "lodash/fp/nth" {
declare module.exports: $Exports<"lodash/fp">["nth"];
}
declare module "lodash/fp/pull" {
declare module.exports: $Exports<"lodash/fp">["pull"];
}
declare module "lodash/fp/pullAll" {
declare module.exports: $Exports<"lodash/fp">["pullAll"];
}
declare module "lodash/fp/pullAllBy" {
declare module.exports: $Exports<"lodash/fp">["pullAllBy"];
}
declare module "lodash/fp/pullAllWith" {
declare module.exports: $Exports<"lodash/fp">["pullAllWith"];
}
declare module "lodash/fp/pullAt" {
declare module.exports: $Exports<"lodash/fp">["pullAt"];
}
declare module "lodash/fp/remove" {
declare module.exports: $Exports<"lodash/fp">["remove"];
}
declare module "lodash/fp/reverse" {
declare module.exports: $Exports<"lodash/fp">["reverse"];
}
declare module "lodash/fp/slice" {
declare module.exports: $Exports<"lodash/fp">["slice"];
}
declare module "lodash/fp/sortedIndex" {
declare module.exports: $Exports<"lodash/fp">["sortedIndex"];
}
declare module "lodash/fp/sortedIndexBy" {
declare module.exports: $Exports<"lodash/fp">["sortedIndexBy"];
}
declare module "lodash/fp/sortedIndexOf" {
declare module.exports: $Exports<"lodash/fp">["sortedIndexOf"];
}
declare module "lodash/fp/sortedLastIndex" {
declare module.exports: $Exports<"lodash/fp">["sortedLastIndex"];
}
declare module "lodash/fp/sortedLastIndexBy" {
declare module.exports: $Exports<"lodash/fp">["sortedLastIndexBy"];
}
declare module "lodash/fp/sortedLastIndexOf" {
declare module.exports: $Exports<"lodash/fp">["sortedLastIndexOf"];
}
declare module "lodash/fp/sortedUniq" {
declare module.exports: $Exports<"lodash/fp">["sortedUniq"];
}
declare module "lodash/fp/sortedUniqBy" {
declare module.exports: $Exports<"lodash/fp">["sortedUniqBy"];
}
declare module "lodash/fp/tail" {
declare module.exports: $Exports<"lodash/fp">["tail"];
}
declare module "lodash/fp/take" {
declare module.exports: $Exports<"lodash/fp">["take"];
}
declare module "lodash/fp/takeRight" {
declare module.exports: $Exports<"lodash/fp">["takeRight"];
}
declare module "lodash/fp/takeLast" {
declare module.exports: $Exports<"lodash/fp">["takeLast"];
}
declare module "lodash/fp/takeRightWhile" {
declare module.exports: $Exports<"lodash/fp">["takeRightWhile"];
}
declare module "lodash/fp/takeLastWhile" {
declare module.exports: $Exports<"lodash/fp">["takeLastWhile"];
}
declare module "lodash/fp/takeWhile" {
declare module.exports: $Exports<"lodash/fp">["takeWhile"];
}
declare module "lodash/fp/union" {
declare module.exports: $Exports<"lodash/fp">["union"];
}
declare module "lodash/fp/unionBy" {
declare module.exports: $Exports<"lodash/fp">["unionBy"];
}
declare module "lodash/fp/unionWith" {
declare module.exports: $Exports<"lodash/fp">["unionWith"];
}
declare module "lodash/fp/uniq" {
declare module.exports: $Exports<"lodash/fp">["uniq"];
}
declare module "lodash/fp/uniqBy" {
declare module.exports: $Exports<"lodash/fp">["uniqBy"];
}
declare module "lodash/fp/uniqWith" {
declare module.exports: $Exports<"lodash/fp">["uniqWith"];
}
declare module "lodash/fp/unzip" {
declare module.exports: $Exports<"lodash/fp">["unzip"];
}
declare module "lodash/fp/unzipWith" {
declare module.exports: $Exports<"lodash/fp">["unzipWith"];
}
declare module "lodash/fp/without" {
declare module.exports: $Exports<"lodash/fp">["without"];
}
declare module "lodash/fp/xor" {
declare module.exports: $Exports<"lodash/fp">["xor"];
}
declare module "lodash/fp/symmetricDifference" {
declare module.exports: $Exports<"lodash/fp">["symmetricDifference"];
}
declare module "lodash/fp/xorBy" {
declare module.exports: $Exports<"lodash/fp">["xorBy"];
}
declare module "lodash/fp/symmetricDifferenceBy" {
declare module.exports: $Exports<"lodash/fp">["symmetricDifferenceBy"];
}
declare module "lodash/fp/xorWith" {
declare module.exports: $Exports<"lodash/fp">["xorWith"];
}
declare module "lodash/fp/symmetricDifferenceWith" {
declare module.exports: $Exports<"lodash/fp">["symmetricDifferenceWith"];
}
declare module "lodash/fp/zip" {
declare module.exports: $Exports<"lodash/fp">["zip"];
}
declare module "lodash/fp/zipAll" {
declare module.exports: $Exports<"lodash/fp">["zipAll"];
}
declare module "lodash/fp/zipObject" {
declare module.exports: $Exports<"lodash/fp">["zipObject"];
}
declare module "lodash/fp/zipObj" {
declare module.exports: $Exports<"lodash/fp">["zipObj"];
}
declare module "lodash/fp/zipObjectDeep" {
declare module.exports: $Exports<"lodash/fp">["zipObjectDeep"];
}
declare module "lodash/fp/zipWith" {
declare module.exports: $Exports<"lodash/fp">["zipWith"];
}
declare module "lodash/fp/countBy" {
declare module.exports: $Exports<"lodash/fp">["countBy"];
}
declare module "lodash/fp/each" {
declare module.exports: $Exports<"lodash/fp">["each"];
}
declare module "lodash/fp/eachRight" {
declare module.exports: $Exports<"lodash/fp">["eachRight"];
}
declare module "lodash/fp/every" {
declare module.exports: $Exports<"lodash/fp">["every"];
}
declare module "lodash/fp/all" {
declare module.exports: $Exports<"lodash/fp">["all"];
}
declare module "lodash/fp/filter" {
declare module.exports: $Exports<"lodash/fp">["filter"];
}
declare module "lodash/fp/find" {
declare module.exports: $Exports<"lodash/fp">["find"];
}
declare module "lodash/fp/findFrom" {
declare module.exports: $Exports<"lodash/fp">["findFrom"];
}
declare module "lodash/fp/findLast" {
declare module.exports: $Exports<"lodash/fp">["findLast"];
}
declare module "lodash/fp/findLastFrom" {
declare module.exports: $Exports<"lodash/fp">["findLastFrom"];
}
declare module "lodash/fp/flatMap" {
declare module.exports: $Exports<"lodash/fp">["flatMap"];
}
declare module "lodash/fp/flatMapDeep" {
declare module.exports: $Exports<"lodash/fp">["flatMapDeep"];
}
declare module "lodash/fp/flatMapDepth" {
declare module.exports: $Exports<"lodash/fp">["flatMapDepth"];
}
declare module "lodash/fp/forEach" {
declare module.exports: $Exports<"lodash/fp">["forEach"];
}
declare module "lodash/fp/forEachRight" {
declare module.exports: $Exports<"lodash/fp">["forEachRight"];
}
declare module "lodash/fp/groupBy" {
declare module.exports: $Exports<"lodash/fp">["groupBy"];
}
declare module "lodash/fp/includes" {
declare module.exports: $Exports<"lodash/fp">["includes"];
}
declare module "lodash/fp/contains" {
declare module.exports: $Exports<"lodash/fp">["contains"];
}
declare module "lodash/fp/includesFrom" {
declare module.exports: $Exports<"lodash/fp">["includesFrom"];
}
declare module "lodash/fp/invokeMap" {
declare module.exports: $Exports<"lodash/fp">["invokeMap"];
}
declare module "lodash/fp/invokeArgsMap" {
declare module.exports: $Exports<"lodash/fp">["invokeArgsMap"];
}
declare module "lodash/fp/keyBy" {
declare module.exports: $Exports<"lodash/fp">["keyBy"];
}
declare module "lodash/fp/indexBy" {
declare module.exports: $Exports<"lodash/fp">["indexBy"];
}
declare module "lodash/fp/map" {
declare module.exports: $Exports<"lodash/fp">["map"];
}
declare module "lodash/fp/pluck" {
declare module.exports: $Exports<"lodash/fp">["pluck"];
}
declare module "lodash/fp/orderBy" {
declare module.exports: $Exports<"lodash/fp">["orderBy"];
}
declare module "lodash/fp/partition" {
declare module.exports: $Exports<"lodash/fp">["partition"];
}
declare module "lodash/fp/reduce" {
declare module.exports: $Exports<"lodash/fp">["reduce"];
}
declare module "lodash/fp/reduceRight" {
declare module.exports: $Exports<"lodash/fp">["reduceRight"];
}
declare module "lodash/fp/reject" {
declare module.exports: $Exports<"lodash/fp">["reject"];
}
declare module "lodash/fp/sample" {
declare module.exports: $Exports<"lodash/fp">["sample"];
}
declare module "lodash/fp/sampleSize" {
declare module.exports: $Exports<"lodash/fp">["sampleSize"];
}
declare module "lodash/fp/shuffle" {
declare module.exports: $Exports<"lodash/fp">["shuffle"];
}
declare module "lodash/fp/size" {
declare module.exports: $Exports<"lodash/fp">["size"];
}
declare module "lodash/fp/some" {
declare module.exports: $Exports<"lodash/fp">["some"];
}
declare module "lodash/fp/any" {
declare module.exports: $Exports<"lodash/fp">["any"];
}
declare module "lodash/fp/sortBy" {
declare module.exports: $Exports<"lodash/fp">["sortBy"];
}
declare module "lodash/fp/now" {
declare module.exports: $Exports<"lodash/fp">["now"];
}
declare module "lodash/fp/after" {
declare module.exports: $Exports<"lodash/fp">["after"];
}
declare module "lodash/fp/ary" {
declare module.exports: $Exports<"lodash/fp">["ary"];
}
declare module "lodash/fp/nAry" {
declare module.exports: $Exports<"lodash/fp">["nAry"];
}
declare module "lodash/fp/before" {
declare module.exports: $Exports<"lodash/fp">["before"];
}
declare module "lodash/fp/bind" {
declare module.exports: $Exports<"lodash/fp">["bind"];
}
declare module "lodash/fp/bindKey" {
declare module.exports: $Exports<"lodash/fp">["bindKey"];
}
declare module "lodash/fp/curry" {
declare module.exports: $Exports<"lodash/fp">["curry"];
}
declare module "lodash/fp/curryN" {
declare module.exports: $Exports<"lodash/fp">["curryN"];
}
declare module "lodash/fp/curryRight" {
declare module.exports: $Exports<"lodash/fp">["curryRight"];
}
declare module "lodash/fp/curryRightN" {
declare module.exports: $Exports<"lodash/fp">["curryRightN"];
}
declare module "lodash/fp/debounce" {
declare module.exports: $Exports<"lodash/fp">["debounce"];
}
declare module "lodash/fp/defer" {
declare module.exports: $Exports<"lodash/fp">["defer"];
}
declare module "lodash/fp/delay" {
declare module.exports: $Exports<"lodash/fp">["delay"];
}
declare module "lodash/fp/flip" {
declare module.exports: $Exports<"lodash/fp">["flip"];
}
declare module "lodash/fp/memoize" {
declare module.exports: $Exports<"lodash/fp">["memoize"];
}
declare module "lodash/fp/negate" {
declare module.exports: $Exports<"lodash/fp">["negate"];
}
declare module "lodash/fp/complement" {
declare module.exports: $Exports<"lodash/fp">["complement"];
}
declare module "lodash/fp/once" {
declare module.exports: $Exports<"lodash/fp">["once"];
}
declare module "lodash/fp/overArgs" {
declare module.exports: $Exports<"lodash/fp">["overArgs"];
}
declare module "lodash/fp/useWith" {
declare module.exports: $Exports<"lodash/fp">["useWith"];
}
declare module "lodash/fp/partial" {
declare module.exports: $Exports<"lodash/fp">["partial"];
}
declare module "lodash/fp/partialRight" {
declare module.exports: $Exports<"lodash/fp">["partialRight"];
}
declare module "lodash/fp/rearg" {
declare module.exports: $Exports<"lodash/fp">["rearg"];
}
declare module "lodash/fp/rest" {
declare module.exports: $Exports<"lodash/fp">["rest"];
}
declare module "lodash/fp/unapply" {
declare module.exports: $Exports<"lodash/fp">["unapply"];
}
declare module "lodash/fp/restFrom" {
declare module.exports: $Exports<"lodash/fp">["restFrom"];
}
declare module "lodash/fp/spread" {
declare module.exports: $Exports<"lodash/fp">["spread"];
}
declare module "lodash/fp/apply" {
declare module.exports: $Exports<"lodash/fp">["apply"];
}
declare module "lodash/fp/spreadFrom" {
declare module.exports: $Exports<"lodash/fp">["spreadFrom"];
}
declare module "lodash/fp/throttle" {
declare module.exports: $Exports<"lodash/fp">["throttle"];
}
declare module "lodash/fp/unary" {
declare module.exports: $Exports<"lodash/fp">["unary"];
}
declare module "lodash/fp/wrap" {
declare module.exports: $Exports<"lodash/fp">["wrap"];
}
declare module "lodash/fp/castArray" {
declare module.exports: $Exports<"lodash/fp">["castArray"];
}
declare module "lodash/fp/clone" {
declare module.exports: $Exports<"lodash/fp">["clone"];
}
declare module "lodash/fp/cloneDeep" {
declare module.exports: $Exports<"lodash/fp">["cloneDeep"];
}
declare module "lodash/fp/cloneDeepWith" {
declare module.exports: $Exports<"lodash/fp">["cloneDeepWith"];
}
declare module "lodash/fp/cloneWith" {
declare module.exports: $Exports<"lodash/fp">["cloneWith"];
}
declare module "lodash/fp/conformsTo" {
declare module.exports: $Exports<"lodash/fp">["conformsTo"];
}
declare module "lodash/fp/where" {
declare module.exports: $Exports<"lodash/fp">["where"];
}
declare module "lodash/fp/conforms" {
declare module.exports: $Exports<"lodash/fp">["conforms"];
}
declare module "lodash/fp/eq" {
declare module.exports: $Exports<"lodash/fp">["eq"];
}
declare module "lodash/fp/identical" {
declare module.exports: $Exports<"lodash/fp">["identical"];
}
declare module "lodash/fp/gt" {
declare module.exports: $Exports<"lodash/fp">["gt"];
}
declare module "lodash/fp/gte" {
declare module.exports: $Exports<"lodash/fp">["gte"];
}
declare module "lodash/fp/isArguments" {
declare module.exports: $Exports<"lodash/fp">["isArguments"];
}
declare module "lodash/fp/isArray" {
declare module.exports: $Exports<"lodash/fp">["isArray"];
}
declare module "lodash/fp/isArrayBuffer" {
declare module.exports: $Exports<"lodash/fp">["isArrayBuffer"];
}
declare module "lodash/fp/isArrayLike" {
declare module.exports: $Exports<"lodash/fp">["isArrayLike"];
}
declare module "lodash/fp/isArrayLikeObject" {
declare module.exports: $Exports<"lodash/fp">["isArrayLikeObject"];
}
declare module "lodash/fp/isBoolean" {
declare module.exports: $Exports<"lodash/fp">["isBoolean"];
}
declare module "lodash/fp/isBuffer" {
declare module.exports: $Exports<"lodash/fp">["isBuffer"];
}
declare module "lodash/fp/isDate" {
declare module.exports: $Exports<"lodash/fp">["isDate"];
}
declare module "lodash/fp/isElement" {
declare module.exports: $Exports<"lodash/fp">["isElement"];
}
declare module "lodash/fp/isEmpty" {
declare module.exports: $Exports<"lodash/fp">["isEmpty"];
}
declare module "lodash/fp/isEqual" {
declare module.exports: $Exports<"lodash/fp">["isEqual"];
}
declare module "lodash/fp/equals" {
declare module.exports: $Exports<"lodash/fp">["equals"];
}
declare module "lodash/fp/isEqualWith" {
declare module.exports: $Exports<"lodash/fp">["isEqualWith"];
}
declare module "lodash/fp/isError" {
declare module.exports: $Exports<"lodash/fp">["isError"];
}
declare module "lodash/fp/isFinite" {
declare module.exports: $Exports<"lodash/fp">["isFinite"];
}
declare module "lodash/fp/isFunction" {
declare module.exports: $Exports<"lodash/fp">["isFunction"];
}
declare module "lodash/fp/isInteger" {
declare module.exports: $Exports<"lodash/fp">["isInteger"];
}
declare module "lodash/fp/isLength" {
declare module.exports: $Exports<"lodash/fp">["isLength"];
}
declare module "lodash/fp/isMap" {
declare module.exports: $Exports<"lodash/fp">["isMap"];
}
declare module "lodash/fp/isMatch" {
declare module.exports: $Exports<"lodash/fp">["isMatch"];
}
declare module "lodash/fp/whereEq" {
declare module.exports: $Exports<"lodash/fp">["whereEq"];
}
declare module "lodash/fp/isMatchWith" {
declare module.exports: $Exports<"lodash/fp">["isMatchWith"];
}
declare module "lodash/fp/isNaN" {
declare module.exports: $Exports<"lodash/fp">["isNaN"];
}
declare module "lodash/fp/isNative" {
declare module.exports: $Exports<"lodash/fp">["isNative"];
}
declare module "lodash/fp/isNil" {
declare module.exports: $Exports<"lodash/fp">["isNil"];
}
declare module "lodash/fp/isNull" {
declare module.exports: $Exports<"lodash/fp">["isNull"];
}
declare module "lodash/fp/isNumber" {
declare module.exports: $Exports<"lodash/fp">["isNumber"];
}
declare module "lodash/fp/isObject" {
declare module.exports: $Exports<"lodash/fp">["isObject"];
}
declare module "lodash/fp/isObjectLike" {
declare module.exports: $Exports<"lodash/fp">["isObjectLike"];
}
declare module "lodash/fp/isPlainObject" {
declare module.exports: $Exports<"lodash/fp">["isPlainObject"];
}
declare module "lodash/fp/isRegExp" {
declare module.exports: $Exports<"lodash/fp">["isRegExp"];
}
declare module "lodash/fp/isSafeInteger" {
declare module.exports: $Exports<"lodash/fp">["isSafeInteger"];
}
declare module "lodash/fp/isSet" {
declare module.exports: $Exports<"lodash/fp">["isSet"];
}
declare module "lodash/fp/isString" {
declare module.exports: $Exports<"lodash/fp">["isString"];
}
declare module "lodash/fp/isSymbol" {
declare module.exports: $Exports<"lodash/fp">["isSymbol"];
}
declare module "lodash/fp/isTypedArray" {
declare module.exports: $Exports<"lodash/fp">["isTypedArray"];
}
declare module "lodash/fp/isUndefined" {
declare module.exports: $Exports<"lodash/fp">["isUndefined"];
}
declare module "lodash/fp/isWeakMap" {
declare module.exports: $Exports<"lodash/fp">["isWeakMap"];
}
declare module "lodash/fp/isWeakSet" {
declare module.exports: $Exports<"lodash/fp">["isWeakSet"];
}
declare module "lodash/fp/lt" {
declare module.exports: $Exports<"lodash/fp">["lt"];
}
declare module "lodash/fp/lte" {
declare module.exports: $Exports<"lodash/fp">["lte"];
}
declare module "lodash/fp/toArray" {
declare module.exports: $Exports<"lodash/fp">["toArray"];
}
declare module "lodash/fp/toFinite" {
declare module.exports: $Exports<"lodash/fp">["toFinite"];
}
declare module "lodash/fp/toInteger" {
declare module.exports: $Exports<"lodash/fp">["toInteger"];
}
declare module "lodash/fp/toLength" {
declare module.exports: $Exports<"lodash/fp">["toLength"];
}
declare module "lodash/fp/toNumber" {
declare module.exports: $Exports<"lodash/fp">["toNumber"];
}
declare module "lodash/fp/toPlainObject" {
declare module.exports: $Exports<"lodash/fp">["toPlainObject"];
}
declare module "lodash/fp/toSafeInteger" {
declare module.exports: $Exports<"lodash/fp">["toSafeInteger"];
}
declare module "lodash/fp/toString" {
declare module.exports: $Exports<"lodash/fp">["toString"];
}
declare module "lodash/fp/add" {
declare module.exports: $Exports<"lodash/fp">["add"];
}
declare module "lodash/fp/ceil" {
declare module.exports: $Exports<"lodash/fp">["ceil"];
}
declare module "lodash/fp/divide" {
declare module.exports: $Exports<"lodash/fp">["divide"];
}
declare module "lodash/fp/floor" {
declare module.exports: $Exports<"lodash/fp">["floor"];
}
declare module "lodash/fp/max" {
declare module.exports: $Exports<"lodash/fp">["max"];
}
declare module "lodash/fp/maxBy" {
declare module.exports: $Exports<"lodash/fp">["maxBy"];
}
declare module "lodash/fp/mean" {
declare module.exports: $Exports<"lodash/fp">["mean"];
}
declare module "lodash/fp/meanBy" {
declare module.exports: $Exports<"lodash/fp">["meanBy"];
}
declare module "lodash/fp/min" {
declare module.exports: $Exports<"lodash/fp">["min"];
}
declare module "lodash/fp/minBy" {
declare module.exports: $Exports<"lodash/fp">["minBy"];
}
declare module "lodash/fp/multiply" {
declare module.exports: $Exports<"lodash/fp">["multiply"];
}
declare module "lodash/fp/round" {
declare module.exports: $Exports<"lodash/fp">["round"];
}
declare module "lodash/fp/subtract" {
declare module.exports: $Exports<"lodash/fp">["subtract"];
}
declare module "lodash/fp/sum" {
declare module.exports: $Exports<"lodash/fp">["sum"];
}
declare module "lodash/fp/sumBy" {
declare module.exports: $Exports<"lodash/fp">["sumBy"];
}
declare module "lodash/fp/clamp" {
declare module.exports: $Exports<"lodash/fp">["clamp"];
}
declare module "lodash/fp/inRange" {
declare module.exports: $Exports<"lodash/fp">["inRange"];
}
declare module "lodash/fp/random" {
declare module.exports: $Exports<"lodash/fp">["random"];
}
declare module "lodash/fp/assign" {
declare module.exports: $Exports<"lodash/fp">["assign"];
}
declare module "lodash/fp/assignAll" {
declare module.exports: $Exports<"lodash/fp">["assignAll"];
}
declare module "lodash/fp/assignInAll" {
declare module.exports: $Exports<"lodash/fp">["assignInAll"];
}
declare module "lodash/fp/extendAll" {
declare module.exports: $Exports<"lodash/fp">["extendAll"];
}
declare module "lodash/fp/assignIn" {
declare module.exports: $Exports<"lodash/fp">["assignIn"];
}
declare module "lodash/fp/assignInWith" {
declare module.exports: $Exports<"lodash/fp">["assignInWith"];
}
declare module "lodash/fp/assignWith" {
declare module.exports: $Exports<"lodash/fp">["assignWith"];
}
declare module "lodash/fp/assignInAllWith" {
declare module.exports: $Exports<"lodash/fp">["assignInAllWith"];
}
declare module "lodash/fp/extendAllWith" {
declare module.exports: $Exports<"lodash/fp">["extendAllWith"];
}
declare module "lodash/fp/assignAllWith" {
declare module.exports: $Exports<"lodash/fp">["assignAllWith"];
}
declare module "lodash/fp/at" {
declare module.exports: $Exports<"lodash/fp">["at"];
}
declare module "lodash/fp/props" {
declare module.exports: $Exports<"lodash/fp">["props"];
}
declare module "lodash/fp/paths" {
declare module.exports: $Exports<"lodash/fp">["paths"];
}
declare module "lodash/fp/create" {
declare module.exports: $Exports<"lodash/fp">["create"];
}
declare module "lodash/fp/defaults" {
declare module.exports: $Exports<"lodash/fp">["defaults"];
}
declare module "lodash/fp/defaultsAll" {
declare module.exports: $Exports<"lodash/fp">["defaultsAll"];
}
declare module "lodash/fp/defaultsDeep" {
declare module.exports: $Exports<"lodash/fp">["defaultsDeep"];
}
declare module "lodash/fp/defaultsDeepAll" {
declare module.exports: $Exports<"lodash/fp">["defaultsDeepAll"];
}
declare module "lodash/fp/entries" {
declare module.exports: $Exports<"lodash/fp">["entries"];
}
declare module "lodash/fp/entriesIn" {
declare module.exports: $Exports<"lodash/fp">["entriesIn"];
}
declare module "lodash/fp/extend" {
declare module.exports: $Exports<"lodash/fp">["extend"];
}
declare module "lodash/fp/extendWith" {
declare module.exports: $Exports<"lodash/fp">["extendWith"];
}
declare module "lodash/fp/findKey" {
declare module.exports: $Exports<"lodash/fp">["findKey"];
}
declare module "lodash/fp/findLastKey" {
declare module.exports: $Exports<"lodash/fp">["findLastKey"];
}
declare module "lodash/fp/forIn" {
declare module.exports: $Exports<"lodash/fp">["forIn"];
}
declare module "lodash/fp/forInRight" {
declare module.exports: $Exports<"lodash/fp">["forInRight"];
}
declare module "lodash/fp/forOwn" {
declare module.exports: $Exports<"lodash/fp">["forOwn"];
}
declare module "lodash/fp/forOwnRight" {
declare module.exports: $Exports<"lodash/fp">["forOwnRight"];
}
declare module "lodash/fp/functions" {
declare module.exports: $Exports<"lodash/fp">["functions"];
}
declare module "lodash/fp/functionsIn" {
declare module.exports: $Exports<"lodash/fp">["functionsIn"];
}
declare module "lodash/fp/get" {
declare module.exports: $Exports<"lodash/fp">["get"];
}
declare module "lodash/fp/prop" {
declare module.exports: $Exports<"lodash/fp">["prop"];
}
declare module "lodash/fp/path" {
declare module.exports: $Exports<"lodash/fp">["path"];
}
declare module "lodash/fp/getOr" {
declare module.exports: $Exports<"lodash/fp">["getOr"];
}
declare module "lodash/fp/propOr" {
declare module.exports: $Exports<"lodash/fp">["propOr"];
}
declare module "lodash/fp/pathOr" {
declare module.exports: $Exports<"lodash/fp">["pathOr"];
}
declare module "lodash/fp/has" {
declare module.exports: $Exports<"lodash/fp">["has"];
}
declare module "lodash/fp/hasIn" {
declare module.exports: $Exports<"lodash/fp">["hasIn"];
}
declare module "lodash/fp/invert" {
declare module.exports: $Exports<"lodash/fp">["invert"];
}
declare module "lodash/fp/invertObj" {
declare module.exports: $Exports<"lodash/fp">["invertObj"];
}
declare module "lodash/fp/invertBy" {
declare module.exports: $Exports<"lodash/fp">["invertBy"];
}
declare module "lodash/fp/invoke" {
declare module.exports: $Exports<"lodash/fp">["invoke"];
}
declare module "lodash/fp/invokeArgs" {
declare module.exports: $Exports<"lodash/fp">["invokeArgs"];
}
declare module "lodash/fp/keys" {
declare module.exports: $Exports<"lodash/fp">["keys"];
}
declare module "lodash/fp/keysIn" {
declare module.exports: $Exports<"lodash/fp">["keysIn"];
}
declare module "lodash/fp/mapKeys" {
declare module.exports: $Exports<"lodash/fp">["mapKeys"];
}
declare module "lodash/fp/mapValues" {
declare module.exports: $Exports<"lodash/fp">["mapValues"];
}
declare module "lodash/fp/merge" {
declare module.exports: $Exports<"lodash/fp">["merge"];
}
declare module "lodash/fp/mergeAll" {
declare module.exports: $Exports<"lodash/fp">["mergeAll"];
}
declare module "lodash/fp/mergeWith" {
declare module.exports: $Exports<"lodash/fp">["mergeWith"];
}
declare module "lodash/fp/mergeAllWith" {
declare module.exports: $Exports<"lodash/fp">["mergeAllWith"];
}
declare module "lodash/fp/omit" {
declare module.exports: $Exports<"lodash/fp">["omit"];
}
declare module "lodash/fp/omitAll" {
declare module.exports: $Exports<"lodash/fp">["omitAll"];
}
declare module "lodash/fp/omitBy" {
declare module.exports: $Exports<"lodash/fp">["omitBy"];
}
declare module "lodash/fp/pick" {
declare module.exports: $Exports<"lodash/fp">["pick"];
}
declare module "lodash/fp/pickAll" {
declare module.exports: $Exports<"lodash/fp">["pickAll"];
}
declare module "lodash/fp/pickBy" {
declare module.exports: $Exports<"lodash/fp">["pickBy"];
}
declare module "lodash/fp/result" {
declare module.exports: $Exports<"lodash/fp">["result"];
}
declare module "lodash/fp/set" {
declare module.exports: $Exports<"lodash/fp">["set"];
}
declare module "lodash/fp/assoc" {
declare module.exports: $Exports<"lodash/fp">["assoc"];
}
declare module "lodash/fp/assocPath" {
declare module.exports: $Exports<"lodash/fp">["assocPath"];
}
declare module "lodash/fp/setWith" {
declare module.exports: $Exports<"lodash/fp">["setWith"];
}
declare module "lodash/fp/toPairs" {
declare module.exports: $Exports<"lodash/fp">["toPairs"];
}
declare module "lodash/fp/toPairsIn" {
declare module.exports: $Exports<"lodash/fp">["toPairsIn"];
}
declare module "lodash/fp/transform" {
declare module.exports: $Exports<"lodash/fp">["transform"];
}
declare module "lodash/fp/unset" {
declare module.exports: $Exports<"lodash/fp">["unset"];
}
declare module "lodash/fp/update" {
declare module.exports: $Exports<"lodash/fp">["update"];
}
declare module "lodash/fp/updateWith" {
declare module.exports: $Exports<"lodash/fp">["updateWith"];
}
declare module "lodash/fp/values" {
declare module.exports: $Exports<"lodash/fp">["values"];
}
declare module "lodash/fp/valuesIn" {
declare module.exports: $Exports<"lodash/fp">["valuesIn"];
}
declare module "lodash/fp/tap" {
declare module.exports: $Exports<"lodash/fp">["tap"];
}
declare module "lodash/fp/thru" {
declare module.exports: $Exports<"lodash/fp">["thru"];
}
declare module "lodash/fp/camelCase" {
declare module.exports: $Exports<"lodash/fp">["camelCase"];
}
declare module "lodash/fp/capitalize" {
declare module.exports: $Exports<"lodash/fp">["capitalize"];
}
declare module "lodash/fp/deburr" {
declare module.exports: $Exports<"lodash/fp">["deburr"];
}
declare module "lodash/fp/endsWith" {
declare module.exports: $Exports<"lodash/fp">["endsWith"];
}
declare module "lodash/fp/escape" {
declare module.exports: $Exports<"lodash/fp">["escape"];
}
declare module "lodash/fp/escapeRegExp" {
declare module.exports: $Exports<"lodash/fp">["escapeRegExp"];
}
declare module "lodash/fp/kebabCase" {
declare module.exports: $Exports<"lodash/fp">["kebabCase"];
}
declare module "lodash/fp/lowerCase" {
declare module.exports: $Exports<"lodash/fp">["lowerCase"];
}
declare module "lodash/fp/lowerFirst" {
declare module.exports: $Exports<"lodash/fp">["lowerFirst"];
}
declare module "lodash/fp/pad" {
declare module.exports: $Exports<"lodash/fp">["pad"];
}
declare module "lodash/fp/padChars" {
declare module.exports: $Exports<"lodash/fp">["padChars"];
}
declare module "lodash/fp/padEnd" {
declare module.exports: $Exports<"lodash/fp">["padEnd"];
}
declare module "lodash/fp/padCharsEnd" {
declare module.exports: $Exports<"lodash/fp">["padCharsEnd"];
}
declare module "lodash/fp/padStart" {
declare module.exports: $Exports<"lodash/fp">["padStart"];
}
declare module "lodash/fp/padCharsStart" {
declare module.exports: $Exports<"lodash/fp">["padCharsStart"];
}
declare module "lodash/fp/parseInt" {
declare module.exports: $Exports<"lodash/fp">["parseInt"];
}
declare module "lodash/fp/repeat" {
declare module.exports: $Exports<"lodash/fp">["repeat"];
}
declare module "lodash/fp/replace" {
declare module.exports: $Exports<"lodash/fp">["replace"];
}
declare module "lodash/fp/snakeCase" {
declare module.exports: $Exports<"lodash/fp">["snakeCase"];
}
declare module "lodash/fp/split" {
declare module.exports: $Exports<"lodash/fp">["split"];
}
declare module "lodash/fp/startCase" {
declare module.exports: $Exports<"lodash/fp">["startCase"];
}
declare module "lodash/fp/startsWith" {
declare module.exports: $Exports<"lodash/fp">["startsWith"];
}
declare module "lodash/fp/template" {
declare module.exports: $Exports<"lodash/fp">["template"];
}
declare module "lodash/fp/toLower" {
declare module.exports: $Exports<"lodash/fp">["toLower"];
}
declare module "lodash/fp/toUpper" {
declare module.exports: $Exports<"lodash/fp">["toUpper"];
}
declare module "lodash/fp/trim" {
declare module.exports: $Exports<"lodash/fp">["trim"];
}
declare module "lodash/fp/trimChars" {
declare module.exports: $Exports<"lodash/fp">["trimChars"];
}
declare module "lodash/fp/trimEnd" {
declare module.exports: $Exports<"lodash/fp">["trimEnd"];
}
declare module "lodash/fp/trimCharsEnd" {
declare module.exports: $Exports<"lodash/fp">["trimCharsEnd"];
}
declare module "lodash/fp/trimStart" {
declare module.exports: $Exports<"lodash/fp">["trimStart"];
}
declare module "lodash/fp/trimCharsStart" {
declare module.exports: $Exports<"lodash/fp">["trimCharsStart"];
}
declare module "lodash/fp/truncate" {
declare module.exports: $Exports<"lodash/fp">["truncate"];
}
declare module "lodash/fp/unescape" {
declare module.exports: $Exports<"lodash/fp">["unescape"];
}
declare module "lodash/fp/upperCase" {
declare module.exports: $Exports<"lodash/fp">["upperCase"];
}
declare module "lodash/fp/upperFirst" {
declare module.exports: $Exports<"lodash/fp">["upperFirst"];
}
declare module "lodash/fp/words" {
declare module.exports: $Exports<"lodash/fp">["words"];
}
declare module "lodash/fp/attempt" {
declare module.exports: $Exports<"lodash/fp">["attempt"];
}
declare module "lodash/fp/bindAll" {
declare module.exports: $Exports<"lodash/fp">["bindAll"];
}
declare module "lodash/fp/cond" {
declare module.exports: $Exports<"lodash/fp">["cond"];
}
declare module "lodash/fp/constant" {
declare module.exports: $Exports<"lodash/fp">["constant"];
}
declare module "lodash/fp/always" {
declare module.exports: $Exports<"lodash/fp">["always"];
}
declare module "lodash/fp/defaultTo" {
declare module.exports: $Exports<"lodash/fp">["defaultTo"];
}
declare module "lodash/fp/flow" {
declare module.exports: $Exports<"lodash/fp">["flow"];
}
declare module "lodash/fp/pipe" {
declare module.exports: $Exports<"lodash/fp">["pipe"];
}
declare module "lodash/fp/flowRight" {
declare module.exports: $Exports<"lodash/fp">["flowRight"];
}
declare module "lodash/fp/compose" {
declare module.exports: $Exports<"lodash/fp">["compose"];
}
declare module "lodash/fp/identity" {
declare module.exports: $Exports<"lodash/fp">["identity"];
}
declare module "lodash/fp/iteratee" {
declare module.exports: $Exports<"lodash/fp">["iteratee"];
}
declare module "lodash/fp/matches" {
declare module.exports: $Exports<"lodash/fp">["matches"];
}
declare module "lodash/fp/matchesProperty" {
declare module.exports: $Exports<"lodash/fp">["matchesProperty"];
}
declare module "lodash/fp/propEq" {
declare module.exports: $Exports<"lodash/fp">["propEq"];
}
declare module "lodash/fp/pathEq" {
declare module.exports: $Exports<"lodash/fp">["pathEq"];
}
declare module "lodash/fp/method" {
declare module.exports: $Exports<"lodash/fp">["method"];
}
declare module "lodash/fp/methodOf" {
declare module.exports: $Exports<"lodash/fp">["methodOf"];
}
declare module "lodash/fp/mixin" {
declare module.exports: $Exports<"lodash/fp">["mixin"];
}
declare module "lodash/fp/noConflict" {
declare module.exports: $Exports<"lodash/fp">["noConflict"];
}
declare module "lodash/fp/noop" {
declare module.exports: $Exports<"lodash/fp">["noop"];
}
declare module "lodash/fp/nthArg" {
declare module.exports: $Exports<"lodash/fp">["nthArg"];
}
declare module "lodash/fp/over" {
declare module.exports: $Exports<"lodash/fp">["over"];
}
declare module "lodash/fp/juxt" {
declare module.exports: $Exports<"lodash/fp">["juxt"];
}
declare module "lodash/fp/overEvery" {
declare module.exports: $Exports<"lodash/fp">["overEvery"];
}
declare module "lodash/fp/allPass" {
declare module.exports: $Exports<"lodash/fp">["allPass"];
}
declare module "lodash/fp/overSome" {
declare module.exports: $Exports<"lodash/fp">["overSome"];
}
declare module "lodash/fp/anyPass" {
declare module.exports: $Exports<"lodash/fp">["anyPass"];
}
declare module "lodash/fp/property" {
declare module.exports: $Exports<"lodash/fp">["property"];
}
declare module "lodash/fp/propertyOf" {
declare module.exports: $Exports<"lodash/fp">["propertyOf"];
}
declare module "lodash/fp/range" {
declare module.exports: $Exports<"lodash/fp">["range"];
}
declare module "lodash/fp/rangeStep" {
declare module.exports: $Exports<"lodash/fp">["rangeStep"];
}
declare module "lodash/fp/rangeRight" {
declare module.exports: $Exports<"lodash/fp">["rangeRight"];
}
declare module "lodash/fp/rangeStepRight" {
declare module.exports: $Exports<"lodash/fp">["rangeStepRight"];
}
declare module "lodash/fp/runInContext" {
declare module.exports: $Exports<"lodash/fp">["runInContext"];
}
declare module "lodash/fp/stubArray" {
declare module.exports: $Exports<"lodash/fp">["stubArray"];
}
declare module "lodash/fp/stubFalse" {
declare module.exports: $Exports<"lodash/fp">["stubFalse"];
}
declare module "lodash/fp/F" {
declare module.exports: $Exports<"lodash/fp">["F"];
}
declare module "lodash/fp/stubObject" {
declare module.exports: $Exports<"lodash/fp">["stubObject"];
}
declare module "lodash/fp/stubString" {
declare module.exports: $Exports<"lodash/fp">["stubString"];
}
declare module "lodash/fp/stubTrue" {
declare module.exports: $Exports<"lodash/fp">["stubTrue"];
}
declare module "lodash/fp/T" {
declare module.exports: $Exports<"lodash/fp">["T"];
}
declare module "lodash/fp/times" {
declare module.exports: $Exports<"lodash/fp">["times"];
}
declare module "lodash/fp/toPath" {
declare module.exports: $Exports<"lodash/fp">["toPath"];
}
declare module "lodash/fp/uniqueId" {
declare module.exports: $Exports<"lodash/fp">["uniqueId"];
}