// flow-typed signature: 1b1fe531123a979fe1c4624ccc62bd5a
// flow-typed version: dea0770be9/lodash_v4.x.x/flow_>=v0.63.x
declare module "lodash" {
declare type __CurriedFunction1 = (...r: [AA]) => R;
declare type CurriedFunction1 = __CurriedFunction1;
declare type __CurriedFunction2 = ((
...r: [AA]
) => CurriedFunction1) &
((...r: [AA, BB]) => R);
declare type CurriedFunction2 = __CurriedFunction2;
declare type __CurriedFunction3 = ((
...r: [AA]
) => CurriedFunction2) &
((...r: [AA, BB]) => CurriedFunction1) &
((...r: [AA, BB, CC]) => R);
declare type CurriedFunction3 = __CurriedFunction3<
A,
B,
C,
R,
*,
*,
*
>;
declare type __CurriedFunction4<
A,
B,
C,
D,
R,
AA: A,
BB: B,
CC: C,
DD: D
> = ((...r: [AA]) => CurriedFunction3) &
((...r: [AA, BB]) => CurriedFunction2) &
((...r: [AA, BB, CC]) => CurriedFunction1) &
((...r: [AA, BB, CC, DD]) => R);
declare type CurriedFunction4 = __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) &
((...r: [AA, BB]) => CurriedFunction3) &
((...r: [AA, BB, CC]) => CurriedFunction2) &
((...r: [AA, BB, CC, DD]) => CurriedFunction1) &
((...r: [AA, BB, CC, DD, EE]) => R);
declare type CurriedFunction5 = __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) &
((...r: [AA, BB]) => CurriedFunction4) &
((...r: [AA, BB, CC]) => CurriedFunction3) &
((...r: [AA, BB, CC, DD]) => CurriedFunction2) &
((...r: [AA, BB, CC, DD, EE]) => CurriedFunction1) &
((...r: [AA, BB, CC, DD, EE, FF]) => R);
declare type CurriedFunction6 = __CurriedFunction6<
A,
B,
C,
D,
E,
F,
R,
*,
*,
*,
*,
*,
*
>;
declare type Curry = (((...r: [A]) => R) => CurriedFunction1) &
(((...r: [A, B]) => R) => CurriedFunction2) &
(((...r: [A, B, C]) => R) => CurriedFunction3) &
((
(...r: [A, B, C, D]) => R
) => CurriedFunction4) &
((
(...r: [A, B, C, D, E]) => R
) => CurriedFunction5) &
((
(...r: [A, B, C, D, E, F]) => R
) => CurriedFunction6);
declare type UnaryFn = (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 NestedArray = Array>;
declare type matchesIterateeShorthand = Object;
declare type matchesPropertyIterateeShorthand = [string, any];
declare type propertyIterateeShorthand = string;
declare type OPredicate =
| ((value: A, key: string, object: O) => any)
| matchesIterateeShorthand
| matchesPropertyIterateeShorthand
| propertyIterateeShorthand;
declare type OIterateeWithResult =
| Object
| string
| ((value: V, key: string, object: O) => R);
declare type OIteratee = OIterateeWithResult;
declare type OFlatMapIteratee = OIterateeWithResult>;
declare type Predicate =
| ((value: T, index: number, array: Array) => any)
| matchesIterateeShorthand
| matchesPropertyIterateeShorthand
| propertyIterateeShorthand;
declare type _ValueOnlyIteratee = (value: T) => mixed;
declare type ValueOnlyIteratee = _ValueOnlyIteratee | string;
declare type _Iteratee = (
item: T,
index: number,
array: ?Array
) => mixed;
declare type Iteratee = _Iteratee | Object | string;
declare type FlatMapIteratee =
| ((item: T, index: number, array: ?$ReadOnlyArray) => Array)
| Object
| string;
declare type Comparator = (item: T, item2: T) => boolean;
declare type MapIterator =
| ((item: T, index: number, array: Array) => U)
| propertyIterateeShorthand;
declare type ReadOnlyMapIterator =
| ((item: T, index: number, array: $ReadOnlyArray) => U)
| propertyIterateeShorthand;
declare type OMapIterator =
| ((item: T, key: string, object: O) => U)
| propertyIterateeShorthand;
declare class Lodash {
// Array
chunk(array?: ?Array, size?: ?number): Array>;
compact(array?: ?Array): Array;
concat(base?: ?$ReadOnlyArray, ...elements: Array): Array;
difference(array?: ?$ReadOnlyArray, ...values: Array$ReadOnlyArray>): Array;
differenceBy(
array?: ?$ReadOnlyArray,
values?: ?$ReadOnlyArray,
iteratee?: ?ValueOnlyIteratee
): T[];
differenceWith(array?: ?$ReadOnlyArray, values?: ?$ReadOnlyArray, comparator?: ?Comparator): T[];
drop(array?: ?Array, n?: ?number): Array;
dropRight(array?: ?Array, n?: ?number): Array;
dropRightWhile(array?: ?Array, predicate?: ?Predicate): Array;
dropWhile(array?: ?Array, predicate?: ?Predicate): Array;
fill(
array?: ?Array,
value?: ?U,
start?: ?number,
end?: ?number
): Array;
findIndex(
array: $ReadOnlyArray,
predicate?: ?Predicate,
fromIndex?: ?number
): number;
findIndex(
array: void | null,
predicate?: ?Predicate,
fromIndex?: ?number
): -1;
findLastIndex(
array: $ReadOnlyArray,
predicate?: ?Predicate,
fromIndex?: ?number
): number;
findLastIndex(
array: void | null,
predicate?: ?Predicate,
fromIndex?: ?number
): -1;
// alias of _.head
first(array: ?$ReadOnlyArray): T;
flatten(array?: ?Array | X>): Array;
flattenDeep(array?: ?any[]): Array;
flattenDepth(array?: ?any[], depth?: ?number): any[];
fromPairs(pairs?: ?Array<[A, B]>): { [key: A]: B };
head(array: ?$ReadOnlyArray): T;
indexOf(array: Array, value: T, fromIndex?: number): number;
indexOf(array: void | null, value?: ?T, fromIndex?: ?number): -1;
initial(array: ?Array): Array;
intersection(...arrays?: Array<$ReadOnlyArray>): Array;
//Workaround until (...parameter: T, parameter2: U) works
intersectionBy(a1?: ?$ReadOnlyArray, iteratee?: ?ValueOnlyIteratee): Array;
intersectionBy(
a1?: ?$ReadOnlyArray,
a2?: ?$ReadOnlyArray,
iteratee?: ?ValueOnlyIteratee
): Array;
intersectionBy(
a1?: ?$ReadOnlyArray,
a2?: ?$ReadOnlyArray,
a3?: ?$ReadOnlyArray,
iteratee?: ?ValueOnlyIteratee
): Array;
intersectionBy(
a1?: ?$ReadOnlyArray,
a2?: ?$ReadOnlyArray,
a3?: ?$ReadOnlyArray,
a4?: ?$ReadOnlyArray,
iteratee?: ?ValueOnlyIteratee
): Array;
//Workaround until (...parameter: T, parameter2: U) works
intersectionWith(a1?: ?$ReadOnlyArray, comparator?: ?Comparator): Array;
intersectionWith(
a1?: ?$ReadOnlyArray,
a2?: ?$ReadOnlyArray,
comparator?: ?Comparator
): Array;
intersectionWith(
a1?: ?$ReadOnlyArray,
a2?: ?$ReadOnlyArray,
a3?: ?$ReadOnlyArray,
comparator?: ?Comparator
): Array;
intersectionWith(
a1?: ?$ReadOnlyArray,
a2?: ?$ReadOnlyArray,
a3?: ?$ReadOnlyArray,
a4?: ?$ReadOnlyArray,
comparator?: ?Comparator
): Array;
join(array: Array, separator?: ?string): string;
join(array: void | null, separator?: ?string): '';
last(array: ?$ReadOnlyArray): T;
lastIndexOf(array: Array, value?: ?T, fromIndex?: ?number): number;
lastIndexOf(array: void | null, value?: ?T, fromIndex?: ?number): -1;
nth(array: T[], n?: ?number): T;
nth(array: void | null, n?: ?number): void;
pull(array: Array, ...values?: Array): Array;
pull(array: T, ...values?: Array): T;
pullAll(array: Array, values?: ?Array): Array;
pullAll(array: T, values?: ?Array): T;
pullAllBy(
array: Array,
values?: ?Array,
iteratee?: ?ValueOnlyIteratee
): Array;
pullAllBy(
array: T,
values?: ?Array,
iteratee?: ?ValueOnlyIteratee
): T;
pullAllWith(array: T[], values?: ?T[], comparator?: ?Function): T[];
pullAllWith(array: T, values?: ?Array, comparator?: ?Function): T;
pullAt(array?: ?Array, ...indexed?: Array): Array;
pullAt(array?: ?Array, indexed?: ?Array): Array;
remove(array?: ?Array, predicate?: ?Predicate): Array;
reverse(array: Array): Array;
reverse(array: T): T;
slice(array?: ?$ReadOnlyArray, start?: ?number, end?: ?number): Array;
sortedIndex(array: Array, value: T): number;
sortedIndex(array: void | null, value: ?T): 0;
sortedIndexBy(
array: Array,
value?: ?T,
iteratee?: ?ValueOnlyIteratee
): number;
sortedIndexBy(
array: void | null,
value?: ?T,
iteratee?: ?ValueOnlyIteratee
): 0;
sortedIndexOf(array: Array, value: T): number;
sortedIndexOf(array: void | null, value?: ?T): -1;
sortedLastIndex(array: Array, value: T): number;
sortedLastIndex(array: void | null, value?: ?T): 0;
sortedLastIndexBy(
array: Array,
value: T,
iteratee?: ValueOnlyIteratee
): number;
sortedLastIndexBy(
array: void | null,
value?: ?T,
iteratee?: ?ValueOnlyIteratee
): 0;
sortedLastIndexOf(array: Array, value: T): number;
sortedLastIndexOf(array: void | null, value?: ?T): -1;
sortedUniq(array?: ?Array): Array;
sortedUniqBy(array?: ?Array, iteratee?: ?(value: T) => mixed): Array;
tail(array?: ?Array): Array;
take(array?: ?Array, n?: ?number): Array;
takeRight(array?: ?Array, n?: ?number): Array;
takeRightWhile(array?: ?Array, predicate?: ?Predicate): Array;
takeWhile(array?: ?Array, predicate?: ?Predicate): Array;
union(...arrays?: Array<$ReadOnlyArray>): Array