Lodash fp autocurry

convert.js

const readline = require(`readline`);
const fs = require(`fs`);

const rl = readline.createInterface({
    input: fs.createReadStream(`./to_parse_v4.x.x.js`),
});

const getArgs = /((\(\([^\)]*\)[^\)]*\))|[\w?]|(: )|(\<[^\>]*\>)|(\([^\)]*\))|( => )|( \| )|(\{[^\}]*\})|(\[[^\]]*\])|[\<\>]|( \& ))+/g;

const split = (line) => {
  const start = line.indexOf(`(`);
  const end = line.lastIndexOf(`)`);
  return {
    before: line.slice(0, start),
    args: line.slice(start + 1, end).match(getArgs) || [],
    after: line.slice(end + 3, line.length - 1),
  };
}

const isMethod = (line) => {
  return line.includes(`(`) && line.includes(`)`);
};

const output = fs.createWriteStream(`./result.js`);

const printGroup = (args, from, to) => {
  return `(${args.slice(from, to).join(`, `)})`;
}

const print = (args, config) => {
  const pairs = config.reduce((result, value) => {
    const prev = ((result[result.length - 1] || [])[1] || 0);
    result.push([prev, value + prev])
    return result;
  }, [])
  let printed = pairs.reduce((result, [from, to], i) => {
    if (i === 0) {
      return `${printGroup(args, from, to)}: `;
    }
    return result + `${printGroup(args, from, to)} => `
  }, ``);
  printed += `${printGroup(args, pairs[pairs.length - 1][1])} =>`
  return printed;
}

const printAll = (before, args, after, configs) => {
  return configs
    .map((config) => print(args, config))
    .map((printedArgs) => `${before}${printedArgs}${after}\n`)
    .join(``);
}

const writeCurried = (line) => {
  if (line.includes(`constant`)) {
    return;
  }
  if (isMethod(line)) {
    const {before, args, after} = split(line);
    if (!args || args.length < 2) {
      return;
    }
    if (args.length === 2) {
      output.write(`${before}(${args[0]}): (${args[1]}) => ${after},\n`);
    }
    if (args.length === 3) {
      output.write(`${before}(${args[0]}): ((${args[1]}) => (${args[2]}) => ${after}) & ((${args[1]}, ${args[2]}) => ${after}),\n`);
      output.write(`${before}(${args[0]}, ${args[1]}): (${args[2]}) => ${after},\n`);
    }
    if (args.length === 4) {
      output.write(`${before}(${args[0]}): ((${args[1]}) => (((${args[2]}) => (${args[3]}) => ${after}) & ((${args[2]}, ${args[3]}) => ${after}))) & ((${args[1]}, ${args[2]}) => (${args[3]}) => ${after}) & ((${args[1]}, ${args[2]}, ${args[3]}) => ${after}),\n`)
      output.write(`${before}(${args[0]}, ${args[1]}): ((${args[2]}) => (${args[3]}) => ${after}) & ((${args[2]}, ${args[3]}) => ${after}),\n`);
      output.write(`${before}(${args[0]}, ${args[1]}, ${args[2]}): (${args[3]}) => ${after},\n`);
    }
    if (args.length > 4) {
      throw new Error(args.length);
    }
  }
};

rl.on(`line`, (line) => {
  writeCurried(line)
  output.write(line);
  output.write(`\n`);
});

to_parse_v4.x.x.js

// Array
chunk<T>(size: number): (array: Array<T>) => Array<Array<T>>,
chunk<T>(size: number, array: Array<T>): Array<Array<T>>,
compact<T, N: T>(array: Array<N>): Array<T>,
concat<T, U, A: Array<T> | T, B: Array<U> | U>(base: A): (elements: B) => Array<T | U>,
concat<T, U, A: Array<T> | T, B: Array<U> | U>(base: A, elements: B): Array<T | U>,
difference<T>(values: Array<T>): (array: Array<T>) => Array<T>,
difference<T>(values: Array<T>, array: Array<T>): Array<T>,
differenceBy<T>(iteratee: ValueOnlyIteratee<T>): ((values: Array<T>) => (array: Array<T>) => T[]) & ((values: Array<T>, array: Array<T>) => T[]),
differenceBy<T>(iteratee: ValueOnlyIteratee<T>, values: Array<T>): (array: Array<T>) => T[],
differenceBy<T>(iteratee: ValueOnlyIteratee<T>, values: Array<T>, array: Array<T>): T[],
differenceWith<T>(values: T[]): ((comparator: Comparator<T>) => (array: T[]) => T[]) & ((comparator: Comparator<T>, array: T[]) => T[]),
differenceWith<T>(values: T[], comparator: Comparator<T>): (array: T[]) => T[],
differenceWith<T>(values: T[], comparator: Comparator<T>, array: T[]): T[],
drop<T>(n: number): (array: Array<T>) => Array<T>,
drop<T>(n: number, array: Array<T>): Array<T>,
dropLast<T>(n: number): (array: Array<T>) => Array<T>,
dropLast<T>(n: number, array: Array<T>): Array<T>,
dropRight<T>(n: number): (array: Array<T>) => Array<T>,
dropRight<T>(n: number, array: Array<T>): Array<T>,
dropRightWhile<T>(predicate: Predicate<T>): (array: Array<T>) => Array<T>,
dropRightWhile<T>(predicate: Predicate<T>, array: Array<T>): Array<T>,
dropWhile<T>(predicate: Predicate<T>): (array: Array<T>) => Array<T>,
dropWhile<T>(predicate: Predicate<T>, array: Array<T>): Array<T>,
dropLastWhile<T>(predicate: Predicate<T>): (array: Array<T>) => Array<T>,
dropLastWhile<T>(predicate: Predicate<T>, array: Array<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>),
fill<T, U>(start: number, end: number): ((value: U) => (array: Array<T>) => Array<T | U>) & ((value: U, array: Array<T>) => Array<T | U>),
fill<T, U>(start: number, end: number, value: U): (array: Array<T>) => Array<T | U>,
fill<T, U>(start: number, end: number, value: U, array: Array<T>): Array<T | U>,
findIndex<T>(predicate: Predicate<T>): (array: Array<T>) => number,
findIndex<T>(predicate: Predicate<T>, array: Array<T>): number,
findIndexFrom<T>(predicate: Predicate<T>): ((fromIndex: number) => (array: Array<T>) => number) & ((fromIndex: number, array: Array<T>) => number),
findIndexFrom<T>(predicate: Predicate<T>, fromIndex: number): (array: Array<T>) => number,
findIndexFrom<T>(predicate: Predicate<T>, fromIndex: number, array: Array<T>): number,
findLastIndex<T>(predicate: Predicate<T>): (array: Array<T>) => number,
findLastIndex<T>(predicate: Predicate<T>, array: Array<T>): number,
findLastIndexFrom<T>(predicate: Predicate<T>): ((fromIndex: number) => (array: Array<T>) => number) & ((fromIndex: number, array: Array<T>) => number),
findLastIndexFrom<T>(predicate: Predicate<T>, fromIndex: number): (array: Array<T>) => number,
findLastIndexFrom<T>(predicate: Predicate<T>, fromIndex: number, array: Array<T>): number,
// alias of _.head
first<T>(array: Array<T>): T,
flatten<T, X>(array: Array<Array<T> | X>): Array<T | X>,
unnest<T, X>(array: Array<Array<T> | X>): Array<T | X>,
flattenDeep<T>(array: any[]): Array<T>,
flattenDepth(depth: number): (array: any[]) => any[],
flattenDepth(depth: number, array: any[]): any[],
fromPairs<T>(pairs: Array<T>): Object,
head<T>(array: Array<T>): T,
indexOf<T>(value: T): (array: Array<T>) => number,
indexOf<T>(value: T, array: Array<T>): number,
indexOfFrom<T>(value: T): ((fromIndex: number) => (array: Array<T>) => number) & ((fromIndex: number, array: Array<T>) => number),
indexOfFrom<T>(value: T, fromIndex: number): (array: Array<T>) => number,
indexOfFrom<T>(value: T, fromIndex: number, array: Array<T>): number,
initial<T>(array: Array<T>): Array<T>,
init<T>(array: Array<T>): Array<T>,
intersection<T>(a1: Array<T>): (a2: Array<T>) => Array<T>,
intersection<T>(a1: Array<T>, a2: Array<T>): Array<T>,
intersectionBy<T>(iteratee: ValueOnlyIteratee<T>): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) & ((a1: Array<T>, a2: Array<T>) => Array<T>),
intersectionBy<T>(iteratee: ValueOnlyIteratee<T>, a1: Array<T>): (a2: Array<T>) => Array<T>,
intersectionBy<T>(iteratee: ValueOnlyIteratee<T>, a1: Array<T>, a2: Array<T>): Array<T>,
intersectionWith<T>(comparator: Comparator<T>): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) & ((a1: Array<T>, a2: Array<T>) => Array<T>),
intersectionWith<T>(comparator: Comparator<T>, a1: Array<T>): (a2: Array<T>) => Array<T>,
intersectionWith<T>(comparator: Comparator<T>, a1: Array<T>, a2: Array<T>): Array<T>,
join<T>(separator: string): (array: Array<T>) => string,
join<T>(separator: string, array: Array<T>): string,
last<T>(array: Array<T>): T,
lastIndexOf<T>(value: T): (array: Array<T>) => number,
lastIndexOf<T>(value: T, array: Array<T>): number,
lastIndexOfFrom<T>(value: T): ((fromIndex: number) => (array: Array<T>) => number) & ((fromIndex: number, array: Array<T>) => number),
lastIndexOfFrom<T>(value: T, fromIndex: number): (array: Array<T>) => number,
lastIndexOfFrom<T>(value: T, fromIndex: number, array: Array<T>): number,
nth<T>(n: number): (array: T[]) => T,
nth<T>(n: number, array: T[]): T,
pull<T>(value: T): (array: Array<T>) => Array<T>,
pull<T>(value: T, array: Array<T>): Array<T>,
pullAll<T>(values: Array<T>): (array: Array<T>) => Array<T>,
pullAll<T>(values: Array<T>, array: Array<T>): Array<T>,
pullAllBy<T>(iteratee: ValueOnlyIteratee<T>): ((values: Array<T>) => (array: Array<T>) => Array<T>) & ((values: Array<T>, array: Array<T>) => Array<T>),
pullAllBy<T>(iteratee: ValueOnlyIteratee<T>, values: Array<T>): (array: Array<T>) => Array<T>,
pullAllBy<T>(iteratee: ValueOnlyIteratee<T>, values: Array<T>, array: Array<T>): Array<T>,
pullAllWith<T>(comparator: Function): ((values: T[]) => (array: T[]) => T[]) & ((values: T[], array: T[]) => T[]),
pullAllWith<T>(comparator: Function, values: T[]): (array: T[]) => T[],
pullAllWith<T>(comparator: Function, values: T[], array: T[]): T[],
pullAt<T>(indexed: Array<number>): (array: Array<T>) => Array<T>,
pullAt<T>(indexed: Array<number>, array: Array<T>): Array<T>,
remove<T>(predicate: Predicate<T>): (array: Array<T>) => Array<T>,
remove<T>(predicate: Predicate<T>, array: Array<T>): Array<T>,
reverse<T>(array: Array<T>): Array<T>,
slice<T>(start: number): ((end: number) => (array: Array<T>) => Array<T>) & ((end: number, array: Array<T>) => Array<T>),
slice<T>(start: number, end: number): (array: Array<T>) => Array<T>,
slice<T>(start: number, end: number, array: Array<T>): Array<T>,
sortedIndex<T>(value: T): (array: Array<T>) => number,
sortedIndex<T>(value: T, array: Array<T>): number,
sortedIndexBy<T>(iteratee: ValueOnlyIteratee<T>): ((value: T) => (array: Array<T>) => number) & ((value: T, array: Array<T>) => number),
sortedIndexBy<T>(iteratee: ValueOnlyIteratee<T>, value: T): (array: Array<T>) => number,
sortedIndexBy<T>(iteratee: ValueOnlyIteratee<T>, value: T, array: Array<T>): number,
sortedIndexOf<T>(value: T): (array: Array<T>) => number,
sortedIndexOf<T>(value: T, array: Array<T>): number,
sortedLastIndex<T>(value: T): (array: Array<T>) => number,
sortedLastIndex<T>(value: T, array: Array<T>): number,
sortedLastIndexBy<T>(iteratee: ValueOnlyIteratee<T>): ((value: T) => (array: Array<T>) => number) & ((value: T, array: Array<T>) => number),
sortedLastIndexBy<T>(iteratee: ValueOnlyIteratee<T>, value: T): (array: Array<T>) => number,
sortedLastIndexBy<T>(iteratee: ValueOnlyIteratee<T>, value: T, array: Array<T>): number,
sortedLastIndexOf<T>(value: T): (array: Array<T>) => number,
sortedLastIndexOf<T>(value: T, array: Array<T>): number,
sortedUniq<T>(array: Array<T>): Array<T>,
sortedUniqBy<T>(iteratee: (value: T) => mixed): (array: Array<T>) => Array<T>,
sortedUniqBy<T>(iteratee: (value: T) => mixed, array: Array<T>): Array<T>,
tail<T>(array: Array<T>): Array<T>,
take<T>(n: number): (array: Array<T>) => Array<T>,
take<T>(n: number, array: Array<T>): Array<T>,
takeRight<T>(n: number): (array: Array<T>) => Array<T>,
takeRight<T>(n: number, array: Array<T>): Array<T>,
takeLast<T>(n: number): (array: Array<T>) => Array<T>,
takeLast<T>(n: number, array: Array<T>): Array<T>,
takeRightWhile<T>(predicate: Predicate<T>): (array: Array<T>) => Array<T>,
takeRightWhile<T>(predicate: Predicate<T>, array: Array<T>): Array<T>,
takeLastWhile<T>(predicate: Predicate<T>): (array: Array<T>) => Array<T>,
takeLastWhile<T>(predicate: Predicate<T>, array: Array<T>): Array<T>,
takeWhile<T>(predicate: Predicate<T>): (array: Array<T>) => Array<T>,
takeWhile<T>(predicate: Predicate<T>, array: Array<T>): Array<T>,
union<T>(a1: Array<T>): (a2: Array<T>) => Array<T>,
union<T>(a1: Array<T>, a2: Array<T>): Array<T>,
unionBy<T>(iteratee: ValueOnlyIteratee<T>): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) & ((a1: Array<T>, a2: Array<T>) => Array<T>),
unionBy<T>(iteratee: ValueOnlyIteratee<T>, a1: Array<T>): (a2: Array<T>) => Array<T>,
unionBy<T>(iteratee: ValueOnlyIteratee<T>, a1: Array<T>, a2: Array<T>): Array<T>,
unionWith<T>(comparator: Comparator<T>): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) & ((a1: Array<T>, a2: Array<T>) => Array<T>),
unionWith<T>(comparator: Comparator<T>, a1: Array<T>): (a2: Array<T>) => Array<T>,
unionWith<T>(comparator: Comparator<T>, a1: Array<T>, a2: Array<T>): Array<T>,
uniq<T>(array: Array<T>): Array<T>,
uniqBy<T>(iteratee: ValueOnlyIteratee<T>): (array: Array<T>) => Array<T>,
uniqBy<T>(iteratee: ValueOnlyIteratee<T>, array: Array<T>): Array<T>,
uniqWith<T>(comparator: Comparator<T>): (array: Array<T>) => Array<T>,
uniqWith<T>(comparator: Comparator<T>, array: Array<T>): Array<T>,
unzip<T>(array: Array<T>): Array<T>,
unzipWith<T>(iteratee: Iteratee<T>): (array: Array<T>) => Array<T>,
unzipWith<T>(iteratee: Iteratee<T>, array: Array<T>): Array<T>,
without<T>(values: Array<T>): (array: Array<T>) => Array<T>,
without<T>(values: Array<T>, array: Array<T>): Array<T>,
xor<T>(a1: Array<T>): (a2: Array<T>) => Array<T>,
xor<T>(a1: Array<T>, a2: Array<T>): Array<T>,
symmetricDifference<T>(a1: Array<T>): (a2: Array<T>) => Array<T>,
symmetricDifference<T>(a1: Array<T>, a2: Array<T>): Array<T>,
xorBy<T>(iteratee: ValueOnlyIteratee<T>): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) & ((a1: Array<T>, a2: Array<T>) => Array<T>),
xorBy<T>(iteratee: ValueOnlyIteratee<T>, a1: Array<T>): (a2: Array<T>) => Array<T>,
xorBy<T>(iteratee: ValueOnlyIteratee<T>, a1: Array<T>, a2: Array<T> ): Array<T>,
symmetricDifferenceBy<T>(iteratee: ValueOnlyIteratee<T>): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) & ((a1: Array<T>, a2: Array<T>) => Array<T>),
symmetricDifferenceBy<T>(iteratee: ValueOnlyIteratee<T>, a1: Array<T>): (a2: Array<T>) => Array<T>,
symmetricDifferenceBy<T>(iteratee: ValueOnlyIteratee<T>, a1: Array<T>, a2: Array<T> ): Array<T>,
xorWith<T>(comparator: Comparator<T>): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) & ((a1: Array<T>, a2: Array<T>) => Array<T>),
xorWith<T>(comparator: Comparator<T>, a1: Array<T>): (a2: Array<T>) => Array<T>,
xorWith<T>(comparator: Comparator<T>, a1: Array<T>, a2: Array<T>): Array<T>,
symmetricDifferenceWith<T>(comparator: Comparator<T>): ((a1: Array<T>) => (a2: Array<T>) => Array<T>) & ((a1: Array<T>, a2: Array<T>) => Array<T>),
symmetricDifferenceWith<T>(comparator: Comparator<T>, a1: Array<T>): (a2: Array<T>) => Array<T>,
symmetricDifferenceWith<T>(comparator: Comparator<T>, a1: Array<T>, a2: Array<T>): Array<T>,
zip<A, B>(a1: A[]): (a2: B[]) => Array<[A, B]>,
zip<A, B>(a1: A[], a2: B[]): Array<[A, B]>,
zipAll(arrays: Array<Array<any>>): Array<any>,
zipObject(props: Array<any>): (values: Array<any>) => Object,
zipObject(props: Array<any>, values: Array<any>): Object,
zipObj(props: Array<any>): (values: Array<any>) => Object,
zipObj(props: Array<any>, values: Array<any>): Object,
zipObjectDeep(props: any[]): (values: any) => Object,
zipObjectDeep(props: 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>),
zipWith<T>(iteratee: Iteratee<T>, a1: NestedArray<T>): (a2: NestedArray<T>) => Array<T>,
zipWith<T>(iteratee: Iteratee<T>, a1: NestedArray<T>, a2: NestedArray<T>): Array<T>,
// Collection
countBy<T>(iteratee: ValueOnlyIteratee<T>): (collection: Array<T> | { [id: any]: T }) => { [string]: number },
countBy<T>(iteratee: ValueOnlyIteratee<T>, collection: Array<T> | { [id: any]: T }): { [string]: number },
// alias of _.forEach
each<T>(iteratee: Iteratee<T> | OIteratee<T>): (collection: Array<T> | { [id: any]: T }) => Array<T>,
each<T>(iteratee: Iteratee<T> | OIteratee<T>, collection: Array<T> | { [id: any]: T }): Array<T>,
// alias of _.forEachRight
eachRight<T>(iteratee: Iteratee<T> | OIteratee<T>): (collection: Array<T> | { [id: any]: T }) => Array<T>,
eachRight<T>(iteratee: Iteratee<T> | OIteratee<T>, collection: Array<T> | { [id: any]: T }): Array<T>,
every<T>(iteratee: Iteratee<T> | OIteratee<T>): (collection: Array<T> | { [id: any]: T }) => boolean,
every<T>(iteratee: Iteratee<T> | OIteratee<T>, collection: Array<T> | { [id: any]: T }): boolean,
all<T>(iteratee: Iteratee<T> | OIteratee<T>): (collection: Array<T> | { [id: any]: T }) => boolean,
all<T>(iteratee: Iteratee<T> | OIteratee<T>, collection: Array<T> | { [id: any]: T }): boolean,
filter<T>(predicate: Predicate<T> | OPredicate<T>): (collection: Array<T> | { [id: any]: T }) => Array<T>,
filter<T>(predicate: Predicate<T> | OPredicate<T>, collection: Array<T> | { [id: any]: T }): Array<T>,
find<T>(predicate: Predicate<T> | OPredicate<T>): (collection: Array<T> | { [id: any]: T }) => T | void,
find<T>(predicate: Predicate<T> | OPredicate<T>, collection: Array<T> | { [id: any]: T }): T | void,
findFrom<T>(predicate: Predicate<T> | OPredicate<T>): ((fromIndex: number) => (collection: Array<T> | { [id: any]: T }) => T | void) & ((fromIndex: number, collection: Array<T> | { [id: any]: T }) => T | void),
findFrom<T>(predicate: Predicate<T> | OPredicate<T>, fromIndex: number): (collection: Array<T> | { [id: any]: T }) => T | void,
findFrom<T>(predicate: Predicate<T> | OPredicate<T>, fromIndex: number, collection: Array<T> | { [id: any]: T }): T | void,
findLast<T>(predicate: Predicate<T> | OPredicate<T>): (collection: Array<T> | { [id: any]: T }) => T | void,
findLast<T>(predicate: Predicate<T> | OPredicate<T>, collection: Array<T> | { [id: any]: T }): T | void,
findLastFrom<T>(predicate: Predicate<T> | OPredicate<T>): ((fromIndex: number) => (collection: Array<T> | { [id: any]: T }) => T | void) & ((fromIndex: number, collection: Array<T> | { [id: any]: T }) => T | void),
findLastFrom<T>(predicate: Predicate<T> | OPredicate<T>, fromIndex: number): (collection: Array<T> | { [id: any]: T }) => T | void,
findLastFrom<T>(predicate: Predicate<T> | OPredicate<T>, fromIndex: number, collection: Array<T> | { [id: any]: T }): T | void,
flatMap<T, U>(iteratee: FlatMapIteratee<T, U> | OFlatMapIteratee<T, U>): (collection: Array<T> | { [id: any]: T }) => Array<U>,
flatMap<T, U>(iteratee: FlatMapIteratee<T, U> | OFlatMapIteratee<T, U>, collection: Array<T> | { [id: any]: T }): Array<U>,
flatMapDeep<T, U>(iteratee: FlatMapIteratee<T, U> | OFlatMapIteratee<T, U>): (collection: Array<T> | { [id: any]: T }) => Array<U>,
flatMapDeep<T, U>(iteratee: FlatMapIteratee<T, U> | OFlatMapIteratee<T, U>, collection: Array<T> | { [id: any]: T }): Array<U>,
flatMapDepth<T, U>(iteratee: FlatMapIteratee<T, U> | OFlatMapIteratee<T, U>): ((depth: number) => (collection: Array<T> | { [id: any]: T }) => Array<U>) & ((depth: number, collection: Array<T> | { [id: any]: T }) => Array<U>),
flatMapDepth<T, U>(iteratee: FlatMapIteratee<T, U> | OFlatMapIteratee<T, U>, depth: number): (collection: Array<T> | { [id: any]: T }) => Array<U>,
flatMapDepth<T, U>(iteratee: FlatMapIteratee<T, U> | OFlatMapIteratee<T, U>, depth: number, collection: Array<T> | { [id: any]: T }): Array<U>,
forEach<T>(iteratee: Iteratee<T> | OIteratee<T>): (collection: Array<T> | { [id: any]: T }) => Array<T>,
forEach<T>(iteratee: Iteratee<T> | OIteratee<T>, collection: Array<T> | { [id: any]: T }): Array<T>,
forEachRight<T>(iteratee: Iteratee<T> | OIteratee<T>): (collection: Array<T> | { [id: any]: T }) => Array<T>,
forEachRight<T>(iteratee: Iteratee<T> | OIteratee<T>, collection: Array<T> | { [id: any]: T }): Array<T>,
groupBy<V, T>(iteratee: ValueOnlyIteratee<T>): (collection: Array<T> | { [id: any]: T }) => { [key: V]: Array<T> },
groupBy<V, T>(iteratee: ValueOnlyIteratee<T>, collection: Array<T> | { [id: any]: T }): { [key: V]: Array<T> },
includes(value: string): (str: string) => boolean,
includes(value: string, str: string): boolean,
includes<T>(value: T): (collection: Array<T> | { [id: any]: T }) => boolean,
includes<T>(value: T, collection: Array<T> | { [id: any]: T }): boolean,
contains(value: string): (str: string) => boolean,
contains(value: string, str: string): boolean,
contains<T>(value: T): (collection: Array<T> | { [id: any]: T }) => boolean,
contains<T>(value: T, collection: Array<T> | { [id: any]: T }): boolean,
includesFrom(value: string): ((fromIndex: number) => (str: string) => boolean) & ((fromIndex: number, str: string) => boolean),
includesFrom(value: string, fromIndex: number): (str: string) => boolean,
includesFrom(value: string, fromIndex: number, str: string): boolean,
includesFrom<T>(value: T): ((fromIndex: number) => (collection: Array<T>) => boolean) & ((fromIndex: number, collection: Array<T>) => boolean),
includesFrom<T>(value: T, fromIndex: number): (collection: Array<T>) => boolean,
includesFrom<T>(value: T, fromIndex: number, collection: Array<T>): boolean,
invokeMap<T>(path: ((value: T) => Array<string> | string) | Array<string> | string): (collection: Array<T> | { [id: any]: T }) => Array<any>,
invokeMap<T>(path: ((value: T) => Array<string> | string) | Array<string> | string, collection: Array<T> | { [id: any]: T }): Array<any>,
invokeArgsMap<T>(path: ((value: T) => Array<string> | string) | Array<string> | string): ((collection: Array<T> | { [id: any]: T }) => (args: Array<any>) => Array<any>) & ((collection: Array<T> | { [id: any]: T }, args: Array<any>) => Array<any>),
invokeArgsMap<T>(path: ((value: T) => Array<string> | string) | Array<string> | string, collection: Array<T> | { [id: any]: T }): (args: Array<any>) => Array<any>,
invokeArgsMap<T>(path: ((value: T) => Array<string> | string) | Array<string> | string, collection: Array<T> | { [id: any]: T }, args: Array<any>): Array<any>,
keyBy<T, V>(iteratee: ValueOnlyIteratee<T>): (collection: Array<T> | { [id: any]: T }) => { [key: V]: T },
keyBy<T, V>(iteratee: ValueOnlyIteratee<T>, collection: Array<T> | { [id: any]: T }): { [key: V]: T },
indexBy<T, V>(iteratee: ValueOnlyIteratee<T>): (collection: Array<T> | { [id: any]: T }) => { [key: V]: T },
indexBy<T, V>(iteratee: ValueOnlyIteratee<T>, collection: Array<T> | { [id: any]: T }): { [key: V]: T },
map<T, U>(iteratee: MapIterator<T, U> | OMapIterator<T, U>): (collection: Array<T> | { [id: any]: T}) => Array<U>,
map<T, U>(iteratee: MapIterator<T, U> | OMapIterator<T, U>, collection: Array<T> | { [id: any]: T}): Array<U>,
map(iteratee: (char: string) => any): (str: string) => string,
map(iteratee: (char: string) => any, str: string): string,
pluck<T, U>(iteratee: MapIterator<T, U> | OMapIterator<T, U>): (collection: Array<T> | { [id: any]: T}) => Array<U>,
pluck<T, U>(iteratee: MapIterator<T, U> | OMapIterator<T, U>, collection: Array<T> | { [id: any]: T}): Array<U>,
pluck(iteratee: (char: string) => any): (str: string) => string,
pluck(iteratee: (char: string) => any, str: string): string,
orderBy<T>(iteratees: Array<Iteratee<T> | OIteratee<*>> | string): ((orders: Array<"asc" | "desc"> | string) => (collection: Array<T> | { [id: any]: T}) => Array<T>) & ((orders: Array<"asc" | "desc"> | string, collection: Array<T> | { [id: any]: T}) => Array<T>),
orderBy<T>(iteratees: Array<Iteratee<T> | OIteratee<*>> | string, orders: Array<"asc" | "desc"> | string): (collection: Array<T> | { [id: any]: T}) => Array<T>,
orderBy<T>(iteratees: Array<Iteratee<T> | OIteratee<*>> | string, orders: Array<"asc" | "desc"> | string, collection: Array<T> | { [id: any]: T}): Array<T>,
partition<T>(predicate: Predicate<T> | OPredicate<T>): (collection: Array<T> | { [id: any]: T }) => NestedArray<T>,
partition<T>(predicate: Predicate<T> | OPredicate<T>, collection: Array<T> | { [id: any]: T }): NestedArray<T>,
reduce<T, U>(iteratee: (accumulator: U, value: T) => U): ((accumulator: U) => (collection: Array<T> | { [id: any]: T}) => U) & ((accumulator: U, collection: Array<T> | { [id: any]: T}) => U),
reduce<T, U>(iteratee: (accumulator: U, value: T) => U, accumulator: U): (collection: Array<T> | { [id: any]: T}) => U,
reduce<T, U>(iteratee: (accumulator: U, value: T) => U, accumulator: U, collection: Array<T> | { [id: any]: T}): U,
reduceRight<T, U>(iteratee: (value: T, accumulator: U) => U): ((accumulator: U) => (collection: Array<T> | { [id: any]: T }) => U) & ((accumulator: U, collection: Array<T> | { [id: any]: T }) => U),
reduceRight<T, U>(iteratee: (value: T, accumulator: U) => U, accumulator: U): (collection: Array<T> | { [id: any]: T }) => U,
reduceRight<T, U>(iteratee: (value: T, accumulator: U) => U, accumulator: U, collection: Array<T> | { [id: any]: T }): U,
reject<T>(predicate: Predicate<T> | OPredicate<T>): (collection: Array<T> | { [id: any]: T }) => Array<T>,
reject<T>(predicate: Predicate<T> | OPredicate<T>, collection: Array<T> | { [id: any]: T }): Array<T>,
sample<T>(collection: Array<T> | { [id: any]: T }): T,
sampleSize<T>(n: number): (collection: Array<T> | { [id: any]: T }) => Array<T>,
sampleSize<T>(n: number, collection: Array<T> | { [id: any]: T }): Array<T>,
shuffle<T>(collection: Array<T> | { [id: any]: T }): Array<T>,
size(collection: Array<any> | Object): number,
some<T>(predicate: Predicate<T> | OPredicate<T>): (collection: Array<T> | { [id: any]: T }) => boolean,
some<T>(predicate: Predicate<T> | OPredicate<T>, collection: Array<T> | { [id: any]: T }): boolean,
any<T>(predicate: Predicate<T> | OPredicate<T>): (collection: Array<T> | { [id: any]: T }) => boolean,
any<T>(predicate: Predicate<T> | OPredicate<T>, collection: Array<T> | { [id: any]: T }): boolean,
sortBy<T>(iteratees: Array<Iteratee<T> | OIteratee<T>>): (collection: Array<T> | { [id: any]: T }) => Array<T>,
sortBy<T>(iteratees: Array<Iteratee<T> | OIteratee<T>>, collection: Array<T> | { [id: any]: T }): Array<T>,

// Date
now(): number,

// Function
after(fn: Function): (n: number) => Function,
after(fn: Function, n: number): Function,
ary(func: Function): Function,
nAry(n: number): (func: Function) => Function,
nAry(n: number, func: Function): Function,
before(fn: Function): (n: number) => Function,
before(fn: Function, n: number): Function,
bind(func: Function): (thisArg: any) => Function,
bind(func: Function, thisArg: any): Function,
bindKey(obj: Object): (key: string) => Function,
bindKey(obj: Object, key: string): Function,
curry(func: Function): Function,
curryN(arity: number): (func: Function) => Function,
curryN(arity: number, func: Function): Function,
curryRight(func: Function): Function,
curryRightN(arity: number): (func: Function) => Function,
curryRightN(arity: number, func: Function): Function,
debounce(wait: number): (func: Function) => Function,
debounce(wait: number, func: Function): Function,
defer(func: Function): number,
delay(wait: number): (func: Function) => number,
delay(wait: number, func: Function): number,
flip(func: Function): Function,
memoize(func: Function): Function,
negate(predicate: Function): Function,
complement(predicate: Function): Function,
once(func: Function): Function,
overArgs(func: Function): (transforms: Array<Function>) => Function,
overArgs(func: Function, transforms: Array<Function>): Function,
useWith(func: Function): (transforms: Array<Function>) => Function,
useWith(func: Function, transforms: Array<Function>): Function,
partial(func: Function): (partials: any[]) => Function,
partial(func: Function, partials: any[]): Function,
partialRight(func: Function): (partials: Array<any>) => Function,
partialRight(func: Function, partials: Array<any>): Function,
rearg(indexes: Array<number>): (func: Function) => Function,
rearg(indexes: Array<number>, func: Function): Function,
rest(func: Function): Function,
unapply(func: Function): Function,
restFrom(start: number): (func: Function) => Function,
restFrom(start: number, func: Function): Function,
spread(func: Function): Function,
apply(func: Function): Function,
spreadFrom(start: number): (func: Function) => Function,
spreadFrom(start: number, func: Function): Function,
throttle(wait: number): (func: Function) => Function,
throttle(wait: number, func: Function): Function,
unary(func: Function): Function,
wrap(wrapper: Function): (value: any) => Function,
wrap(wrapper: Function, value: any): Function,

// Lang
castArray(value: *): any[],
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,
cloneDeepWith<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,
cloneWith<T, U>(customizer: (value: T, key: number | string, object: T, stack: any) => U, value: T): U,
conformsTo<T: { [key: string]: mixed }>(predicates: T & { [key: string]: (x: any) => boolean }): (source: T) => boolean,
conformsTo<T: { [key: string]: mixed }>(predicates: T & { [key: string]: (x: any) => boolean }, source: T): boolean,
where<T: { [key: string]: mixed }>(predicates: T & { [key: string]: (x: any) => boolean }): (source: T) => boolean,
where<T: { [key: string]: mixed }>(predicates: T & { [key: string]: (x: any) => boolean }, source: T): boolean,
conforms<T: { [key: string]: mixed }>(predicates: T & { [key: string]: (x: any) => boolean }): (source: T) => boolean,
conforms<T: { [key: string]: mixed }>(predicates: T & { [key: string]: (x: any) => boolean }, source: T): boolean,
eq(value: any): (other: any) => boolean,
eq(value: any, other: any): boolean,
identical(value: any): (other: any) => boolean,
identical(value: any, other: any): boolean,
gt(value: any): (other: any) => boolean,
gt(value: any, other: any): boolean,
gte(value: any): (other: any) => boolean,
gte(value: any, other: any): boolean,
isArguments(value: any): boolean,
isArray(value: any): boolean,
isArrayBuffer(value: any): boolean,
isArrayLike(value: any): boolean,
isArrayLikeObject(value: any): boolean,
isBoolean(value: any): boolean,
isBuffer(value: any): boolean,
isDate(value: any): boolean,
isElement(value: any): boolean,
isEmpty(value: any): boolean,
isEqual(value: any): (other: any) => boolean,
isEqual(value: any, other: any): boolean,
equals(value: any): (other: any) => boolean,
equals(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),
isEqualWith<T, U>(customizer: (objValue: any, otherValue: any, key: number | string, object: T, other: U, stack: any) => boolean | void, value: T): (other: U) => 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,
isError(value: any): boolean,
isFinite(value: any): boolean,
isFunction(value: Function): true,
isFunction(value: number | string | void | null | Object): false,
isInteger(value: any): boolean,
isLength(value: any): boolean,
isMap(value: any): boolean,
isMatch(source: Object): (object: Object) => boolean,
isMatch(source: Object, object: Object): boolean,
whereEq(source: Object): (object: Object) => boolean,
whereEq(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),
isMatchWith<T: Object, U: Object>(customizer: (objValue: any, srcValue: any, key: number | string, object: T, source: U) => boolean | void, source: U): (object: T) => 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,
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,
isString(value: number | boolean | Function | void | null | Object | Array<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,
lt(value: any, other: any): boolean,
lte(value: any): (other: any) => boolean,
lte(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: Array<T>): T,
maxBy<T>(iteratee: Iteratee<T>): (array: Array<T>) => T,
maxBy<T>(iteratee: Iteratee<T>, array: Array<T>): T,
mean(array: Array<*>): number,
meanBy<T>(iteratee: Iteratee<T>): (array: Array<T>) => number,
meanBy<T>(iteratee: Iteratee<T>, array: Array<T>): number,
min<T>(array: Array<T>): T,
minBy<T>(iteratee: Iteratee<T>): (array: Array<T>) => T,
minBy<T>(iteratee: Iteratee<T>, array: Array<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: Array<*>): number,
sumBy<T>(iteratee: Iteratee<T>): (array: Array<T>) => number,
sumBy<T>(iteratee: Iteratee<T>, array: Array<T>): number,

// number
clamp(lower: number): ((upper: number) => (number: number) => number) & ((upper: number, number: number) => number),
clamp(lower: number, upper: number): (number: number) => number,
clamp(lower: number, upper: number, number: number): number,
inRange(start: number): ((end: number) => (number: number) => boolean) & ((end: number, number: number) => boolean),
inRange(start: number, end: number): (number: number) => boolean,
inRange(start: number, end: number, number: number): boolean,
random(lower: number): (upper: number) => number,
random(lower: number, upper: number): number,

// Object
assign(object: Object): (source: Object) => Object,
assign(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,
assignIn<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),
assignInWith<T: Object, A: Object>(customizer: (objValue: any, srcValue: any, key: string, object: T, source: A) => any | void, object: T): (s1: A) => Object,
assignInWith<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),
assignWith<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,
assignInAllWith(customizer: (objValue: any, srcValue: any, key: string, object: Object, source: Object) => any | void): (objects: Array<Object>) => Object,
assignInAllWith(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,
extendAllWith(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,
assignAllWith(customizer: (objValue: any, srcValue: any, key: string, object: Object, source: Object) => any | void, objects: Array<Object>): Object,
at(paths: Array<string>): (object: Object) => Array<any>,
at(paths: Array<string>, object: Object): Array<any>,
props(paths: Array<string>): (object: Object) => Array<any>,
props(paths: Array<string>, object: Object): Array<any>,
paths(paths: Array<string>): (object: Object) => Array<any>,
paths(paths: Array<string>, object: Object): Array<any>,
create<T>(prototype: T): $Supertype<T>,
defaults(source: Object): (object: Object) => Object,
defaults(source: Object, object: Object): Object,
defaultsAll(objects: Array<Object>): Object,
defaultsDeep(source: Object): (object: Object) => Object,
defaultsDeep(source: Object, object: Object): Object,
defaultsDeepAll(objects: Array<Object>): Object,
// alias for _.toPairs
entries(object: Object): NestedArray<any>,
// alias for _.toPairsIn
entriesIn(object: Object): NestedArray<any>,
// alias for _.assignIn
extend<A, B>(a: A): (b: B) => A & B,
extend<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),
extendWith<T: Object, A: Object>(customizer: (objValue: any, srcValue: any, key: string, object: T, source: A) => any | void, object: T): (s1: A) => Object,
extendWith<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: { [id: any]: A }>(predicate: OPredicate<A>): (object: T) => string | void,
findKey<A, T: { [id: any]: A }>(predicate: OPredicate<A>, object: T): string | void,
findLastKey<A, T: { [id: any]: A }>(predicate: OPredicate<A>): (object: T) => string | void,
findLastKey<A, T: { [id: any]: A }>(predicate: OPredicate<A>, object: T): string | void,
forIn(iteratee: OIteratee<*>): (object: Object) => Object,
forIn(iteratee: OIteratee<*>, object: Object): Object,
forInRight(iteratee: OIteratee<*>): (object: Object) => Object,
forInRight(iteratee: OIteratee<*>, object: Object): Object,
forOwn(iteratee: OIteratee<*>): (object: Object) => Object,
forOwn(iteratee: OIteratee<*>, object: Object): Object,
forOwnRight(iteratee: OIteratee<*>): (object: Object) => Object,
forOwnRight(iteratee: OIteratee<*>, object: Object): Object,
functions(object: Object): Array<string>,
functionsIn(object: Object): Array<string>,
get(path: Array<string> | string): (object: Object | Array<any>) => any,
get(path: Array<string> | string, object: Object | Array<any>): any,
prop(path: Array<string> | string): (object: Object | Array<any>) => any,
prop(path: Array<string> | string, object: Object | Array<any>): any,
path(path: Array<string> | string): (object: Object | Array<any>) => any,
path(path: Array<string> | string, object: Object | Array<any>): any,
getOr(defaultValue: any): ((path: Array<string> | string) => (object: Object | Array<any>) => any) & ((path: Array<string> | string, object: Object | Array<any>) => any),
getOr(defaultValue: any, path: Array<string> | string): (object: Object | Array<any>) => any,
getOr(defaultValue: any, path: Array<string> | string, object: Object | Array<any>): any,
propOr(defaultValue: any): ((path: Array<string> | string) => (object: Object | Array<any>) => any) & ((path: Array<string> | string, object: Object | Array<any>) => any),
propOr(defaultValue: any, path: Array<string> | string): (object: Object | Array<any>) => any,
propOr(defaultValue: any, path: Array<string> | string, object: Object | Array<any>): any,
pathOr(defaultValue: any): ((path: Array<string> | string) => (object: Object | Array<any>) => any) & ((path: Array<string> | string, object: Object | Array<any>) => any),
pathOr(defaultValue: any, path: Array<string> | string): (object: Object | Array<any>) => any,
pathOr(defaultValue: any, path: Array<string> | string, object: Object | Array<any>): any,
has(path: Array<string> | string): (object: Object) => boolean,
has(path: Array<string> | string, object: Object): boolean,
hasIn(path: Array<string> | string): (object: Object) => boolean,
hasIn(path: Array<string> | string, object: Object): boolean,
invert(object: Object): Object,
invertObj(object: Object): Object,
invertBy(iteratee: Function): (object: Object) => Object,
invertBy(iteratee: Function, object: Object): Object,
invoke(path: Array<string> | string): (object: Object) => any,
invoke(path: Array<string> | string, object: Object): any,
invokeArgs(path: Array<string> | string): ((object: Object) => (args: Array<any>) => any) & ((object: Object, args: Array<any>) => any),
invokeArgs(path: Array<string> | string, object: Object): (args: Array<any>) => any,
invokeArgs(path: Array<string> | string, object: Object, args: Array<any>): any,
keys(object: Object): Array<string>,
keysIn(object: Object): Array<string>,
mapKeys(iteratee: OIteratee<*>): (object: Object) => Object,
mapKeys(iteratee: OIteratee<*>, object: Object): Object,
mapValues(iteratee: OIteratee<*>): (object: Object) => Object,
mapValues(iteratee: OIteratee<*>, object: Object): Object,
merge(object: Object): (source: Object) => Object,
merge(object: Object, source: Object): Object,
mergeAll(objects: Array<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),
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,
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,
mergeAllWith(customizer: (objValue: any, srcValue: any, key: string, object: Object, source: Object) => any | void): (objects: Array<Object>) => Object,
mergeAllWith(customizer: (objValue: any, srcValue: any, key: string, object: Object, source: Object) => any | void, objects: Array<Object>): Object,
omit(props: Array<string>): (object: Object) => Object,
omit(props: Array<string>, object: Object): Object,
omitAll(props: Array<string>): (object: Object) => Object,
omitAll(props: Array<string>, object: Object): Object,
omitBy<A, T: { [id: any]: A }>(predicate: OPredicate<A>): (object: T) => Object,
omitBy<A, T: { [id: any]: A }>(predicate: OPredicate<A>, object: T): Object,
pick(props: Array<string>): (object: Object) => Object,
pick(props: Array<string>, object: Object): Object,
pickAll(props: Array<string>): (object: Object) => Object,
pickAll(props: Array<string>, object: Object): Object,
pickBy<A, T: { [id: any]: A }>(predicate: OPredicate<A>): (object: T) => Object,
pickBy<A, T: { [id: any]: A }>(predicate: OPredicate<A>, object: T): Object,
result(path: Array<string> | string): (object: Object) => any,
result(path: Array<string> | string, object: Object): any,
set(path: Array<string> | string): ((value: any) => (object: Object) => Object) & ((value: any, object: Object) => Object),
set(path: Array<string> | string, value: any): (object: Object) => Object,
set(path: Array<string> | string, value: any, object: Object): Object,
assoc(path: Array<string> | string): ((value: any) => (object: Object) => Object) & ((value: any, object: Object) => Object),
assoc(path: Array<string> | string, value: any): (object: Object) => Object,
assoc(path: Array<string> | string, value: any, object: Object): Object,
assocPath(path: Array<string> | string): ((value: any) => (object: Object) => Object) & ((value: any, object: Object) => Object),
assocPath(path: Array<string> | string, value: any): (object: Object) => Object,
assocPath(path: Array<string> | string, value: any, object: Object): Object,
setWith<T>(customizer: (nsValue: any, key: string, nsObject: T) => any): ((path: Array<string> | string) => (((value: any) => (object: T) => Object) & ((value: any, object: T) => Object))) & ((path: Array<string> | string, value: any) => (object: T) => Object) & ((path: Array<string> | string, value: any, object: T) => Object),
setWith<T>(customizer: (nsValue: any, key: string, nsObject: T) => any, path: Array<string> | string): ((value: any) => (object: T) => Object) & ((value: any, object: T) => Object),
setWith<T>(customizer: (nsValue: any, key: string, nsObject: T) => any, path: Array<string> | string, value: any): (object: T) => Object,
setWith<T>(customizer: (nsValue: any, key: string, nsObject: T) => any, path: Array<string> | string, value: any, object: T): Object,
toPairs(object: Object | Array<*>): NestedArray<any>,
toPairsIn(object: Object): NestedArray<any>,
transform(iteratee: OIteratee<*>): ((accumulator: any) => (collection: Object | Array<any>) => any) & ((accumulator: any, collection: Object | Array<any>) => any),
transform(iteratee: OIteratee<*>, accumulator: any): (collection: Object | Array<any>) => any,
transform(iteratee: OIteratee<*>, accumulator: any, collection: Object | Array<any>): any,
unset(path: Array<string> | string): (object: Object) => boolean,
unset(path: Array<string> | string, object: Object): boolean,
dissoc(path: Array<string> | string): (object: Object) => boolean,
dissoc(path: Array<string> | string, object: Object): boolean,
dissocPath(path: Array<string> | string): (object: Object) => boolean,
dissocPath(path: Array<string> | string, object: Object): boolean,
update(path: string[] | string): ((updater: Function) => (object: Object) => Object) & ((updater: Function, object: Object) => Object),
update(path: string[] | string, updater: Function): (object: Object) => Object,
update(path: string[] | string, updater: Function, object: Object): Object,
updateWith(customizer: Function): ((path: string[] | string) => (((updater: Function) => (object: Object) => Object) & ((updater: Function, object: Object) => Object))) & ((path: string[] | string, updater: Function) => (object: Object) => Object) & ((path: string[] | string, updater: Function, object: Object) => Object),
updateWith(customizer: Function, path: string[] | string): ((updater: Function) => (object: Object) => Object) & ((updater: Function, object: Object) => Object),
updateWith(customizer: Function, path: string[] | string, updater: Function): (object: Object) => Object,
updateWith(customizer: Function, path: string[] | string, updater: Function, object: Object): Object,
values(object: Object): Array<any>,
valuesIn(object: Object): Array<any>,

tap<T>(interceptor: (value: T) => any): (value: T) => T,
tap<T>(interceptor: (value: T) => any, value: T): T,
thru<T1, T2>(interceptor: (value: T1) => T2): (value: T1) => T2,
thru<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,
endsWith(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,
pad(length: number, string: string): string,
padChars(chars: string): ((length: number) => (string: string) => string) & ((length: number, string: string) => string),
padChars(chars: string, length: number): (string: string) => string,
padChars(chars: string, length: number, string: string): string,
padEnd(length: number): (string: string) => string,
padEnd(length: number, string: string): string,
padCharsEnd(chars: string): ((length: number) => (string: string) => string) & ((length: number, string: string) => string),
padCharsEnd(chars: string, length: number): (string: string) => string,
padCharsEnd(chars: string, length: number, string: string): string,
padStart(length: number): (string: string) => string,
padStart(length: number, string: string): string,
padCharsStart(chars: string): ((length: number) => (string: string) => string) & ((length: number, string: string) => string),
padCharsStart(chars: string, length: number): (string: string) => string,
padCharsStart(chars: string, length: number, string: string): string,
parseInt(radix: number): (string: string) => number,
parseInt(radix: number, string: string): number,
repeat(n: number): (string: string) => string,
repeat(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),
replace(pattern: RegExp | string, replacement: ((string: string) => string) | string): (string: string) => string,
replace(pattern: RegExp | string, replacement: ((string: string) => string) | string, string: string): string,
snakeCase(string: string): string,
split(separator: RegExp | string): (string: string) => Array<string>,
split(separator: RegExp | string, string: string): Array<string>,
startCase(string: string): string,
startsWith(target: string): (string: string) => boolean,
startsWith(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,
trimChars(chars: string, string: string): string,
trimEnd(string: string): string,
trimCharsEnd(chars: string): (string: string) => string,
trimCharsEnd(chars: string, string: string): string,
trimStart(string: string): string,
trimCharsStart(chars: string): (string: string) => string,
trimCharsStart(chars: string, string: string): string,
truncate(options: TruncateOptions): (string: string) => string,
truncate(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: Array<string>): (object: Object) => Object,
bindAll(methodNames: Array<string>, object: Object): Object,
cond(pairs: NestedArray<Function>): Function,
conforms<T: { [key: string]: mixed }>(predicates: T & { [key: string]: (x: any) => boolean }): (source: T) => boolean,
conforms<T: { [key: string]: mixed }>(predicates: T & { [key: string]: (x: any) => boolean }, source: T): boolean,
constant<T>(value: T): () => T,
always<T>(value: T): (: ) => > T,
always<T>(value: T): () => T,
defaultTo<T1: string | boolean | Object, T2>(defaultValue: T2): (value: T1) => T1,
defaultTo<T1: string | boolean | Object, T2>(defaultValue: T2, value: T1): T1,
// NaN is a number instead of its own type, otherwise it would behave like null/void
defaultTo<T1: number, T2>(defaultValue: T2): (value: T1) => T1 | T2,
defaultTo<T1: number, T2>(defaultValue: T2, value: T1): T1 | T2,
defaultTo<T1: void | null, T2>(defaultValue: T2): (value: T1) => T2,
defaultTo<T1: void | null, T2>(defaultValue: T2, value: T1): T2,
flow(...funcs: Array<Function>): Function,
flow(funcs: Array<Function>): Function,
pipe(...funcs: Array<Function>): Function,
pipe(funcs: Array<Function>): Function,
flowRight(...funcs: Array<Function>): Function,
flowRight(funcs: Array<Function>): Function,
compose(...funcs: Array<Function>): Function,
compose(funcs: Array<Function>): Function,
identity<T>(value: T): T,
iteratee(func: any): Function,
matches(source: Object): (object: Object) => boolean,
matches(source: Object, object: Object): boolean,
matchesProperty(path: Array<string> | string): (srcValue: any) => Function,
matchesProperty(path: Array<string> | string, srcValue: any): Function,
propEq(path: Array<string> | string): (srcValue: any) => Function,
propEq(path: Array<string> | string, srcValue: any): Function,
pathEq(path: Array<string> | string): (srcValue: any) => Function,
pathEq(path: Array<string> | string, srcValue: any): Function,
method(path: Array<string> | string): Function,
methodOf(object: Object): Function,
mixin<T: Function | Object>(object: T): ((source: Object) => (options: {chain: boolean}) => T) & ((source: Object, options: {chain: boolean}) => T),
mixin<T: Function | Object>(object: T, source: Object): (options: {chain: boolean}) => T,
mixin<T: Function | Object>(object: T, source: Object, options: {chain: boolean}): T,
noConflict(): Lodash,
noop(...args: Array<mixed>): void,
nthArg(n: number): Function,
over(iteratees: Array<Function>): Function,
juxt(iteratees: Array<Function>): Function,
overEvery(predicates: Array<Function>): Function,
allPass(predicates: Array<Function>): Function,
overSome(predicates: Array<Function>): Function,
anyPass(predicates: Array<Function>): Function,
property(path: Array<string> | string): (object: Object | Array<any>) => any,
property(path: Array<string> | string, object: Object | Array<any>): any,
propertyOf(object: Object): (path: Array<string> | string) => Function,
propertyOf(object: Object, path: Array<string> | string): Function,
range(start: number): (end: number) => Array<number>,
range(start: number, end: number): Array<number>,
rangeStep(step: number): ((start: number) => (end: number) => Array<number>) & ((start: number, end: number) => Array<number>),
rangeStep(step: number, start: number): (end: number) => Array<number>,
rangeStep(step: number, start: number, end: number): Array<number>,
rangeRight(start: number): (end: number) => Array<number>,
rangeRight(start: number, end: number): Array<number>,
rangeStepRight(step: number): ((start: number) => (end: number) => Array<number>) & ((start: number, end: number) => Array<number>),
rangeStepRight(step: number, start: number): (end: number) => Array<number>,
rangeStepRight(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>,
times<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