diff --git a/types/lodash/package.json b/types/lodash/package.json new file mode 100644 index 0000000000..bb80441dc0 --- /dev/null +++ b/types/lodash/package.json @@ -0,0 +1,7 @@ +{ + "private": true, + "types": "index", + "typesVersions": { + ">=3.1.0-0": { "*": ["ts3.1/*"] } + } +} diff --git a/types/lodash/scripts/generate-lowdb.ts b/types/lodash/scripts/generate-lowdb.ts deleted file mode 100644 index 5b8e1269bd..0000000000 --- a/types/lodash/scripts/generate-lowdb.ts +++ /dev/null @@ -1,165 +0,0 @@ -// Script for converting the lodash types into functional programming (FP) format. -// The convertion is done based on this guide: https://github.com/lodash/lodash/wiki/FP-Guide - -// Assumptions: -// - All functions are defined in one of the files in the "common" subfolder -// - All functions are defined inside of the LoDashStatic interface (although functions like _.partial may refer to another interface in the same file) -// - Consistent indentation is used for the start and end of the above interface -// - Consistent spacing is used for interface definitions: interface MyInterface { -// - Consistent line breaks (\n, \r, or \r\n) are used in all files -// - All overloads of a given function are defined in the same file - -import fs from "fs"; -import _ from "lodash"; -import path from "path"; -import { getLineBreak, getLineNumber } from "./utils"; - -interface Definition { - name: string; - overloads: Overload[]; - constants: string[]; - jsdoc: string; -} -interface InterfaceGroup { - functionName: string; - interfaces: Interface[]; -} -interface Interface { - name: string; - typeParams: TypeParam[]; - overloads: Overload[]; - constants: string[]; -} -interface Overload { - typeParams: TypeParam[]; - params: string[]; - returnType: string; - jsdoc: string; - tslintDisable?: string; -} -interface TypeParam { - name: string; - extends?: string; - equals?: string; -} - -// Get the correct line break for the current OS (git for windows will generally convert \n to \r\n during checkout) -let lineBreak = "\n"; -async function main() { - lineBreak = await getLineBreak(); - const commonTypes: string[] = []; - const tsconfigPath = path.join("..", "tsconfig.json"); - - const subfolders = ["common"]; - const promises: Array> = []; - for (const subfolder of subfolders) { - promises.push(new Promise((resolve, reject) => { - fs.readdir(path.join("..", subfolder), (err, files) => { - if (err) { - console.error(`failed to list directory contents for '${subfolder}': `, err); - reject(err); - return; - } - const filePaths = files.map(f => path.join("..", subfolder, f)); - try { - resolve(processDefinitions(filePaths, commonTypes)); - } catch (e) { - console.error(`failed to process files in '${subfolder}': `, e); - reject(e); - } - }); - })); - } - - let functions: string; - try { - functions = _.flatten(await Promise.all(promises)).join(lineBreak); - } catch (err) { - console.error("Failed to parse all functions: ", err); - return; - } - _.pull(commonTypes, "LoDashExplicitWrapper"); - const commonTypeSearch = new RegExp(`\\b(${commonTypes.join("|")})\\b`, "g"); - functions = functions.replace(commonTypeSearch, "_.$1"); - const syncFunctions = functions.replace(/\bLoDashExplicitWrapper\b/g, "LoDashExplicitSyncWrapper"); - const asyncFunctions = functions.replace(/\bLoDashExplicitWrapper\b/g, "LoDashExplicitAsyncWrapper"); - - const lodashFile = [ - "// AUTO-GENERATED: do not modify this file directly.", - "// If you need to make changes, modify types/lodash/scripts/generate-lowdb.ts (if necessary), then open a terminal in types/lodash/scripts, and do:", - "// npm install && npm run generate", - "", - 'import _ = require("lodash");', - 'declare module "./index" {', - " interface LoDashExplicitSyncWrapper {", - syncFunctions, - " }", - "", - " interface LoDashExplicitAsyncWrapper {", - asyncFunctions, - " }", - "}", - "", - ].join(lineBreak); - const lodashFilePath = path.resolve(__dirname, "..", "..", "lowdb", "_lodash.d.ts"); - fs.writeFile(lodashFilePath, lodashFile, (err) => { - if (err) - console.error(`Failed to write ${lodashFilePath}: `, err); - }); -} - -function readFile(filePath: string): Promise { - return new Promise((resolve, reject) => { - fs.readFile(filePath, "utf8", (err, data) => { - if (err) { - reject(err); - return; - } - try { - resolve(data); - } catch (e) { - reject(e); - } - }); - }); -} - -async function processDefinitions(filePaths: string[], commonTypes: string[]): Promise { - const functions: string[] = []; - for (const filePath of filePaths) - functions.push(...await parseFile(filePath, commonTypes)); - return functions; -} - -async function parseFile(filePath: string, commonTypes: string[]): Promise { - const definitionString = await readFile(filePath); - const newCommonTypeRegExp = / (?:type|interface) ([A-Za-z0-9_]+)/g; - let newCommonType = newCommonTypeRegExp.exec(definitionString); - while (newCommonType) { - if (!commonTypes.includes(newCommonType[1])) - commonTypes.push(newCommonType[1]); - newCommonType = newCommonTypeRegExp.exec(definitionString); - } - - const functions: string[] = []; - const lodashWrapperRegExp = /( *)interface +LoDashExplicitWrapper<\w+> *(?:extends .+)? *{/g; - let lodashWrapperMatch = lodashWrapperRegExp.exec(definitionString); - while (lodashWrapperMatch) { - const startIndex = definitionString.indexOf(lineBreak, lodashWrapperMatch.index) + lineBreak.length; - const endIndex = definitionString.indexOf(`${lineBreak}${lodashWrapperMatch[1]}}`, startIndex); - if (endIndex === -1) { - const lineNumber = getLineNumber(definitionString, startIndex); - console.warn(`Failed to find end of interface 'LoDashExplicitWrapper' (starting at ${filePath} line ${lineNumber}).`); - break; - } - let functionString = definitionString.substring(startIndex, endIndex); - // Remove comments since they're generally useless (e.g. @see XXXX) - functionString = functionString.replace(/ *\/\*\*[\s\S]+?\*\/(?:\r\n|\n|\r)/g, ""); - functionString = functionString.replace(/(?:(\r\n){2,}|(\n){2,}|(\r){2,})/g, "$1$2$3"); - functions.push(functionString); - lodashWrapperMatch = lodashWrapperRegExp.exec(definitionString); - } - return functions; -} - -main(); diff --git a/types/lodash/scripts/package.json b/types/lodash/scripts/package.json index a91ecd226e..ae7ea8d9a4 100644 --- a/types/lodash/scripts/package.json +++ b/types/lodash/scripts/package.json @@ -3,9 +3,8 @@ "name": "lodash-scripts", "version": "0.0.1", "scripts": { - "generate": "ts-node generate-fp && ts-node generate-lowdb", + "generate": "ts-node generate-fp", "fp": "ts-node generate-fp", - "lowdb": "ts-node generate-lowdb" }, "devDependencies": { "lodash": "^4.17.4", diff --git a/types/lodash/ts3.1/add.d.ts b/types/lodash/ts3.1/add.d.ts new file mode 100644 index 0000000000..4650a89c4a --- /dev/null +++ b/types/lodash/ts3.1/add.d.ts @@ -0,0 +1,2 @@ +import { add } from "./index"; +export = add; diff --git a/types/lodash/ts3.1/after.d.ts b/types/lodash/ts3.1/after.d.ts new file mode 100644 index 0000000000..277ae1ea53 --- /dev/null +++ b/types/lodash/ts3.1/after.d.ts @@ -0,0 +1,2 @@ +import { after } from "./index"; +export = after; diff --git a/types/lodash/ts3.1/ary.d.ts b/types/lodash/ts3.1/ary.d.ts new file mode 100644 index 0000000000..ac1c72e95d --- /dev/null +++ b/types/lodash/ts3.1/ary.d.ts @@ -0,0 +1,2 @@ +import { ary } from "./index"; +export = ary; diff --git a/types/lodash/ts3.1/assign.d.ts b/types/lodash/ts3.1/assign.d.ts new file mode 100644 index 0000000000..5ffc1e34d7 --- /dev/null +++ b/types/lodash/ts3.1/assign.d.ts @@ -0,0 +1,2 @@ +import { assign } from "./index"; +export = assign; diff --git a/types/lodash/ts3.1/assignIn.d.ts b/types/lodash/ts3.1/assignIn.d.ts new file mode 100644 index 0000000000..3cc54e8178 --- /dev/null +++ b/types/lodash/ts3.1/assignIn.d.ts @@ -0,0 +1,2 @@ +import { assignIn } from "./index"; +export = assignIn; diff --git a/types/lodash/ts3.1/assignInWith.d.ts b/types/lodash/ts3.1/assignInWith.d.ts new file mode 100644 index 0000000000..b4c4dfef2b --- /dev/null +++ b/types/lodash/ts3.1/assignInWith.d.ts @@ -0,0 +1,2 @@ +import { assignInWith } from "./index"; +export = assignInWith; diff --git a/types/lodash/ts3.1/assignWith.d.ts b/types/lodash/ts3.1/assignWith.d.ts new file mode 100644 index 0000000000..97da10ceb0 --- /dev/null +++ b/types/lodash/ts3.1/assignWith.d.ts @@ -0,0 +1,2 @@ +import { assignWith } from "./index"; +export = assignWith; diff --git a/types/lodash/ts3.1/at.d.ts b/types/lodash/ts3.1/at.d.ts new file mode 100644 index 0000000000..49e7147780 --- /dev/null +++ b/types/lodash/ts3.1/at.d.ts @@ -0,0 +1,2 @@ +import { at } from "./index"; +export = at; diff --git a/types/lodash/ts3.1/attempt.d.ts b/types/lodash/ts3.1/attempt.d.ts new file mode 100644 index 0000000000..d4b608900e --- /dev/null +++ b/types/lodash/ts3.1/attempt.d.ts @@ -0,0 +1,2 @@ +import { attempt } from "./index"; +export = attempt; diff --git a/types/lodash/ts3.1/before.d.ts b/types/lodash/ts3.1/before.d.ts new file mode 100644 index 0000000000..03c45c8038 --- /dev/null +++ b/types/lodash/ts3.1/before.d.ts @@ -0,0 +1,2 @@ +import { before } from "./index"; +export = before; diff --git a/types/lodash/ts3.1/bind.d.ts b/types/lodash/ts3.1/bind.d.ts new file mode 100644 index 0000000000..6367da1e1c --- /dev/null +++ b/types/lodash/ts3.1/bind.d.ts @@ -0,0 +1,2 @@ +import { bind } from "./index"; +export = bind; diff --git a/types/lodash/ts3.1/bindAll.d.ts b/types/lodash/ts3.1/bindAll.d.ts new file mode 100644 index 0000000000..25d47e3972 --- /dev/null +++ b/types/lodash/ts3.1/bindAll.d.ts @@ -0,0 +1,2 @@ +import { bindAll } from "./index"; +export = bindAll; diff --git a/types/lodash/ts3.1/bindKey.d.ts b/types/lodash/ts3.1/bindKey.d.ts new file mode 100644 index 0000000000..128b065f3d --- /dev/null +++ b/types/lodash/ts3.1/bindKey.d.ts @@ -0,0 +1,2 @@ +import { bindKey } from "./index"; +export = bindKey; diff --git a/types/lodash/ts3.1/camelCase.d.ts b/types/lodash/ts3.1/camelCase.d.ts new file mode 100644 index 0000000000..5c10659d92 --- /dev/null +++ b/types/lodash/ts3.1/camelCase.d.ts @@ -0,0 +1,2 @@ +import { camelCase } from "./index"; +export = camelCase; diff --git a/types/lodash/ts3.1/capitalize.d.ts b/types/lodash/ts3.1/capitalize.d.ts new file mode 100644 index 0000000000..416f5f598a --- /dev/null +++ b/types/lodash/ts3.1/capitalize.d.ts @@ -0,0 +1,2 @@ +import { capitalize } from "./index"; +export = capitalize; diff --git a/types/lodash/ts3.1/castArray.d.ts b/types/lodash/ts3.1/castArray.d.ts new file mode 100644 index 0000000000..74ea7bd235 --- /dev/null +++ b/types/lodash/ts3.1/castArray.d.ts @@ -0,0 +1,2 @@ +import { castArray } from "./index"; +export = castArray; diff --git a/types/lodash/ts3.1/ceil.d.ts b/types/lodash/ts3.1/ceil.d.ts new file mode 100644 index 0000000000..0c6f1fd1ca --- /dev/null +++ b/types/lodash/ts3.1/ceil.d.ts @@ -0,0 +1,2 @@ +import { ceil } from "./index"; +export = ceil; diff --git a/types/lodash/ts3.1/chain.d.ts b/types/lodash/ts3.1/chain.d.ts new file mode 100644 index 0000000000..d09d2bb08f --- /dev/null +++ b/types/lodash/ts3.1/chain.d.ts @@ -0,0 +1,2 @@ +import { chain } from "./index"; +export = chain; diff --git a/types/lodash/ts3.1/chunk.d.ts b/types/lodash/ts3.1/chunk.d.ts new file mode 100644 index 0000000000..125c98f738 --- /dev/null +++ b/types/lodash/ts3.1/chunk.d.ts @@ -0,0 +1,2 @@ +import { chunk } from "./index"; +export = chunk; diff --git a/types/lodash/ts3.1/clamp.d.ts b/types/lodash/ts3.1/clamp.d.ts new file mode 100644 index 0000000000..df1706691a --- /dev/null +++ b/types/lodash/ts3.1/clamp.d.ts @@ -0,0 +1,2 @@ +import { clamp } from "./index"; +export = clamp; diff --git a/types/lodash/ts3.1/clone.d.ts b/types/lodash/ts3.1/clone.d.ts new file mode 100644 index 0000000000..c5884d700e --- /dev/null +++ b/types/lodash/ts3.1/clone.d.ts @@ -0,0 +1,2 @@ +import { clone } from "./index"; +export = clone; diff --git a/types/lodash/ts3.1/cloneDeep.d.ts b/types/lodash/ts3.1/cloneDeep.d.ts new file mode 100644 index 0000000000..b7bd89327e --- /dev/null +++ b/types/lodash/ts3.1/cloneDeep.d.ts @@ -0,0 +1,2 @@ +import { cloneDeep } from "./index"; +export = cloneDeep; diff --git a/types/lodash/ts3.1/cloneDeepWith.d.ts b/types/lodash/ts3.1/cloneDeepWith.d.ts new file mode 100644 index 0000000000..3eb368ba77 --- /dev/null +++ b/types/lodash/ts3.1/cloneDeepWith.d.ts @@ -0,0 +1,2 @@ +import { cloneDeepWith } from "./index"; +export = cloneDeepWith; diff --git a/types/lodash/ts3.1/cloneWith.d.ts b/types/lodash/ts3.1/cloneWith.d.ts new file mode 100644 index 0000000000..1e6bf7a808 --- /dev/null +++ b/types/lodash/ts3.1/cloneWith.d.ts @@ -0,0 +1,2 @@ +import { cloneWith } from "./index"; +export = cloneWith; diff --git a/types/lodash/ts3.1/common/array.d.ts b/types/lodash/ts3.1/common/array.d.ts new file mode 100644 index 0000000000..13e4e3d920 --- /dev/null +++ b/types/lodash/ts3.1/common/array.d.ts @@ -0,0 +1,2120 @@ +import _ = require("../index"); +declare module "../index" { + interface LoDashStatic { + /** + * Creates an array of elements split into groups the length of size. If collection can’t be split evenly, the + * final chunk will be the remaining elements. + * + * @param array The array to process. + * @param size The length of each chunk. + * @return Returns the new array containing chunks. + */ + chunk(array: List | null | undefined, size?: number): T[][]; + } + interface Collection { + /** + * @see _.chunk + */ + chunk(size?: number): Collection; + } + interface CollectionChain { + /** + * @see _.chunk + */ + chunk(size?: number): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array with all falsey values removed. The values false, null, 0, "", undefined, and NaN are + * falsey. + * + * @param array The array to compact. + * @return Returns the new array of filtered values. + */ + compact(array: List | null | undefined): T[]; + } + + type Truthy = T extends null | undefined | false | "" | 0 ? never : T; + interface Collection { + /** + * @see _.compact + */ + compact(): Collection>; + } + interface CollectionChain { + /** + * @see _.compact + */ + compact(): CollectionChain>; + } + interface LoDashStatic { + /** + * Creates a new array concatenating `array` with any additional arrays + * and/or values. + * + * @category Array + * @param array The array to concatenate. + * @param [values] The values to concatenate. + * @returns Returns the new concatenated array. + * @example + * + * var array = [1]; + * var other = _.concat(array, 2, [3], [[4]]); + * + * console.log(other); + * // => [1, 2, 3, [4]] + * + * console.log(array); + * // => [1] + */ + concat(array: Many, ...values: Array>): T[]; + } + interface Primitive { + /** + * @see _.concat + */ + concat(...values: Array>): Collection; + } + interface Collection { + /** + * @see _.concat + */ + concat(...values: Array>): Collection; + } + interface Object { + /** + * @see _.concat + */ + concat(...values: Array>): Collection; + } + interface PrimitiveChain { + /** + * @see _.concat + */ + concat(...values: Array>): CollectionChain; + } + interface CollectionChain { + /** + * @see _.concat + */ + concat(...values: Array>): CollectionChain; + } + interface ObjectChain { + /** + * @see _.concat + */ + concat(...values: Array>): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array of unique array values not included in the other provided arrays using SameValueZero for + * equality comparisons. + * + * @param array The array to inspect. + * @param values The arrays of values to exclude. + * @return Returns the new array of filtered values. + */ + difference(array: List | null | undefined, ...values: Array>): T[]; + } + interface Collection { + /** + * @see _.difference + */ + difference(...values: Array>): Collection; + } + interface CollectionChain { + /** + * @see _.difference + */ + difference(...values: Array>): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like _.difference except that it accepts iteratee which is invoked for each element of array + * and values to generate the criterion by which uniqueness is computed. The iteratee is invoked with one + * argument: (value). + * + * @param array The array to inspect. + * @param values The values to exclude. + * @param iteratee The iteratee invoked per element. + * @returns Returns the new array of filtered values. + */ + differenceBy(array: List | null | undefined, values: List, iteratee: ValueIteratee): T1[]; + /** + * @see _.differenceBy + */ + differenceBy(array: List | null | undefined, values1: List, values2: List, iteratee: ValueIteratee): T1[]; + /** + * @see _.differenceBy + */ + differenceBy(array: List | null | undefined, values1: List, values2: List, values3: List, iteratee: ValueIteratee): T1[]; + /** + * @see _.differenceBy + */ + differenceBy(array: List | null | undefined, values1: List, values2: List, values3: List, values4: List, iteratee: ValueIteratee): T1[]; + /** + * @see _.differenceBy + */ + differenceBy(array: List | null | undefined, values1: List, values2: List, values3: List, values4: List, values5: List, iteratee: ValueIteratee): T1[]; + /** + * @see _.differenceBy + */ + differenceBy(array: List | null | undefined, values1: List, values2: List, values3: List, values4: List, values5: List, ...values: Array | ValueIteratee>): T1[]; + /** + * @see _.differenceBy + */ + differenceBy(array: List | null | undefined, ...values: Array>): T[]; + } + interface Collection { + /** + * @see _.differenceBy + */ + differenceBy(values1: List, iteratee?: ValueIteratee): Collection; + /** + * @see _.differenceBy + */ + differenceBy(...values: Array | ValueIteratee>): Collection; + } + interface CollectionChain { + /** + * @see _.differenceBy + */ + differenceBy(values1: List, iteratee?: ValueIteratee): CollectionChain; + /** + * @see _.differenceBy + */ + differenceBy(...values: Array | ValueIteratee>): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array of unique `array` values not included in the other + * provided arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) + * for equality comparisons. + * + * @category Array + * @param [values] The arrays to inspect. + * @param [comparator] The comparator invoked per element. + * @returns Returns the new array of filtered values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + + * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual); + * // => [{ 'x': 2, 'y': 1 }] + */ + differenceWith(array: List | null | undefined, values: List, comparator: Comparator2): T1[]; + /** + * @see _.differenceWith + */ + differenceWith(array: List | null | undefined, values1: List, values2: List, comparator: Comparator2): T1[]; + /** + * @see _.differenceWith + */ + differenceWith(array: List | null | undefined, values1: List, values2: List, ...values: Array | Comparator2>): T1[]; + /** + * @see _.differenceWith + */ + differenceWith(array: List | null | undefined, ...values: Array>): T[]; + } + interface Collection { + /** + * @see _.differenceWith + */ + differenceWith(values: List, comparator: Comparator2): Collection; + /** + * @see _.differenceWith + */ + differenceWith(...values: Array | Comparator2>): Collection; + } + interface CollectionChain { + /** + * @see _.differenceWith + */ + differenceWith< T2>(values: List, comparator: Comparator2): CollectionChain; + /** + * @see _.differenceWith + */ + differenceWith< T2, T3, T4>(...values: Array | Comparator2>): CollectionChain; + } + interface LoDashStatic { + /** + * Creates a slice of array with n elements dropped from the beginning. + * + * @param array The array to query. + * @param n The number of elements to drop. + * @return Returns the slice of array. + */ + drop(array: List | null | undefined, n?: number): T[]; + } + interface Collection { + /** + * @see _.drop + */ + drop(n?: number): Collection; + } + interface CollectionChain { + /** + * @see _.drop + */ + drop(n?: number): CollectionChain; + } + interface LoDashStatic { + /** + * Creates a slice of array with n elements dropped from the end. + * + * @param array The array to query. + * @param n The number of elements to drop. + * @return Returns the slice of array. + */ + dropRight(array: List | null | undefined, n?: number): T[]; + } + interface Collection { + /** + * @see _.dropRight + */ + dropRight(n?: number): Collection; + } + interface CollectionChain { + /** + * @see _.dropRight + */ + dropRight(n?: number): CollectionChain; + } + interface LoDashStatic { + /** + * Creates a slice of array excluding elements dropped from the end. Elements are dropped until predicate + * returns falsey. The predicate is invoked with three arguments: (value, index, array). + * + * @param array The array to query. + * @param predicate The function invoked per iteration. + * @return Returns the slice of array. + */ + dropRightWhile(array: List | null | undefined, predicate?: ListIteratee): T[]; + } + interface Collection { + /** + * @see _.dropRightWhile + */ + dropRightWhile(predicate?: ListIteratee): Collection; + } + interface CollectionChain { + /** + * @see _.dropRightWhile + */ + dropRightWhile(predicate?: ListIteratee): CollectionChain; + } + interface LoDashStatic { + /** + * Creates a slice of array excluding elements dropped from the beginning. Elements are dropped until predicate + * returns falsey. The predicate is invoked with three arguments: (value, index, array). + * + * @param array The array to query. + * @param predicate The function invoked per iteration. + * @return Returns the slice of array. + */ + dropWhile(array: List | null | undefined, predicate?: ListIteratee): T[]; + } + interface Collection { + /** + * @see _.dropWhile + */ + dropWhile(predicate?: ListIteratee): Collection; + } + interface CollectionChain { + /** + * @see _.dropWhile + */ + dropWhile(predicate?: ListIteratee): CollectionChain; + } + interface LoDashStatic { + /** + * Fills elements of array with value from start up to, but not including, end. + * + * Note: This method mutates array. + * + * @param array The array to fill. + * @param value The value to fill array with. + * @param start The start position. + * @param end The end position. + * @return Returns array. + */ + fill(array: any[] | null | undefined, value: T): T[]; + /** + * @see _.fill + */ + fill(array: List | null | undefined, value: T): List; + /** + * @see _.fill + */ + fill(array: U[] | null | undefined, value: T, start?: number, end?: number): Array; + /** + * @see _.fill + */ + fill(array: List | null | undefined, value: T, start?: number, end?: number): List; + } + interface Collection { + /** + * @see _.fill + */ + fill(value: U, start?: number, end?: number): Collection; + } + interface CollectionChain { + /** + * @see _.fill + */ + fill(value: U, start?: number, end?: number): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like _.find except that it returns the index of the first element predicate returns truthy + * for instead of the element itself. + * + * @param array The array to search. + * @param predicate The function invoked per iteration. + * @param fromIndex The index to search from. + * @return Returns the index of the found element, else -1. + */ + findIndex(array: List | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number): number; + } + interface Collection { + /** + * @see _.findIndex + */ + findIndex(predicate?: ListIterateeCustom, fromIndex?: number): number; + } + interface CollectionChain { + /** + * @see _.findIndex + */ + findIndex(predicate?: ListIterateeCustom, fromIndex?: number): PrimitiveChain; + } + interface LoDashStatic { + /** + * This method is like _.findIndex except that it iterates over elements of collection from right to left. + * + * @param array The array to search. + * @param predicate The function invoked per iteration. + * @param fromIndex The index to search from. + * @return Returns the index of the found element, else -1. + */ + findLastIndex(array: List | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number): number; + } + interface Collection { + /** + * @see _.findLastIndex + */ + findLastIndex(predicate?: ListIterateeCustom, fromIndex?: number): number; + } + interface CollectionChain { + /** + * @see _.findLastIndex + */ + findLastIndex(predicate?: ListIterateeCustom, fromIndex?: number): PrimitiveChain; + } + interface LoDashStatic { + /** + * @see _.head + */ + first: LoDashStatic["head"]; + } + interface String { + /** + * @see _.first + */ + first(): string | undefined; + } + interface StringChain { + /** + * @see _.first + */ + first(): StringNullableChain; + } + interface StringNullableChain { + /** + * @see _.first + */ + first(): StringNullableChain; + } + interface Collection { + /** + * @see _.first + */ + first(): T | undefined; + } + interface CollectionChain { + /** + * @see _.first + */ + first(): ExpChain; + } + interface RecursiveArray extends Array> {} + interface ListOfRecursiveArraysOrValues extends List> {} + interface LoDashStatic { + /** + * Flattens `array` a single level deep. + * + * @param array The array to flatten. + * @return Returns the new flattened array. + */ + flatten(array: List> | null | undefined): T[]; + } + interface String { + /** + * @see _.flatten + */ + flatten(): Collection; + } + interface StringChain { + /** + * @see _.flatten + */ + flatten(): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.flatten + */ + flatten(): CollectionChain; + } + interface Collection { + /** + * @see _.flatten + */ + flatten(): T extends Many ? Collection : Collection; + } + interface CollectionChain { + /** + * @see _.flatten + */ + flatten(): T extends Many ? CollectionChain : CollectionChain; + } + interface LoDashStatic { + /** + * Recursively flattens a nested array. + * + * @param array The array to recursively flatten. + * @return Returns the new flattened array. + */ + flattenDeep(array: ListOfRecursiveArraysOrValues | null | undefined): T[]; + } + interface Collection { + /** + * @see _.flattenDeep + */ + flattenDeep(): Collection; + } + interface CollectionChain { + /** + * @see _.flattenDeep + */ + flattenDeep(): CollectionChain; + } + interface LoDashStatic { + /** + * Recursively flatten array up to depth times. + * + * @param array The array to recursively flatten. + * @param number The maximum recursion depth. + * @return Returns the new flattened array. + */ + flattenDepth(array: ListOfRecursiveArraysOrValues | null | undefined, depth?: number): T[]; + } + interface Collection { + /** + * @see _.flattenDepth + */ + flattenDepth(depth?: number): Collection; + } + interface CollectionChain { + /** + * @see _.flattenDepth + */ + flattenDepth(depth?: number): CollectionChain; + } + interface LoDashStatic { + /** + * The inverse of `_.toPairs`; this method returns an object composed + * from key-value `pairs`. + * + * @category Array + * @param pairs The key-value pairs. + * @returns Returns the new object. + * @example + * + * _.fromPairs([['fred', 30], ['barney', 40]]); + * // => { 'fred': 30, 'barney': 40 } + */ + fromPairs(pairs: List<[PropertyName, T]> | null | undefined): Dictionary; + /** + * @see _.fromPairs + */ + fromPairs(pairs: List | null | undefined): Dictionary; + } + interface Collection { + /** + * @see _.fromPairs + */ + fromPairs(): Object>; + } + interface CollectionChain { + /** + * @see _.fromPairs + */ + fromPairs(): ObjectChain>; + } + interface LoDashStatic { + /** + * Gets the first element of array. + * + * @alias _.first + * + * @param array The array to query. + * @return Returns the first element of array. + */ + head(array: List | null | undefined): T | undefined; + } + interface String { + /** + * @see _.head + */ + head(): string | undefined; + } + interface StringChain { + /** + * @see _.head + */ + head(): StringNullableChain; + } + interface StringNullableChain { + /** + * @see _.head + */ + head(): StringNullableChain; + } + interface Collection { + /** + * @see _.head + */ + head(): T | undefined; + } + interface CollectionChain { + /** + * @see _.head + */ + head(): ExpChain; + } + interface LoDashStatic { + /** + * Gets the index at which the first occurrence of `value` is found in `array` + * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) + * for equality comparisons. If `fromIndex` is negative, it's used as the offset + * from the end of `array`. + * + * @category Array + * @param array The array to search. + * @param value The value to search for. + * @param [fromIndex=0] The index to search from. + * @returns Returns the index of the matched value, else `-1`. + * @example + * + * _.indexOf([1, 2, 1, 2], 2); + * // => 1 + * + * // using `fromIndex` + * _.indexOf([1, 2, 1, 2], 2, 2); + * // => 3 + */ + indexOf(array: List | null | undefined, value: T, fromIndex?: number): number; + } + interface Collection { + /** + * @see _.indexOf + */ + indexOf(value: T, fromIndex?: number): number; + } + interface CollectionChain { + /** + * @see _.indexOf + */ + indexOf(value: T, fromIndex?: number): PrimitiveChain; + } + interface LoDashStatic { + /** + * Gets all but the last element of array. + * + * @param array The array to query. + * @return Returns the slice of array. + */ + initial(array: List | null | undefined): T[]; + } + interface Collection { + /** + * @see _.initial + */ + initial(): Collection; + } + interface CollectionChain { + /** + * @see _.initial + */ + initial(): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array of unique values that are included in all of the provided arrays using SameValueZero for + * equality comparisons. + * + * @param arrays The arrays to inspect. + * @return Returns the new array of shared values. + */ + intersection(...arrays: Array>): T[]; + } + interface Collection { + /** + * @see _.intersection + */ + intersection(...arrays: Array>): Collection; + } + interface CollectionChain { + /** + * @see _.intersection + */ + intersection(...arrays: Array>): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.intersection` except that it accepts `iteratee` + * which is invoked for each element of each `arrays` to generate the criterion + * by which uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @category Array + * @param [arrays] The arrays to inspect. + * @param [iteratee=_.identity] The iteratee invoked per element. + * @returns Returns the new array of shared values. + * @example + * + * _.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor); + * // => [2.1] + * + * // using the `_.property` iteratee shorthand + * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }] + */ + intersectionBy(array: List | null, values: List, iteratee: ValueIteratee): T1[]; + /** + * @see _.intersectionBy + */ + intersectionBy(array: List | null, values1: List, values2: List, iteratee: ValueIteratee): T1[]; + /** + * @see _.intersectionBy + */ + intersectionBy(array: List | null | undefined, values1: List, values2: List, ...values: Array | ValueIteratee>): T1[]; + /** + * @see _.intersectionBy + */ + intersectionBy(array?: List | null, ...values: Array>): T[]; + } + interface Collection { + /** + * @see _.intersectionBy + */ + intersectionBy(values: List, iteratee: ValueIteratee): Collection; + /** + * @see _.intersectionBy + */ + intersectionBy(...values: Array | ValueIteratee>): Collection; + } + interface CollectionChain { + /** + * @see _.intersectionBy + */ + intersectionBy(values: List, iteratee: ValueIteratee): CollectionChain; + /** + * @see _.intersectionBy + */ + intersectionBy(...values: Array | ValueIteratee>): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array of unique `array` values not included in the other + * provided arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) + * for equality comparisons. + * + * @category Array + * @param [values] The arrays to inspect. + * @param [comparator] The comparator invoked per element. + * @returns Returns the new array of filtered values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + + * _.intersectionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }] + */ + intersectionWith(array: List | null | undefined, values: List, comparator: Comparator2): T1[]; + /** + * @see _.intersectionWith + */ + intersectionWith(array: List | null | undefined, values1: List, values2: List, comparator: Comparator2): T1[]; + /** + * @see _.intersectionWith + */ + intersectionWith(array: List | null | undefined, values1: List, values2: List, ...values: Array | Comparator2>): T1[]; + /** + * @see _.intersectionWith + */ + intersectionWith(array?: List | null, ...values: Array>): T[]; + } + interface Collection { + /** + * @see _.intersectionWith + */ + intersectionWith(values: List, comparator: Comparator2): Collection; + /** + * @see _.intersectionWith + */ + intersectionWith(...values: Array | Comparator2>): Collection; + } + interface CollectionChain { + /** + * @see _.intersectionWith + */ + intersectionWith(values: List, comparator: Comparator2): CollectionChain; + /** + * @see _.intersectionWith + */ + intersectionWith(...values: Array | Comparator2>): CollectionChain; + } + interface LoDashStatic { + /** + * Converts all elements in `array` into a string separated by `separator`. + * + * @param array The array to convert. + * @param separator The element separator. + * @returns Returns the joined string. + */ + join(array: List | null | undefined, separator?: string): string; + } + interface String { + /** + * @see _.join + */ + join(separator?: string): string; + } + interface StringChain { + /** + * @see _.join + */ + join(separator?: string): StringChain; + } + interface StringNullableChain { + /** + * @see _.join + */ + join(separator?: string): StringChain; + } + interface Collection { + /** + * @see _.join + */ + join(separator?: string): string; + } + interface CollectionChain { + /** + * @see _.join + */ + join(separator?: string): StringChain; + } + interface LoDashStatic { + /** + * Gets the last element of array. + * + * @param array The array to query. + * @return Returns the last element of array. + */ + last(array: List | null | undefined): T | undefined; + } + interface Collection { + /** + * @see _.last + */ + last(): T | undefined; + } + interface CollectionChain { + /** + * @see _.last + */ + last(): ExpChain; + } + interface String { + /** + * @see _.last + */ + last(): string | undefined; + } + interface StringChain { + /** + * @see _.last + */ + last(): StringNullableChain; + } + interface StringNullableChain { + /** + * @see _.last + */ + last(): StringNullableChain; + } + interface LoDashStatic { + /** + * This method is like _.indexOf except that it iterates over elements of array from right to left. + * + * @param array The array to search. + * @param value The value to search for. + * @param fromIndex The index to search from or true to perform a binary search on a sorted array. + * @return Returns the index of the matched value, else -1. + */ + lastIndexOf(array: List | null | undefined, value: T, fromIndex?: true|number): number; + } + interface Collection { + /** + * @see _.lastIndexOf + */ + lastIndexOf(value: T, fromIndex?: true|number): number; + } + interface CollectionChain { + /** + * @see _.lastIndexOf + */ + lastIndexOf(value: T, fromIndex?: true|number): PrimitiveChain; + } + interface LoDashStatic { + /** + * Gets the element at index `n` of `array`. If `n` is negative, the nth element from the end is returned. + * + * @param array array The array to query. + * @param value The index of the element to return. + * @return Returns the nth element of `array`. + */ + nth(array: List | null | undefined, n?: number): T | undefined; + } + interface Collection { + /** + * @see _.nth + */ + nth(n?: number): T | undefined; + } + interface CollectionChain { + /** + * @see _.nth + */ + nth(n?: number): ExpChain; + } + interface LoDashStatic { + /** + * Removes all provided values from array using SameValueZero for equality comparisons. + * + * Note: Unlike _.without, this method mutates array. + * + * @param array The array to modify. + * @param values The values to remove. + * @return Returns array. + */ + pull(array: T[], ...values: T[]): T[]; + /** + * @see _.pull + */ + pull(array: List, ...values: T[]): List; + } + interface Collection { + /** + * @see _.pull + */ + pull(...values: T[]): Collection; + } + interface CollectionChain { + /** + * @see _.pull + */ + pull(...values: T[]): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.pull` except that it accepts an array of values to remove. + * + * **Note:** Unlike `_.difference`, this method mutates `array`. + * + * @category Array + * @param array The array to modify. + * @param values The values to remove. + * @returns Returns `array`. + * @example + * + * var array = [1, 2, 3, 1, 2, 3]; + * + * _.pull(array, [2, 3]); + * console.log(array); + * // => [1, 1] + */ + pullAll(array: T[], values?: List): T[]; + /** + * @see _.pullAll + */ + pullAll(array: List, values?: List): List; + } + interface Collection { + /** + * @see _.pullAll + */ + pullAll(values?: List): Collection; + } + interface CollectionChain { + /** + * @see _.pullAll + */ + pullAll(values?: List): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.pullAll` except that it accepts `iteratee` which is + * invoked for each element of `array` and `values` to to generate the criterion + * by which uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * **Note:** Unlike `_.differenceBy`, this method mutates `array`. + * + * @category Array + * @param array The array to modify. + * @param values The values to remove. + * @param [iteratee=_.identity] The iteratee invoked per element. + * @returns Returns `array`. + * @example + * + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ + pullAllBy(array: T[], values?: List, iteratee?: ValueIteratee): T[]; + /** + * @see _.pullAllBy + */ + pullAllBy(array: List, values?: List, iteratee?: ValueIteratee): List; + /** + * @see _.pullAllBy + */ + pullAllBy(array: T1[], values: List, iteratee: ValueIteratee): T1[]; + /** + * @see _.pullAllBy + */ + pullAllBy(array: List, values: List, iteratee: ValueIteratee): List; + } + interface Collection { + /** + * @see _.pullAllBy + */ + pullAllBy(values?: List, iteratee?: ValueIteratee): Collection; + } + interface CollectionChain { + /** + * @see _.pullAllBy + */ + pullAllBy(values?: List, iteratee?: ValueIteratee): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.pullAll` except that it accepts `comparator` which is + * invoked to compare elements of array to values. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @category Array + * @param array The array to modify. + * @param values The values to remove. + * @param [iteratee=_.identity] The iteratee invoked per element. + * @returns Returns `array`. + * @example + * + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ + pullAllWith(array: T[], values?: List, comparator?: Comparator): T[]; + /** + * @see _.pullAllWith + */ + pullAllWith(array: List, values?: List, comparator?: Comparator): List; + /** + * @see _.pullAllWith + */ + pullAllWith(array: T1[], values: List, comparator: Comparator2): T1[]; + /** + * @see _.pullAllWith + */ + pullAllWith(array: List, values: List, comparator: Comparator2): List; + } + interface Collection { + /** + * @see _.pullAllWith + */ + pullAllWith(values?: List, comparator?: Comparator2): Collection; + } + interface CollectionChain { + /** + * @see _.pullAllWith + */ + pullAllWith(values?: List, comparator?: Comparator2): CollectionChain; + } + interface LoDashStatic { + /** + * Removes elements from array corresponding to the given indexes and returns an array of the removed elements. + * Indexes may be specified as an array of indexes or as individual arguments. + * + * Note: Unlike _.at, this method mutates array. + * + * @param array The array to modify. + * @param indexes The indexes of elements to remove, specified as individual indexes or arrays of indexes. + * @return Returns the new array of removed elements. + */ + pullAt(array: T[], ...indexes: Array>): T[]; + /** + * @see _.pullAt + */ + pullAt(array: List, ...indexes: Array>): List; + } + interface Collection { + /** + * @see _.pullAt + */ + pullAt(...indexes: Array>): Collection; + } + interface CollectionChain { + /** + * @see _.pullAt + */ + pullAt(...indexes: Array>): CollectionChain; + } + interface LoDashStatic { + /** + * Removes all elements from array that predicate returns truthy for and returns an array of the removed + * elements. The predicate is invoked with three arguments: (value, index, array). + * + * Note: Unlike _.filter, this method mutates array. + * + * @param array The array to modify. + * @param predicate The function invoked per iteration. + * @return Returns the new array of removed elements. + */ + remove(array: List, predicate?: ListIteratee): T[]; + } + interface Collection { + /** + * @see _.remove + */ + remove(predicate?: ListIteratee): Collection; + } + interface CollectionChain { + /** + * @see _.remove + */ + remove(predicate?: ListIteratee): CollectionChain; + } + interface LoDashStatic { + /** + * Reverses `array` so that the first element becomes the last, the second + * element becomes the second to last, and so on. + * + * **Note:** This method mutates `array` and is based on + * [`Array#reverse`](https://mdn.io/Array/reverse). + * + * @category Array + * @returns Returns `array`. + * @example + * + * var array = [1, 2, 3]; + * + * _.reverse(array); + * // => [3, 2, 1] + * + * console.log(array); + * // => [3, 2, 1] + */ + reverse>(array: TList): TList; + } + interface LoDashStatic { + /** + * Creates a slice of array from start up to, but not including, end. + * + * @param array The array to slice. + * @param start The start position. + * @param end The end position. + * @return Returns the slice of array. + */ + slice(array: List | null | undefined, start?: number, end?: number): T[]; + } + interface Collection { + /** + * @see _.slice + */ + slice(start?: number, end?: number): Collection; + } + interface CollectionChain { + /** + * @see _.slice + */ + slice(start?: number, end?: number): CollectionChain; + } + interface LoDashStatic { + /** + * Uses a binary search to determine the lowest index at which `value` should + * be inserted into `array` in order to maintain its sort order. + * + * @category Array + * @param array The sorted array to inspect. + * @param value The value to evaluate. + * @returns Returns the index at which `value` should be inserted into `array`. + * @example + * + * _.sortedIndex([30, 50], 40); + * // => 1 + * + * _.sortedIndex([4, 5], 4); + * // => 0 + */ + sortedIndex(array: List | null | undefined, value: T): number; + } + interface Collection { + /** + * @see _.sortedIndex + */ + sortedIndex(value: T): number; + } + interface CollectionChain { + /** + * @see _.sortedIndex + */ + sortedIndex(value: T): PrimitiveChain; + } + interface LoDashStatic { + /** + * Uses a binary search to determine the lowest index at which `value` should + * be inserted into `array` in order to maintain its sort order. + * + * @category Array + * @param array The sorted array to inspect. + * @param value The value to evaluate. + * @returns Returns the index at which `value` should be inserted into `array`. + * @example + * + * _.sortedIndex([30, 50], 40); + * // => 1 + * + * _.sortedIndex([4, 5], 4); + * // => 0 + */ + sortedIndex(array: List | null | undefined, value: T): number; + } + interface Collection { + /** + * @see _.sortedIndex + */ + sortedIndex(value: T): number; + } + interface CollectionChain { + /** + * @see _.sortedIndex + */ + sortedIndex(value: T): PrimitiveChain; + } + interface LoDashStatic { + /** + * This method is like `_.sortedIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @category Array + * @param array The sorted array to inspect. + * @param value The value to evaluate. + * @param [iteratee=_.identity] The iteratee invoked per element. + * @returns Returns the index at which `value` should be inserted into `array`. + * @example + * + * var dict = { 'thirty': 30, 'forty': 40, 'fifty': 50 }; + * + * _.sortedIndexBy(['thirty', 'fifty'], 'forty', _.propertyOf(dict)); + * // => 1 + * + * // using the `_.property` iteratee shorthand + * _.sortedIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x'); + * // => 0 + */ + sortedIndexBy(array: List | null | undefined, value: T, iteratee?: ValueIteratee): number; + } + interface Collection { + /** + * @see _.sortedIndexBy + */ + sortedIndexBy(value: T, iteratee?: ValueIteratee): number; + } + interface CollectionChain { + /** + * @see _.sortedIndexBy + */ + sortedIndexBy(value: T, iteratee?: ValueIteratee): PrimitiveChain; + } + interface LoDashStatic { + /** + * This method is like `_.indexOf` except that it performs a binary + * search on a sorted `array`. + * + * @category Array + * @param array The array to search. + * @param value The value to search for. + * @returns Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedIndexOf([1, 1, 2, 2], 2); + * // => 2 + */ + sortedIndexOf(array: List | null | undefined, value: T): number; + } + interface Collection { + /** + * @see _.sortedIndexOf + */ + sortedIndexOf(value: T): number; + } + interface CollectionChain { + /** + * @see _.sortedIndexOf + */ + sortedIndexOf(value: T): PrimitiveChain; + } + interface LoDashStatic { + /** + * This method is like `_.sortedIndex` except that it returns the highest + * index at which `value` should be inserted into `array` in order to + * maintain its sort order. + * + * @category Array + * @param array The sorted array to inspect. + * @param value The value to evaluate. + * @returns Returns the index at which `value` should be inserted into `array`. + * @example + * + * _.sortedLastIndex([4, 5], 4); + * // => 1 + */ + sortedLastIndex(array: List | null | undefined, value: T): number; + } + interface Collection { + /** + * @see _.sortedLastIndex + */ + sortedLastIndex(value: T): number; + } + interface CollectionChain { + /** + * @see _.sortedLastIndex + */ + sortedLastIndex(value: T): PrimitiveChain; + } + interface LoDashStatic { + /** + * This method is like `_.sortedLastIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @category Array + * @param array The sorted array to inspect. + * @param value The value to evaluate. + * @param [iteratee=_.identity] The iteratee invoked per element. + * @returns Returns the index at which `value` should be inserted into `array`. + * @example + * + * // using the `_.property` iteratee shorthand + * _.sortedLastIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x'); + * // => 1 + */ + sortedLastIndexBy(array: List | null | undefined, value: T, iteratee: ValueIteratee): number; + } + interface Collection { + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy(value: T, iteratee: ValueIteratee): number; + } + interface CollectionChain { + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy(value: T, iteratee: ValueIteratee): PrimitiveChain; + } + interface LoDashStatic { + /** + * This method is like `_.lastIndexOf` except that it performs a binary + * search on a sorted `array`. + * + * @category Array + * @param array The array to search. + * @param value The value to search for. + * @returns Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedLastIndexOf([1, 1, 2, 2], 2); + * // => 3 + */ + sortedLastIndexOf(array: List | null | undefined, value: T): number; + } + interface Collection { + /** + * @see _.sortedLastIndexOf + */ + sortedLastIndexOf(value: T): number; + } + interface CollectionChain { + /** + * @see _.sortedLastIndexOf + */ + sortedLastIndexOf(value: T): PrimitiveChain; + } + interface LoDashStatic { + /** + * This method is like `_.uniq` except that it's designed and optimized + * for sorted arrays. + * + * @category Array + * @param array The array to inspect. + * @returns Returns the new duplicate free array. + * @example + * + * _.sortedUniq([1, 1, 2]); + * // => [1, 2] + */ + sortedUniq(array: List | null | undefined): T[]; + } + interface Collection { + /** + * @see _.sortedUniq + */ + sortedUniq(): Collection; + } + interface CollectionChain { + /** + * @see _.sortedUniq + */ + sortedUniq(): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.uniqBy` except that it's designed and optimized + * for sorted arrays. + * + * @category Array + * @param array The array to inspect. + * @param [iteratee] The iteratee invoked per element. + * @returns Returns the new duplicate free array. + * @example + * + * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor); + * // => [1.1, 2.2] + */ + sortedUniqBy(array: List | null | undefined, iteratee: ValueIteratee): T[]; + } + interface Collection { + /** + * @see _.sortedUniqBy + */ + sortedUniqBy(iteratee: ValueIteratee): Collection; + } + interface CollectionChain { + /** + * @see _.sortedUniqBy + */ + sortedUniqBy(iteratee: ValueIteratee): CollectionChain; + } + interface LoDashStatic { + /** + * Gets all but the first element of array. + * + * @param array The array to query. + * @return Returns the slice of array. + */ + tail(array: List | null | undefined): T[]; + } + interface Collection { + /** + * @see _.tail + */ + tail(): Collection; + } + interface CollectionChain { + /** + * @see _.tail + */ + tail(): CollectionChain; + } + interface LoDashStatic { + /** + * Creates a slice of array with n elements taken from the beginning. + * + * @param array The array to query. + * @param n The number of elements to take. + * @return Returns the slice of array. + */ + take(array: List | null | undefined, n?: number): T[]; + } + interface Collection { + /** + * @see _.take + */ + take(n?: number): Collection; + } + interface CollectionChain { + /** + * @see _.take + */ + take(n?: number): CollectionChain; + } + interface LoDashStatic { + /** + * Creates a slice of array with n elements taken from the end. + * + * @param array The array to query. + * @param n The number of elements to take. + * @return Returns the slice of array. + */ + takeRight(array: List | null | undefined, n?: number): T[]; + } + interface Collection { + /** + * @see _.takeRight + */ + takeRight(n?: number): Collection; + } + interface CollectionChain { + /** + * @see _.takeRight + */ + takeRight(n?: number): CollectionChain; + } + interface LoDashStatic { + /** + * Creates a slice of array with elements taken from the end. Elements are taken until predicate returns + * falsey. The predicate is invoked with three arguments: (value, index, array). + * + * @param array The array to query. + * @param predicate The function invoked per iteration. + * @return Returns the slice of array. + */ + takeRightWhile(array: List | null | undefined, predicate?: ListIteratee): T[]; + } + interface Collection { + /** + * @see _.takeRightWhile + */ + takeRightWhile(predicate?: ListIteratee): Collection; + } + interface CollectionChain { + /** + * @see _.takeRightWhile + */ + takeRightWhile(predicate?: ListIteratee): CollectionChain; + } + interface LoDashStatic { + /** + * Creates a slice of array with elements taken from the beginning. Elements are taken until predicate returns + * falsey. The predicate is invoked with three arguments: (value, index, array). + * + * @param array The array to query. + * @param predicate The function invoked per iteration. + * @return Returns the slice of array. + */ + takeWhile(array: List | null | undefined, predicate?: ListIteratee): T[]; + } + interface Collection { + /** + * @see _.takeWhile + */ + takeWhile(predicate?: ListIteratee): Collection; + } + interface CollectionChain { + /** + * @see _.takeWhile + */ + takeWhile(predicate?: ListIteratee): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array of unique values, in order, from all of the provided arrays using SameValueZero for + * equality comparisons. + * + * @param arrays The arrays to inspect. + * @return Returns the new array of combined values. + */ + union(...arrays: Array | null | undefined>): T[]; + } + interface Collection { + /** + * @see _.union + */ + union(...arrays: Array | null | undefined>): Collection; + } + interface CollectionChain { + /** + * @see _.union + */ + union(...arrays: Array | null | undefined>): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @param arrays The arrays to inspect. + * @param iteratee The iteratee invoked per element. + * @return Returns the new array of combined values. + */ + unionBy(arrays: List | null | undefined, iteratee?: ValueIteratee): T[]; + /** + * @see _.unionBy + */ + unionBy(arrays1: List | null | undefined, arrays2: List | null | undefined, iteratee?: ValueIteratee): T[]; + /** + * @see _.unionBy + */ + unionBy(arrays1: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, iteratee?: ValueIteratee): T[]; + /** + * @see _.unionBy + */ + unionBy(arrays1: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, iteratee?: ValueIteratee): T[]; + /** + * @see _.unionBy + */ + unionBy(arrays1: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, arrays4: List | null | undefined, arrays5: List | null | undefined, ...iteratee: Array | List | null | undefined>): T[]; + } + interface Collection { + /** + * @see _.unionBy + */ + unionBy(arrays2: List | null | undefined, iteratee?: ValueIteratee): Collection; + /** + * @see _.unionBy + */ + unionBy(...iteratee: Array | List | null | undefined>): Collection; + } + interface CollectionChain { + /** + * @see _.unionBy + */ + unionBy(arrays2: List | null | undefined, iteratee?: ValueIteratee): CollectionChain; + /** + * @see _.unionBy + */ + unionBy(...iteratee: Array | List | null | undefined>): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @category Array + * @param [arrays] The arrays to inspect. + * @param [comparator] The comparator invoked per element. + * @returns Returns the new array of combined values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.unionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ + unionWith(arrays: List | null | undefined, comparator?: Comparator): T[]; + /** + * @see _.unionWith + */ + unionWith(arrays: List | null | undefined, arrays2: List | null | undefined, comparator?: Comparator): T[]; + /** + * @see _.unionWith + */ + unionWith(arrays: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, ...comparator: Array | List | null | undefined>): T[]; + } + interface Collection { + /** + * @see _.unionWith + */ + unionWith(arrays2: List | null | undefined, comparator?: Comparator): Collection; + /** + * @see _.unionWith + */ + unionWith(...comparator: Array | List | null | undefined>): Collection; + } + interface CollectionChain { + /** + * @see _.unionWith + */ + unionWith(arrays2: List | null | undefined, comparator?: Comparator): CollectionChain; + /** + * @see _.unionWith + */ + unionWith(...comparator: Array | List | null | undefined>): CollectionChain; + } + interface LoDashStatic { + /** + * Creates a duplicate-free version of an array, using + * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) + * for equality comparisons, in which only the first occurrence of each element + * is kept. + * + * @category Array + * @param array The array to inspect. + * @returns Returns the new duplicate free array. + * @example + * + * _.uniq([2, 1, 2]); + * // => [2, 1] + */ + uniq(array: List | null | undefined): T[]; + } + interface Collection { + /** + * @see _.uniq + */ + uniq(): Collection; + } + interface CollectionChain { + /** + * @see _.uniq + */ + uniq(): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.uniq` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @category Array + * @param array The array to inspect. + * @param [iteratee=_.identity] The iteratee invoked per element. + * @returns Returns the new duplicate free array. + * @example + * + * _.uniqBy([2.1, 1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * // using the `_.property` iteratee shorthand + * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */ + uniqBy(array: List | null | undefined, iteratee: ValueIteratee): T[]; + } + interface Collection { + /** + * @see _.uniqBy + */ + uniqBy(iteratee: ValueIteratee): Collection; + } + interface CollectionChain { + /** + * @see _.uniqBy + */ + uniqBy(iteratee: ValueIteratee): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.uniq` except that it accepts `comparator` which + * is invoked to compare elements of `array`. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * @category Array + * @param array The array to inspect. + * @param [comparator] The comparator invoked per element. + * @returns Returns the new duplicate free array. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.uniqWith(objects, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }] + */ + uniqWith(array: List | null | undefined, comparator?: Comparator): T[]; + } + interface Collection { + /** + * @see _.uniqWith + */ + uniqWith(comparator?: Comparator): Collection; + } + interface CollectionChain { + /** + * @see _.uniqWith + */ + uniqWith(comparator?: Comparator): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like _.zip except that it accepts an array of grouped elements and creates an array + * regrouping the elements to their pre-zip configuration. + * + * @param array The array of grouped elements to process. + * @return Returns the new array of regrouped elements. + */ + unzip(array: T[][] | List> | null | undefined): T[][]; + } + interface Collection { + /** + * @see _.unzip + */ + unzip(): T extends List ? Collection : unknown; + } + interface CollectionChain { + /** + * @see _.unzip + */ + unzip(): T extends List ? CollectionChain : unknown; + } + interface LoDashStatic { + /** + * This method is like _.unzip except that it accepts an iteratee to specify how regrouped values should be + * combined. The iteratee is invoked with four arguments: (accumulator, value, index, group). + * + * @param array The array of grouped elements to process. + * @param iteratee The function to combine regrouped values. + * @return Returns the new array of regrouped elements. + */ + unzipWith(array: List> | null | undefined, iteratee: (...values: T[]) => TResult): TResult[]; + /** + * @see _.unzipWith + */ + unzipWith(array: List> | null | undefined): T[][]; + } + interface Collection { + /** + * @see _.unzipWith + */ + unzipWith(iteratee: (...values: Array ? U : unknown>) => TResult): Collection; + /** + * @see _.unzipWith + */ + unzipWith(): T extends List ? Collection : unknown; + } + interface CollectionChain { + /** + * @see _.unzipWith + */ + unzipWith(iteratee: (...values: Array ? U : unknown>) => TResult): CollectionChain; + /** + * @see _.unzipWith + */ + unzipWith(): T extends List ? CollectionChain : unknown; + } + interface LoDashStatic { + /** + * Creates an array excluding all provided values using SameValueZero for equality comparisons. + * + * @param array The array to filter. + * @param values The values to exclude. + * @return Returns the new array of filtered values. + */ + without(array: List | null | undefined, ...values: T[]): T[]; + } + interface Collection { + /** + * @see _.without + */ + without(...values: T[]): Collection; + } + interface CollectionChain { + /** + * @see _.without + */ + without(...values: T[]): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array of unique values that is the symmetric difference of the provided arrays. + * + * @param arrays The arrays to inspect. + * @return Returns the new array of values. + */ + xor(...arrays: Array | null | undefined>): T[]; + } + interface Collection { + /** + * @see _.xor + */ + xor(...arrays: Array | null | undefined>): Collection; + } + interface CollectionChain { + /** + * @see _.xor + */ + xor(...arrays: Array | null | undefined>): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @category Array + * @param [arrays] The arrays to inspect. + * @param [iteratee=_.identity] The iteratee invoked per element. + * @returns Returns the new array of values. + * @example + * + * _.xorBy([2.1, 1.2], [4.3, 2.4], Math.floor); + * // => [1.2, 4.3] + * + * // using the `_.property` iteratee shorthand + * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */ + xorBy(arrays: List | null | undefined, iteratee?: ValueIteratee): T[]; + /** + * @see _.xorBy + */ + xorBy(arrays: List | null | undefined, arrays2: List | null | undefined, iteratee?: ValueIteratee): T[]; + /** + * @see _.xorBy + */ + xorBy(arrays: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, ...iteratee: Array | List | null | undefined>): T[]; + } + interface Collection { + /** + * @see _.xorBy + */ + xorBy(arrays2: List | null | undefined, iteratee?: ValueIteratee): Collection; + /** + * @see _.xorBy + */ + xorBy(...iteratee: Array | List | null | undefined>): Collection; + } + interface CollectionChain { + /** + * @see _.xorBy + */ + xorBy(arrays2: List | null | undefined, iteratee?: ValueIteratee): CollectionChain; + /** + * @see _.xorBy + */ + xorBy(...iteratee: Array | List | null | undefined>): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * @category Array + * @param [arrays] The arrays to inspect. + * @param [comparator] The comparator invoked per element. + * @returns Returns the new array of values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.xorWith(objects, others, _.isEqual); + * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ + xorWith(arrays: List | null | undefined, comparator?: Comparator): T[]; + /** + * @see _.xorWith + */ + xorWith(arrays: List | null | undefined, arrays2: List | null | undefined, comparator?: Comparator): T[]; + /** + * @see _.xorWith + */ + xorWith(arrays: List | null | undefined, arrays2: List | null | undefined, arrays3: List | null | undefined, ...comparator: Array | List | null | undefined>): T[]; + } + interface Collection { + /** + * @see _.xorWith + */ + xorWith(arrays2: List | null | undefined, comparator?: Comparator): Collection; + /** + * @see _.xorWith + */ + xorWith(...comparator: Array | List | null | undefined>): Collection; + } + interface CollectionChain { + /** + * @see _.xorWith + */ + xorWith(arrays2: List | null | undefined, comparator?: Comparator): CollectionChain; + /** + * @see _.xorWith + */ + xorWith(...comparator: Array | List | null | undefined>): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array of grouped elements, the first of which contains the first elements of the given arrays, + * the second of which contains the second elements of the given arrays, and so on. + * + * @param arrays The arrays to process. + * @return Returns the new array of grouped elements. + */ + zip(arrays1: List, arrays2: List): Array<[T1 | undefined, T2 | undefined]>; + /** + * @see _.zip + */ + zip(arrays1: List, arrays2: List, arrays3: List): Array<[T1 | undefined, T2 | undefined, T3 | undefined]>; + /** + * @see _.zip + */ + zip(arrays1: List, arrays2: List, arrays3: List, arrays4: List): Array<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined]>; + /** + * @see _.zip + */ + zip(arrays1: List, arrays2: List, arrays3: List, arrays4: List, arrays5: List): Array<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined, T5 | undefined]>; + /** + * @see _.zip + */ + zip(...arrays: Array | null | undefined>): Array>; + } + interface Collection { + /** + * @see _.zip + */ + zip(arrays2: List): Collection<[T | undefined, T2 | undefined]>; + /** + * @see _.zip + */ + zip(...arrays: Array | null | undefined>): Collection>; + } + interface CollectionChain { + /** + * @see _.zip + */ + zip(arrays2: List): CollectionChain<[T | undefined, T2 | undefined]>; + /** + * @see _.zip + */ + zip(...arrays: Array | null | undefined>): CollectionChain>; + } + interface LoDashStatic { + /** + * This method is like _.fromPairs except that it accepts two arrays, one of property + * identifiers and one of corresponding values. + * + * @param props The property names. + * @param values The property values. + * @return Returns the new object. + */ + zipObject(props: List, values: List): Dictionary; + /** + * @see _.zipObject + */ + zipObject(props?: List): Dictionary; + } + interface Collection { + /** + * @see _.zipObject + */ + zipObject(values: List): Object>; + /** + * @see _.zipObject + */ + zipObject(): Object>; + } + interface CollectionChain { + /** + * @see _.zipObject + */ + zipObject(values: List): ObjectChain>; + /** + * @see _.zipObject + */ + zipObject(): ObjectChain>; + } + interface LoDashStatic { + /** + * This method is like _.zipObject except that it supports property paths. + * + * @param paths The property names. + * @param values The property values. + * @return Returns the new object. + */ + zipObjectDeep(paths?: List, values?: List): object; + } + interface Collection { + /** + * @see _.zipObjectDeep + */ + zipObjectDeep(values?: List): Object; + } + interface CollectionChain { + /** + * @see _.zipObjectDeep + */ + zipObjectDeep(values?: List): ObjectChain; + } + interface LoDashStatic { + /** + * This method is like _.zip except that it accepts an iteratee to specify how grouped values should be + * combined. The iteratee is invoked with four arguments: (accumulator, value, index, + * group). + * @param arrays The arrays to process. + * @param iteratee The function to combine grouped values. + * @return Returns the new array of grouped elements. + */ + zipWith(arrays: List, iteratee: (value1: T) => TResult): TResult[]; + /** + * @see _.zipWith + */ + zipWith(arrays1: List, arrays2: List, iteratee: (value1: T1, value2: T2) => TResult): TResult[]; + /** + * @see _.zipWith + */ + zipWith(arrays1: List, arrays2: List, arrays3: List, iteratee: (value1: T1, value2: T2, value3: T3) => TResult): TResult[]; + /** + * @see _.zipWith + */ + zipWith(arrays1: List, arrays2: List, arrays3: List, arrays4: List, iteratee: (value1: T1, value2: T2, value3: T3, value4: T4) => TResult): TResult[]; + /** + * @see _.zipWith + */ + zipWith(arrays1: List, arrays2: List, arrays3: List, arrays4: List, arrays5: List, iteratee: (value1: T1, value2: T2, value3: T3, value4: T4, value5: T5) => TResult): TResult[]; + /** + * @see _.zipWith + */ + zipWith(...iteratee: Array<((...group: T[]) => TResult) | List | null | undefined>): TResult[]; + } + interface Collection { + /** + * @see _.zipWith + */ + zipWith(arrays2: List, iteratee: (value1: T, value2: T2) => TResult): Collection; + /** + * @see _.zipWith + */ + zipWith(arrays2: List, arrays3: List, iteratee: (value1: T, value2: T2, value3: T3) => TResult): Collection; + /** + * @see _.zipWith + */ + zipWith(...iteratee: Array<((...group: T[]) => TResult) | List | null | undefined>): Collection; + } + interface CollectionChain { + /** + * @see _.zipWith + */ + zipWith(arrays2: List, iteratee: (value1: T, value2: T2) => TResult): CollectionChain; + /** + * @see _.zipWith + */ + zipWith(arrays2: List, arrays3: List, iteratee: (value1: T, value2: T2, value3: T3) => TResult): CollectionChain; + /** + * @see _.zipWith + */ + zipWith(...iteratee: Array<((...group: T[]) => TResult) | List | null | undefined>): CollectionChain; + } +} diff --git a/types/lodash/ts3.1/common/collection.d.ts b/types/lodash/ts3.1/common/collection.d.ts new file mode 100644 index 0000000000..0f782e45c2 --- /dev/null +++ b/types/lodash/ts3.1/common/collection.d.ts @@ -0,0 +1,1918 @@ +import _ = require("../index"); +declare module "../index" { + interface LoDashStatic { + /** + * Creates an object composed of keys generated from the results of running each element of collection through + * iteratee. The corresponding value of each key is the number of times the key was returned by iteratee. The + * iteratee is invoked with one argument: (value). + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns the composed aggregate object. + */ + countBy(collection: List | null | undefined, iteratee?: ValueIteratee): Dictionary; + /** + * @see _.countBy + */ + countBy(collection: T | null | undefined, iteratee?: ValueIteratee): Dictionary; + } + interface Object { + /** + * @see _.countBy + */ + countBy(iteratee?: ValueIteratee): Object>; + } + interface String { + /** + * @see _.countBy + */ + countBy(iteratee?: ValueIteratee): Object>; + } + interface Collection { + /** + * @see _.countBy + */ + countBy(iteratee?: ValueIteratee): Object>; + } + interface ObjectChain { + /** + * @see _.countBy + */ + countBy(iteratee?: ValueIteratee): ObjectChain>; + } + interface StringChain { + /** + * @see _.countBy + */ + countBy(iteratee?: ValueIteratee): ObjectChain>; + } + interface StringNullableChain { + /** + * @see _.countBy + */ + countBy(iteratee?: ValueIteratee): ObjectChain>; + } + interface CollectionChain { + /** + * @see _.countBy + */ + countBy(iteratee?: ValueIteratee): ObjectChain>; + } + interface LoDashStatic { + /** + * @see _.forEach + */ + each: LoDashStatic['forEach']; + } + interface String { + /** + * @see _.each + */ + each: String['forEach']; + } + interface Collection { + /** + * @see _.each + */ + each: Collection['forEach']; + } + interface Object { + /** + * @see _.each + */ + each: Object['forEach']; + } + interface StringChain { + /** + * @see _.each + */ + each: StringChain['forEach']; + } + interface StringNullableChain { + /** + * @see _.each + */ + each: StringNullableChain['forEach']; + } + interface CollectionChain { + /** + * @see _.each + */ + each: CollectionChain['forEach']; + } + interface ObjectChain { + /** + * @see _.each + */ + each: ObjectChain['forEach']; + } + interface LoDashStatic { + /** + * @see _.forEachRight + */ + eachRight: LoDashStatic["forEachRight"]; + } + interface String { + /** + * @see _.eachRight + */ + eachRight: String['forEachRight']; + } + interface Collection { + /** + * @see _.eachRight + */ + eachRight: Collection['forEachRight']; + } + interface Object { + /** + * @see _.eachRight + */ + eachRight: Object['forEachRight']; + } + interface StringChain { + /** + * @see _.eachRight + */ + eachRight: StringChain['forEachRight']; + } + interface StringNullableChain { + /** + * @see _.eachRight + */ + eachRight: StringNullableChain['forEachRight']; + } + interface CollectionChain { + /** + * @see _.eachRight + */ + eachRight: CollectionChain['forEachRight']; + } + interface ObjectChain { + /** + * @see _.eachRight + */ + eachRight: ObjectChain['forEachRight']; + } + interface LoDashStatic { + /** + * Checks if predicate returns truthy for all elements of collection. Iteration is stopped once predicate + * returns falsey. The predicate is invoked with three arguments: (value, index|key, collection). + * + * @param collection The collection to iterate over. + * @param predicate The function invoked per iteration. + * @return Returns true if all elements pass the predicate check, else false. + */ + every(collection: List | null | undefined, predicate?: ListIterateeCustom): boolean; + /** + * @see _.every + */ + every(collection: T | null | undefined, predicate?: ObjectIterateeCustom): boolean; + } + interface Collection { + /** + * @see _.every + */ + every(predicate?: ListIterateeCustom): boolean; + } + interface Object { + /** + * @see _.every + */ + every(predicate?: ObjectIterateeCustom): boolean; + } + interface CollectionChain { + /** + * @see _.every + */ + every(predicate?: ListIterateeCustom): PrimitiveChain; + } + interface ObjectChain { + /** + * @see _.every + */ + every(predicate?: ObjectIterateeCustom): PrimitiveChain; + } + interface LoDashStatic { + /** + * Iterates over elements of collection, returning an array of all elements predicate returns truthy for. The + * predicate is invoked with three arguments: (value, index|key, collection). + * + * @param collection The collection to iterate over. + * @param predicate The function invoked per iteration. + * @return Returns the new filtered array. + */ + filter(collection: string | null | undefined, predicate?: StringIterator): string[]; + /** + * @see _.filter + */ + filter(collection: List | null | undefined, predicate: ListIteratorTypeGuard): S[]; + /** + * @see _.filter + */ + filter(collection: List | null | undefined, predicate?: ListIterateeCustom): T[]; + /** + * @see _.filter + */ + filter(collection: T | null | undefined, predicate: ObjectIteratorTypeGuard): S[]; + /** + * @see _.filter + */ + filter(collection: T | null | undefined, predicate?: ObjectIterateeCustom): Array; + } + interface String { + /** + * @see _.filter + */ + filter(predicate?: StringIterator): Collection; + } + interface Collection { + /** + * @see _.filter + */ + filter(predicate: ListIteratorTypeGuard): Collection; + /** + * @see _.filter + */ + filter(predicate?: ListIterateeCustom): Collection; + } + interface Object { + /** + * @see _.filter + */ + filter(predicate: ObjectIteratorTypeGuard): Collection; + /** + * @see _.filter + */ + filter(predicate?: ObjectIterateeCustom): Collection; + } + interface StringChain { + /** + * @see _.filter + */ + filter(predicate?: StringIterator): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.filter + */ + filter(predicate?: StringIterator): CollectionChain; + } + interface CollectionChain { + /** + * @see _.filter + */ + filter(predicate: ListIteratorTypeGuard): CollectionChain; + /** + * @see _.filter + */ + filter(predicate?: ListIterateeCustom): CollectionChain; + } + interface ObjectChain { + /** + * @see _.filter + */ + filter(predicate: ObjectIteratorTypeGuard): CollectionChain; + /** + * @see _.filter + */ + filter(predicate?: ObjectIterateeCustom): CollectionChain; + } + interface LoDashStatic { + /** + * Iterates over elements of collection, returning the first element predicate returns truthy for. + * The predicate is invoked with three arguments: (value, index|key, collection). + * + * @param collection The collection to search. + * @param predicate The function invoked per iteration. + * @param fromIndex The index to search from. + * @return Returns the matched element, else undefined. + */ + find(collection: List | null | undefined, predicate: ListIteratorTypeGuard, fromIndex?: number): S|undefined; + /** + * @see _.find + */ + find(collection: List | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number): T|undefined; + /** + * @see _.find + */ + find(collection: T | null | undefined, predicate: ObjectIteratorTypeGuard, fromIndex?: number): S|undefined; + /** + * @see _.find + */ + find(collection: T | null | undefined, predicate?: ObjectIterateeCustom, fromIndex?: number): T[keyof T]|undefined; + } + interface Collection { + /** + * @see _.find + */ + find(predicate: ListIteratorTypeGuard, fromIndex?: number): S|undefined; + /** + * @see _.find + */ + find(predicate?: ListIterateeCustom, fromIndex?: number): T|undefined; + } + interface Object { + /** + * @see _.find + */ + find< S extends T[keyof T]>(predicate: ObjectIteratorTypeGuard, fromIndex?: number): S|undefined; + /** + * @see _.find + */ + find(predicate?: ObjectIterateeCustom, fromIndex?: number): T[keyof T]|undefined; + } + interface CollectionChain { + /** + * @see _.find + */ + find< S extends T>(predicate: ListIteratorTypeGuard, fromIndex?: number): ExpChain; + /** + * @see _.find + */ + find(predicate?: ListIterateeCustom, fromIndex?: number): ExpChain; + } + interface ObjectChain { + /** + * @see _.find + */ + find< S extends T[keyof T]>(predicate: ObjectIteratorTypeGuard, fromIndex?: number): ExpChain; + /** + * @see _.find + */ + find(predicate?: ObjectIterateeCustom, fromIndex?: number): ExpChain; + } + interface LoDashStatic { + /** + * This method is like _.find except that it iterates over elements of a collection from + * right to left. + * @param collection Searches for a value in this list. + * @param predicate The function called per iteration. + * @param fromIndex The index to search from. + * @return The found element, else undefined. + */ + findLast(collection: List | null | undefined, predicate: ListIteratorTypeGuard, fromIndex?: number): S|undefined; + /** + * @see _.findLast + */ + findLast(collection: List | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number): T|undefined; + /** + * @see _.findLast + */ + findLast(collection: T | null | undefined, predicate: ObjectIteratorTypeGuard, fromIndex?: number): S|undefined; + /** + * @see _.findLast + */ + findLast(collection: T | null | undefined, predicate?: ObjectIterateeCustom, fromIndex?: number): T[keyof T]|undefined; + } + interface Collection { + /** + * @see _.findLast + */ + findLast(predicate: ListIteratorTypeGuard, fromIndex?: number): S|undefined; + /** + * @see _.findLast + */ + findLast(predicate?: ListIterateeCustom, fromIndex?: number): T|undefined; + } + interface Object { + /** + * @see _.findLast + */ + findLast< S extends T[keyof T]>(predicate: ObjectIteratorTypeGuard, fromIndex?: number): S|undefined; + /** + * @see _.findLast + */ + findLast(predicate?: ObjectIterateeCustom, fromIndex?: number): T[keyof T]|undefined; + } + interface CollectionChain { + /** + * @see _.findLast + */ + findLast< S extends T>(predicate: ListIteratorTypeGuard, fromIndex?: number): ExpChain; + /** + * @see _.findLast + */ + findLast(predicate?: ListIterateeCustom, fromIndex?: number): ExpChain; + } + interface ObjectChain { + /** + * @see _.findLast + */ + findLast< S extends T[keyof T]>(predicate: ObjectIteratorTypeGuard, fromIndex?: number): ExpChain; + /** + * @see _.findLast + */ + findLast(predicate?: ObjectIterateeCustom, fromIndex?: number): ExpChain; + } + interface LoDashStatic { + /** + * Creates an array of flattened values by running each element in collection through iteratee + * and concating its result to the other mapped values. The iteratee is invoked with three arguments: + * (value, index|key, collection). + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns the new flattened array. + */ + flatMap(collection: Dictionary> | NumericDictionary> | null | undefined): T[]; + /** + * @see _.flatMap + */ + flatMap(collection: object | null | undefined): any[]; + /** + * @see _.flatMap + */ + flatMap(collection: List | null | undefined, iteratee: ListIterator>): TResult[]; + /** + * @see _.flatMap + */ + flatMap(collection: T | null | undefined, iteratee: ObjectIterator>): TResult[]; + /** + * @see _.flatMap + */ + flatMap(collection: object | null | undefined, iteratee: string): any[]; + /** + * @see _.flatMap + */ + flatMap(collection: object | null | undefined, iteratee: object): boolean[]; + } + interface String { + /** + * @see _.flatMap + */ + flatMap(iteratee: StringIterator>): Collection; + /** + * @see _.flatMap + */ + flatMap(): Collection; + } + interface Collection { + /** + * @see _.flatMap + */ + flatMap(iteratee: ListIterator> | PropertyName): Collection; + /** + * @see _.flatMap + */ + flatMap(iteratee: [PropertyName, any] | object): Collection; + /** + * @see _.flatMap + */ + flatMap(): T extends Many ? Collection : Collection; + } + interface Object { + /** + * @see _.flatMap + */ + flatMap(iteratee: ObjectIterator> | PropertyName): Collection; + /** + * @see _.flatMap + */ + flatMap(iteratee: [PropertyName, any] | object): Collection; + /** + * @see _.flatMap + */ + flatMap(): Collection; + } + interface StringChain { + /** + * @see _.flatMap + */ + flatMap(iteratee: StringIterator>): CollectionChain; + /** + * @see _.flatMap + */ + flatMap(): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.flatMap + */ + flatMap(iteratee: StringIterator>): CollectionChain; + /** + * @see _.flatMap + */ + flatMap(): CollectionChain; + } + interface CollectionChain { + /** + * @see _.flatMap + */ + flatMap(iteratee: ListIterator> | PropertyName): CollectionChain; + /** + * @see _.flatMap + */ + flatMap(iteratee: [PropertyName, any] | object): CollectionChain; + /** + * @see _.flatMap + */ + flatMap(): T extends Many ? CollectionChain : CollectionChain; + } + interface ObjectChain { + /** + * @see _.flatMap + */ + flatMap(iteratee: ObjectIterator> | PropertyName): CollectionChain; + /** + * @see _.flatMap + */ + flatMap(iteratee: [PropertyName, any] | object): CollectionChain; + /** + * @see _.flatMap + */ + flatMap(): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.flatMap` except that it recursively flattens the + * mapped results. + * + * @since 4.7.0 + * @category Collection + * @param collection The collection to iterate over. + * @param [iteratee=_.identity] The function invoked per iteration. + * @returns Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * _.flatMapDeep([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ + flatMapDeep(collection: Dictionary | T> | NumericDictionary | T> | null | undefined): T[]; + /** + * @see _.flatMapDeep + */ + flatMapDeep(collection: List | null | undefined, iteratee: ListIterator | TResult>): TResult[]; + /** + * @see _.flatMapDeep + */ + flatMapDeep(collection: T | null | undefined, iteratee: ObjectIterator | TResult>): TResult[]; + /** + * @see _.flatMapDeep + */ + flatMapDeep(collection: object | null | undefined, iteratee: string): any[]; + /** + * @see _.flatMapDeep + */ + flatMapDeep(collection: object | null | undefined, iteratee: object): boolean[]; + } + interface String { + /** + * @see _.flatMapDeep + */ + flatMapDeep(iteratee: StringIterator | TResult>): Collection; + /** + * @see _.flatMapDeep + */ + flatMapDeep(): Collection; + } + interface Collection { + /** + * @see _.flatMapDeep + */ + flatMapDeep(iteratee: ListIterator | TResult> | PropertyName): Collection; + /** + * @see _.flatMapDeep + */ + flatMapDeep(iteratee: [PropertyName, any] | object): Collection; + /** + * @see _.flatMapDeep + */ + flatMapDeep(): Collection; + } + interface Object { + /** + * @see _.flatMapDeep + */ + flatMapDeep(iteratee: ObjectIterator | TResult> | PropertyName): Collection; + /** + * @see _.flatMapDeep + */ + flatMapDeep(iteratee: [PropertyName, any] | object): Collection; + /** + * @see _.flatMapDeep + */ + flatMapDeep(): Collection; + } + interface StringChain { + /** + * @see _.flatMapDeep + */ + flatMapDeep(iteratee: StringIterator | TResult>): CollectionChain; + /** + * @see _.flatMapDeep + */ + flatMapDeep(): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.flatMapDeep + */ + flatMapDeep(iteratee: StringIterator | TResult>): CollectionChain; + /** + * @see _.flatMapDeep + */ + flatMapDeep(): CollectionChain; + } + interface CollectionChain { + /** + * @see _.flatMapDeep + */ + flatMapDeep(iteratee: ListIterator | TResult> | PropertyName): CollectionChain; + /** + * @see _.flatMapDeep + */ + flatMapDeep(iteratee: [PropertyName, any] | object): CollectionChain; + /** + * @see _.flatMapDeep + */ + flatMapDeep(): CollectionChain; + } + interface ObjectChain { + /** + * @see _.flatMapDeep + */ + flatMapDeep(iteratee: ObjectIterator | TResult> | PropertyName): CollectionChain; + /** + * @see _.flatMapDeep + */ + flatMapDeep(iteratee: [PropertyName, any] | object): CollectionChain; + /** + * @see _.flatMapDeep + */ + flatMapDeep(): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.flatMap` except that it recursively flattens the + * mapped results up to `depth` times. + * + * @since 4.7.0 + * @category Collection + * @param collection The collection to iterate over. + * @param [iteratee=_.identity] The function invoked per iteration. + * @param [depth=1] The maximum recursion depth. + * @returns Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * _.flatMapDepth([1, 2], duplicate, 2); + * // => [[1, 1], [2, 2]] + */ + flatMapDepth(collection: Dictionary | T> | NumericDictionary | T> | null | undefined): T[]; + /** + * @see _.flatMapDepth + */ + flatMapDepth(collection: List | null | undefined, iteratee: ListIterator | TResult>, depth?: number): TResult[]; + /** + * @see _.flatMapDepth + */ + flatMapDepth(collection: T | null | undefined, iteratee: ObjectIterator | TResult>, depth?: number): TResult[]; + /** + * @see _.flatMapDepth + */ + flatMapDepth(collection: object | null | undefined, iteratee: string, depth?: number): any[]; + /** + * @see _.flatMapDepth + */ + flatMapDepth(collection: object | null | undefined, iteratee: object, depth?: number): boolean[]; + } + interface String { + /** + * @see _.flatMapDepth + */ + flatMapDepth(iteratee: StringIterator | TResult>, depth?: number): Collection; + /** + * @see _.flatMapDepth + */ + flatMapDepth(depth?: number): Collection; + } + interface Collection { + /** + * @see _.flatMapDepth + */ + flatMapDepth(iteratee: ListIterator | TResult> | PropertyName, depth?: number): Collection; + /** + * @see _.flatMapDepth + */ + flatMapDepth(iteratee: [PropertyName, any] | object, depth?: number): Collection; + /** + * @see _.flatMapDepth + */ + flatMapDepth(depth?: number): Collection; + } + interface Object { + /** + * @see _.flatMapDepth + */ + flatMapDepth(iteratee: ObjectIterator | TResult> | PropertyName, depth?: number): Collection; + /** + * @see _.flatMapDepth + */ + flatMapDepth(iteratee: [PropertyName, any] | object, depth?: number): Collection; + /** + * @see _.flatMapDepth + */ + flatMapDepth(depth?: number): Collection; + } + interface StringChain { + /** + * @see _.flatMapDepth + */ + flatMapDepth(iteratee: StringIterator | TResult>, depth?: number): CollectionChain; + /** + * @see _.flatMapDepth + */ + flatMapDepth(depth?: number): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.flatMapDepth + */ + flatMapDepth(iteratee: StringIterator | TResult>, depth?: number): CollectionChain; + /** + * @see _.flatMapDepth + */ + flatMapDepth(depth?: number): CollectionChain; + } + interface CollectionChain { + /** + * @see _.flatMapDepth + */ + flatMapDepth(iteratee: ListIterator | TResult> | PropertyName, depth?: number): CollectionChain; + /** + * @see _.flatMapDepth + */ + flatMapDepth(iteratee: [PropertyName, any] | object, depth?: number): CollectionChain; + /** + * @see _.flatMapDepth + */ + flatMapDepth(depth?: number): CollectionChain; + } + interface ObjectChain { + /** + * @see _.flatMapDepth + */ + flatMapDepth(iteratee: ObjectIterator | TResult> | PropertyName, depth?: number): CollectionChain; + /** + * @see _.flatMapDepth + */ + flatMapDepth(iteratee: [PropertyName, any] | object, depth?: number): CollectionChain; + /** + * @see _.flatMapDepth + */ + flatMapDepth(depth?: number): CollectionChain; + } + interface LoDashStatic { + /** + * Iterates over elements of collection invoking iteratee for each element. The iteratee is invoked with three arguments: + * (value, index|key, collection). Iteratee functions may exit iteration early by explicitly returning false. + * + * Note: As with other "Collections" methods, objects with a "length" property are iterated like arrays. To + * avoid this behavior _.forIn or _.forOwn may be used for object iteration. + * + * @alias _.each + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + */ + forEach(collection: T[], iteratee?: ArrayIterator): T[]; + /** + * @see _.forEach + */ + forEach(collection: string, iteratee?: StringIterator): string; + /** + * @see _.forEach + */ + forEach(collection: List, iteratee?: ListIterator): List; + /** + * @see _.forEach + */ + forEach(collection: T, iteratee?: ObjectIterator): T; + /** + * @see _.forEach + */ + forEach(collection: TArray & (T[] | null | undefined), iteratee?: ArrayIterator): TArray; + /** + * @see _.forEach + */ + forEach(collection: TString, iteratee?: StringIterator): TString; + /** + * @see _.forEach + */ + forEach | null | undefined>(collection: TList & (List | null | undefined), iteratee?: ListIterator): TList; + /** + * @see _.forEach + */ + forEach(collection: T | null | undefined, iteratee?: ObjectIterator): T | null | undefined; + } + interface String { + /** + * @see _.forEach + */ + forEach(iteratee?: StringIterator): String; + } + interface Object { + /** + * @see _.forEach + */ + forEach(iteratee?: ObjectIterator): Object; + } + interface Collection { + /** + * @see _.forEach + */ + forEach(iteratee?: ListIterator): Collection; + } + interface StringChain { + /** + * @see _.forEach + */ + forEach(iteratee?: StringIterator): StringChain; + } + interface StringNullableChain { + /** + * @see _.forEach + */ + forEach(iteratee?: StringIterator): StringNullableChain; + } + interface ObjectChain { + /** + * @see _.forEach + */ + forEach(iteratee?: ObjectIterator): ObjectChain; + } + interface CollectionChain { + /** + * @see _.forEach + */ + forEach(iteratee?: ListIterator): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like _.forEach except that it iterates over elements of collection from right to left. + * + * @alias _.eachRight + * + * @param collection The collection to iterate over. + * @param iteratee The function called per iteration. + */ + forEachRight(collection: T[], iteratee?: ArrayIterator): T[]; + /** + * @see _.forEachRight + */ + forEachRight(collection: string, iteratee?: StringIterator): string; + /** + * @see _.forEachRight + */ + forEachRight(collection: List, iteratee?: ListIterator): List; + /** + * @see _.forEachRight + */ + forEachRight(collection: T, iteratee?: ObjectIterator): T; + /** + * @see _.forEachRight + */ + forEachRight(collection: TArray & (T[] | null | undefined), iteratee?: ArrayIterator): TArray; + /** + * @see _.forEachRight + */ + forEachRight(collection: TString, iteratee?: StringIterator): TString; + /** + * @see _.forEachRight + */ + forEachRight | null | undefined>(collection: TList & (List | null | undefined), iteratee?: ListIterator): TList; + /** + * @see _.forEachRight + */ + forEachRight(collection: T | null | undefined, iteratee?: ObjectIterator): T | null | undefined; + } + interface String { + /** + * @see _.forEachRight + */ + forEachRight(iteratee?: StringIterator): String; + } + interface Object { + /** + * @see _.forEachRight + */ + forEachRight(iteratee?: ObjectIterator): Object; + } + interface Collection { + /** + * @see _.forEachRight + */ + forEachRight(iteratee?: ListIterator): Collection; + } + interface StringChain { + /** + * @see _.forEachRight + */ + forEachRight(iteratee?: StringIterator): StringChain; + } + interface StringNullableChain { + /** + * @see _.forEachRight + */ + forEachRight(iteratee?: StringIterator): StringNullableChain; + } + interface ObjectChain { + /** + * @see _.forEachRight + */ + forEachRight(iteratee?: ObjectIterator): ObjectChain; + } + interface CollectionChain { + /** + * @see _.forEachRight + */ + forEachRight(iteratee?: ListIterator): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an object composed of keys generated from the results of running each element of collection through + * iteratee. The corresponding value of each key is an array of the elements responsible for generating the + * key. The iteratee is invoked with one argument: (value). + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns the composed aggregate object. + */ + groupBy(collection: List | null | undefined, iteratee?: ValueIteratee): Dictionary; + /** + * @see _.groupBy + */ + groupBy(collection: T | null | undefined, iteratee?: ValueIteratee): Dictionary>; + } + interface String { + /** + * @see _.groupBy + */ + groupBy(iteratee?: ValueIteratee): Object>; + } + interface Collection { + /** + * @see _.groupBy + */ + groupBy(iteratee?: ValueIteratee): Object>; + } + interface Object { + /** + * @see _.groupBy + */ + groupBy(iteratee?: ValueIteratee): Object>>; + } + interface StringChain { + /** + * @see _.groupBy + */ + groupBy(iteratee?: ValueIteratee): ObjectChain>; + } + interface StringNullableChain { + /** + * @see _.groupBy + */ + groupBy(iteratee?: ValueIteratee): ObjectChain>; + } + interface CollectionChain { + /** + * @see _.groupBy + */ + groupBy(iteratee?: ValueIteratee): ObjectChain>; + } + interface ObjectChain { + /** + * @see _.groupBy + */ + groupBy(iteratee?: ValueIteratee): ObjectChain>>; + } + interface LoDashStatic { + /** + * Checks if target is in collection using SameValueZero for equality comparisons. If fromIndex is negative, + * it’s used as the offset from the end of collection. + * + * @param collection The collection to search. + * @param target The value to search for. + * @param fromIndex The index to search from. + * @return True if the target element is found, else false. + */ + includes(collection: Dictionary | NumericDictionary | null | undefined, target: T, fromIndex?: number): boolean; + } + interface Object { + /** + * @see _.includes + */ + includes(target: T[keyof T], fromIndex?: number): boolean; + } + interface Collection { + /** + * @see _.includes + */ + includes(target: T, fromIndex?: number): boolean; + } + interface ObjectChain { + /** + * @see _.includes + */ + includes(target: T[keyof T], fromIndex?: number): PrimitiveChain; + } + interface CollectionChain { + /** + * @see _.includes + */ + includes(target: T, fromIndex?: number): PrimitiveChain; + } + interface LoDashStatic { + /** + * Invokes the method named by methodName on each element in the collection returning + * an array of the results of each invoked method. Additional arguments will be provided + * to each invoked method. If methodName is a function it will be invoked for, and this + * bound to, each element in the collection. + * @param collection The collection to iterate over. + * @param methodName The name of the method to invoke. + * @param args Arguments to invoke the method with. + */ + invokeMap(collection: object | null | undefined, methodName: string, ...args: any[]): any[]; + /** + * @see _.invokeMap + */ + invokeMap(collection: object | null | undefined, method: (...args: any[]) => TResult, ...args: any[]): TResult[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.invokeMap + */ + invokeMap(methodName: string, ...args: any[]): Collection; + /** + * @see _.invokeMap + */ + invokeMap(method: (...args: any[]) => TResult, ...args: any[]): Collection; + } + interface LoDashExplicitWrapper { + /** + * @see _.invokeMap + */ + invokeMap(methodName: string, ...args: any[]): CollectionChain; + /** + * @see _.invokeMap + */ + invokeMap(method: (...args: any[]) => TResult, ...args: any[]): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an object composed of keys generated from the results of running each element of collection through + * iteratee. The corresponding value of each key is the last element responsible for generating the key. The + * iteratee function is invoked with one argument: (value). + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns the composed aggregate object. + */ + keyBy(collection: List | null | undefined, iteratee?: ValueIterateeCustom): Dictionary; + /** + * @see _.keyBy + */ + keyBy(collection: T | null | undefined, iteratee?: ValueIterateeCustom): Dictionary; + } + interface String { + /** + * @see _.keyBy + */ + keyBy(iteratee?: ValueIterateeCustom): Object>; + } + interface Collection { + /** + * @see _.keyBy + */ + keyBy(iteratee?: ValueIterateeCustom): Object>; + } + interface Object { + /** + * @see _.keyBy + */ + keyBy(iteratee?: ValueIterateeCustom): Object>; + } + interface StringChain { + /** + * @see _.keyBy + */ + keyBy(iteratee?: ValueIterateeCustom): ObjectChain>; + } + interface StringNullableChain { + /** + * @see _.keyBy + */ + keyBy(iteratee?: ValueIterateeCustom): ObjectChain>; + } + interface CollectionChain { + /** + * @see _.keyBy + */ + keyBy(iteratee?: ValueIterateeCustom): ObjectChain>; + } + interface ObjectChain { + /** + * @see _.keyBy + */ + keyBy(iteratee?: ValueIterateeCustom): ObjectChain>; + } + interface LoDashStatic { + /** + * Creates an array of values by running each element in collection through iteratee. The iteratee is + * invoked with three arguments: (value, index|key, collection). + * + * Many lodash methods are guarded to work as iteratees for methods like _.every, _.filter, _.map, _.mapValues, + * _.reject, and _.some. + * + * The guarded methods are: + * ary, callback, chunk, clone, create, curry, curryRight, drop, dropRight, every, fill, flatten, invert, max, + * min, parseInt, slice, sortBy, take, takeRight, template, trim, trimLeft, trimRight, trunc, random, range, + * sample, some, sum, uniq, and words + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns the new mapped array. + */ + map(collection: T[] | null | undefined, iteratee: ArrayIterator): TResult[]; + /** + * @see _.map + */ + map(collection: List | null | undefined, iteratee: ListIterator): TResult[]; + /** + * @see _.map + */ + map(collection: Dictionary | NumericDictionary | null | undefined): T[]; + /** + * @see _.map + */ + map(collection: T | null | undefined, iteratee: ObjectIterator): TResult[]; + /** + * @see _.map + */ + map(collection: Dictionary | NumericDictionary | null | undefined, iteratee: K): Array; + /** + * @see _.map + */ + map(collection: Dictionary | NumericDictionary | null | undefined, iteratee?: string): any[]; + /** + * @see _.map + */ + map(collection: Dictionary | NumericDictionary | null | undefined, iteratee?: object): boolean[]; + } + + interface String { + /** + * @see _.map + */ + map(iteratee: StringIterator): Collection; + /** + * @see _.map + */ + map(): Collection; + } + interface Collection { + /** + * @see _.map + */ + map(key: K): Collection; + /** + * @see _.map + */ + map(iteratee: ListIterator): Collection; + /** + * @see _.map + */ + map(iteratee: PropertyName): Collection; + /** + * @see _.map + */ + map(iteratee: [PropertyName, any] | object): Collection; + /** + * @see _.map + */ + map(): Collection; + } + interface Object { + /** + * @see _.map + */ + map(key: K): Collection; + /** + * @see _.map + */ + map(iteratee: ObjectIterator): Collection; + /** + * @see _.map + */ + map(iteratee: PropertyName): Collection; + /** + * @see _.map + */ + map(iteratee: [PropertyName, any] | object): Collection; + /** + * @see _.map + */ + map(): Collection; + } + interface StringChain { + /** + * @see _.map + */ + map(iteratee: StringIterator): CollectionChain; + /** + * @see _.map + */ + map(): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.map + */ + map(iteratee: StringIterator): CollectionChain; + /** + * @see _.map + */ + map(): CollectionChain; + } + interface CollectionChain { + /** + * @see _.map + */ + map(key: K): CollectionChain; + /** + * @see _.map + */ + map(iteratee: ListIterator): CollectionChain; + /** + * @see _.map + */ + map(iteratee: PropertyName): CollectionChain; + /** + * @see _.map + */ + map(iteratee: [PropertyName, any] | object): CollectionChain; + /** + * @see _.map + */ + map(): CollectionChain; + } + interface ObjectChain { + /** + * @see _.map + */ + map(key: K): CollectionChain; + /** + * @see _.map + */ + map(iteratee: ObjectIterator): CollectionChain; + /** + * @see _.map + */ + map(iteratee: PropertyName): CollectionChain; + /** + * @see _.map + */ + map(iteratee: [PropertyName, any] | object): CollectionChain; + /** + * @see _.map + */ + map(): CollectionChain; + } + interface LoDashStatic { + /** + * This method is like `_.sortBy` except that it allows specifying the sort + * orders of the iteratees to sort by. If `orders` is unspecified, all values + * are sorted in ascending order. Otherwise, specify an order of "desc" for + * descending or "asc" for ascending sort order of corresponding values. + * + * @category Collection + * @param collection The collection to iterate over. + * @param [iteratees=[_.identity]] The iteratees to sort by. + * @param [orders] The sort orders of `iteratees`. + * @param- {Object} [guard] Enables use as an iteratee for functions like `_.reduce`. + * @returns Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 34 }, + * { 'user': 'fred', 'age': 42 }, + * { 'user': 'barney', 'age': 36 } + * ]; + * + * // sort by `user` in ascending order and by `age` in descending order + * _.orderBy(users, ['user', 'age'], ['asc', 'desc']); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]] + */ + orderBy(collection: List | null | undefined, iteratees?: Many>, orders?: Many): T[]; + /** + * @see _.orderBy + */ + orderBy(collection: List | null | undefined, iteratees?: Many>, orders?: Many): T[]; + /** + * @see _.orderBy + */ + orderBy(collection: T | null | undefined, iteratees?: Many>, orders?: Many): Array; + /** + * @see _.orderBy + */ + orderBy(collection: T | null | undefined, iteratees?: Many>, orders?: Many): Array; + } + interface Collection { + /** + * @see _.orderBy + */ + orderBy(iteratees?: Many>, orders?: Many): Collection; + } + interface Object { + /** + * @see _.orderBy + */ + orderBy(iteratees?: Many>, orders?: Many): Collection; + } + interface CollectionChain { + /** + * @see _.orderBy + */ + orderBy(iteratees?: Many>, orders?: Many): CollectionChain; + } + interface ObjectChain { + /** + * @see _.orderBy + */ + orderBy(iteratees?: Many>, orders?: Many): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array of elements split into two groups, the first of which contains elements predicate returns truthy for, + * while the second of which contains elements predicate returns falsey for. + * The predicate is invoked with three arguments: (value, index|key, collection). + * + * @param collection The collection to iterate over. + * @param callback The function called per iteration. + * @return Returns the array of grouped elements. + */ + partition(collection: List | null | undefined, callback: ValueIteratorTypeGuard): [U[], Array>]; + /** + * @see _.partition + */ + partition(collection: List | null | undefined, callback: ValueIteratee): [T[], T[]]; + /** + * @see _.partition + */ + partition(collection: T | null | undefined, callback: ValueIteratee): [Array, Array]; + } + interface String { + /** + * @see _.partition + */ + partition(callback: StringIterator): LoDashImplicitWrapper<[string[], string[]]>; + } + interface Collection { + /** + * @see _.partition + */ + partition(callback: ValueIteratorTypeGuard): LoDashImplicitWrapper<[U[], Array>]>; + /** + * @see _.partition + */ + partition(callback: ValueIteratee): LoDashImplicitWrapper<[T[], T[]]>; + } + interface Object { + /** + * @see _.partition + */ + partition(callback: ValueIteratee): LoDashImplicitWrapper<[Array, Array]>; + } + interface StringChain { + /** + * @see _.partition + */ + partition(callback: StringIterator): LoDashExplicitWrapper<[string[], string[]]>; + } + interface StringNullableChain { + /** + * @see _.partition + */ + partition(callback: StringIterator): LoDashExplicitWrapper<[string[], string[]]>; + } + interface CollectionChain { + /** + * @see _.partition + */ + partition(callback: ValueIteratorTypeGuard): LoDashExplicitWrapper<[U[], Array>]>; + /** + * @see _.partition + */ + partition(callback: ValueIteratee): LoDashExplicitWrapper<[T[], T[]]>; + } + interface ObjectChain { + /** + * @see _.partition + */ + partition(callback: ValueIteratee): LoDashExplicitWrapper<[Array, Array]>; + } + interface LoDashStatic { + /** + * Reduces a collection to a value which is the accumulated result of running each + * element in the collection through the callback, where each successive callback execution + * consumes the return value of the previous execution. If accumulator is not provided the + * first element of the collection will be used as the initial accumulator value. The callback + * is invoked with four arguments: (accumulator, value, index|key, collection). + * @param collection The collection to iterate over. + * @param callback The function called per iteration. + * @param accumulator Initial value of the accumulator. + * @return Returns the accumulated value. + */ + reduce(collection: T[] | null | undefined, callback: MemoListIterator, accumulator: TResult): TResult; + /** + * @see _.reduce + */ + reduce(collection: List | null | undefined, callback: MemoListIterator>, accumulator: TResult): TResult; + /** + * @see _.reduce + */ + reduce(collection: T | null | undefined, callback: MemoObjectIterator, accumulator: TResult): TResult; + /** + * @see _.reduce + */ + reduce(collection: T[] | null | undefined, callback: MemoListIterator): T | undefined; + /** + * @see _.reduce + */ + reduce(collection: List | null | undefined, callback: MemoListIterator>): T | undefined; + /** + * @see _.reduce + */ + reduce(collection: T | null | undefined, callback: MemoObjectIterator): T[keyof T] | undefined; + } + interface Collection { + /** + * @see _.reduce + */ + reduce(callback: MemoListIterator>, accumulator: TResult): TResult; + /** + * @see _.reduce + */ + reduce(callback: MemoListIterator>): T | undefined; + } + interface Object { + /** + * @see _.reduce + */ + reduce(callback: MemoObjectIterator, accumulator: TResult): TResult; + /** + * @see _.reduce + */ + reduce(callback: MemoObjectIterator): T[keyof T] | undefined; + } + interface CollectionChain { + /** + * @see _.reduce + */ + reduce(callback: MemoListIterator>, accumulator: TResult): ExpChain; + /** + * @see _.reduce + */ + reduce(callback: MemoListIterator>): ExpChain; + } + interface ObjectChain { + /** + * @see _.reduce + */ + reduce(callback: MemoObjectIterator, accumulator: TResult): ExpChain; + /** + * @see _.reduce + */ + reduce(callback: MemoObjectIterator): ExpChain; + } + interface LoDashStatic { + /** + * This method is like _.reduce except that it iterates over elements of a collection from + * right to left. + * @param collection The collection to iterate over. + * @param callback The function called per iteration. + * @param accumulator Initial value of the accumulator. + * @return The accumulated value. + */ + reduceRight(collection: T[] | null | undefined, callback: MemoListIterator, accumulator: TResult): TResult; + /** + * @see _.reduceRight + */ + reduceRight(collection: List | null | undefined, callback: MemoListIterator>, accumulator: TResult): TResult; + /** + * @see _.reduceRight + */ + reduceRight(collection: T | null | undefined, callback: MemoObjectIterator, accumulator: TResult): TResult; + /** + * @see _.reduceRight + */ + reduceRight(collection: T[] | null | undefined, callback: MemoListIterator): T | undefined; + /** + * @see _.reduceRight + */ + reduceRight(collection: List | null | undefined, callback: MemoListIterator>): T | undefined; + /** + * @see _.reduceRight + */ + reduceRight(collection: T | null | undefined, callback: MemoObjectIterator): T[keyof T] | undefined; + } + interface Collection { + /** + * @see _.reduceRight + */ + reduceRight(callback: MemoListIterator>, accumulator: TResult): TResult; + /** + * @see _.reduceRight + */ + reduceRight(callback: MemoListIterator>): T | undefined; + } + interface Object { + /** + * @see _.reduceRight + */ + reduceRight(callback: MemoObjectIterator, accumulator: TResult): TResult; + /** + * @see _.reduceRight + */ + reduceRight(callback: MemoObjectIterator): T[keyof T] | undefined; + } + interface CollectionChain { + /** + * @see _.reduceRight + */ + reduceRight(callback: MemoListIterator>, accumulator: TResult): ExpChain; + /** + * @see _.reduceRight + */ + reduceRight(callback: MemoListIterator>): ExpChain; + } + interface ObjectChain { + /** + * @see _.reduceRight + */ + reduceRight(callback: MemoObjectIterator, accumulator: TResult): ExpChain; + /** + * @see _.reduceRight + */ + reduceRight(callback: MemoObjectIterator): ExpChain; + } + interface LoDashStatic { + /** + * The opposite of _.filter; this method returns the elements of collection that predicate does not return + * truthy for. + * + * @param collection The collection to iterate over. + * @param predicate The function invoked per iteration. + * @return Returns the new filtered array. + */ + reject(collection: string | null | undefined, predicate?: StringIterator): string[]; + /** + * @see _.reject + */ + reject(collection: List | null | undefined, predicate?: ListIterateeCustom): T[]; + /** + * @see _.reject + */ + reject(collection: T | null | undefined, predicate?: ObjectIterateeCustom): Array; + } + interface String { + /** + * @see _.reject + */ + reject(predicate?: StringIterator): Collection; + } + interface Collection { + /** + * @see _.reject + */ + reject(predicate?: ListIterateeCustom): Collection; + } + interface Object { + /** + * @see _.reject + */ + reject(predicate?: ObjectIterateeCustom): Collection; + } + interface StringChain { + /** + * @see _.reject + */ + reject(predicate?: StringIterator): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.reject + */ + reject(predicate?: StringIterator): CollectionChain; + } + interface CollectionChain { + /** + * @see _.reject + */ + reject(predicate?: ListIterateeCustom): CollectionChain; + } + interface ObjectChain { + /** + * @see _.reject + */ + reject(predicate?: ObjectIterateeCustom): CollectionChain; + } + interface LoDashStatic { + /** + * Gets a random element from collection. + * + * @param collection The collection to sample. + * @return Returns the random element. + */ + sample(collection: Dictionary | NumericDictionary | null | undefined): T | undefined; + /** + * @see _.sample + */ + sample(collection: T | null | undefined): T[keyof T] | undefined; + } + interface String { + /** + * @see _.sample + */ + sample(): string | undefined; + } + interface Collection { + /** + * @see _.sample + */ + sample(): T | undefined; + } + interface Object { + /** + * @see _.sample + */ + sample(): T[keyof T] | undefined; + } + interface StringChain { + /** + * @see _.sample + */ + sample(): StringNullableChain; + } + interface StringNullableChain { + /** + * @see _.sample + */ + sample(): StringNullableChain; + } + interface CollectionChain { + /** + * @see _.sample + */ + sample(): ExpChain; + } + interface ObjectChain { + /** + * @see _.sample + */ + sample(): ExpChain; + } + interface LoDashStatic { + /** + * Gets n random elements at unique keys from collection up to the size of collection. + * + * @param collection The collection to sample. + * @param n The number of elements to sample. + * @return Returns the random elements. + */ + sampleSize(collection: Dictionary | NumericDictionary | null | undefined, n?: number): T[]; + /** + * @see _.sampleSize + */ + sampleSize(collection: T | null | undefined, n?: number): Array; + } + interface String { + /** + * @see _.sampleSize + */ + sampleSize(n?: number): Collection; + } + interface Collection { + /** + * @see _.sampleSize + */ + sampleSize(n?: number): Collection; + } + interface Object { + /** + * @see _.sampleSize + */ + sampleSize(n?: number): Collection; + } + interface StringChain { + /** + * @see _.sampleSize + */ + sampleSize(n?: number): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.sampleSize + */ + sampleSize(n?: number): CollectionChain; + } + interface CollectionChain { + /** + * @see _.sampleSize + */ + sampleSize(n?: number): CollectionChain; + } + interface ObjectChain { + /** + * @see _.sampleSize + */ + sampleSize(n?: number): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array of shuffled values, using a version of the Fisher-Yates shuffle. + * + * @param collection The collection to shuffle. + * @return Returns the new shuffled array. + */ + shuffle(collection: List | null | undefined): T[]; + /** + * @see _.shuffle + */ + shuffle(collection: T | null | undefined): Array; + } + interface String { + /** + * @see _.shuffle + */ + shuffle(): Collection; + } + interface Collection { + /** + * @see _.shuffle + */ + shuffle(): Collection; + } + interface Object { + /** + * @see _.shuffle + */ + shuffle(): Collection; + } + interface StringChain { + /** + * @see _.shuffle + */ + shuffle(): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.shuffle + */ + shuffle(): CollectionChain; + } + interface CollectionChain { + /** + * @see _.shuffle + */ + shuffle(): CollectionChain; + } + interface ObjectChain { + /** + * @see _.shuffle + */ + shuffle(): CollectionChain; + } + interface LoDashStatic { + /** + * Gets the size of collection by returning its length for array-like values or the number of own enumerable + * properties for objects. + * + * @param collection The collection to inspect. + * @return Returns the size of collection. + */ + size(collection: object | string | null | undefined): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.size + */ + size(): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.size + */ + size(): PrimitiveChain; + } + interface LoDashStatic { + /** + * Checks if predicate returns truthy for any element of collection. Iteration is stopped once predicate + * returns truthy. The predicate is invoked with three arguments: (value, index|key, collection). + * + * @param collection The collection to iterate over. + * @param predicate The function invoked per iteration. + * @return Returns true if any element passes the predicate check, else false. + */ + some(collection: List | null | undefined, predicate?: ListIterateeCustom): boolean; + /** + * @see _.some + */ + some(collection: T | null | undefined, predicate?: ObjectIterateeCustom): boolean; + } + interface Collection { + /** + * @see _.some + */ + some(predicate?: ListIterateeCustom): boolean; + } + interface Object { + /** + * @see _.some + */ + some(predicate?: ObjectIterateeCustom): boolean; + } + interface CollectionChain { + /** + * @see _.some + */ + some(predicate?: ListIterateeCustom): PrimitiveChain; + } + interface ObjectChain { + /** + * @see _.some + */ + some(predicate?: ObjectIterateeCustom): PrimitiveChain; + } + interface LoDashStatic { + /** + * Creates an array of elements, sorted in ascending order by the results of + * running each element in a collection through each iteratee. This method + * performs a stable sort, that is, it preserves the original sort order of + * equal elements. The iteratees are invoked with one argument: (value). + * + * @category Collection + * @param collection The collection to iterate over. + * @param [iteratees=[_.identity]] + * The iteratees to sort by, specified individually or in arrays. + * @returns Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 42 }, + * { 'user': 'barney', 'age': 34 } + * ]; + * + * _.sortBy(users, function(o) { return o.user; }); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]] + * + * _.sortBy(users, ['user', 'age']); + * // => objects for [['barney', 34], ['barney', 36], ['fred', 42], ['fred', 48]] + * + * _.sortBy(users, 'user', function(o) { + * return Math.floor(o.age / 10); + * }); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]] + */ + sortBy(collection: List | null | undefined, ...iteratees: Array>>): T[]; + /** + * @see _.sortBy + */ + sortBy(collection: T | null | undefined, ...iteratees: Array>>): Array; + } + interface Collection { + /** + * @see _.sortBy + */ + sortBy(...iteratees: Array>>): Collection; + } + interface Object { + /** + * @see _.sortBy + */ + sortBy(...iteratees: Array>>): Collection; + } + interface CollectionChain { + /** + * @see _.sortBy + */ + sortBy(...iteratees: Array>>): CollectionChain; + } + interface ObjectChain { + /** + * @see _.sortBy + */ + sortBy(...iteratees: Array>>): CollectionChain; + } +} diff --git a/types/lodash/ts3.1/common/common.d.ts b/types/lodash/ts3.1/common/common.d.ts new file mode 100644 index 0000000000..dc892a1ca6 --- /dev/null +++ b/types/lodash/ts3.1/common/common.d.ts @@ -0,0 +1,286 @@ +import _ = require("../index"); +// tslint:disable-next-line:strict-export-declare-modifiers +type GlobalPartial = Partial; +declare module "../index" { + type Omit = Pick>; + type PartialObject = GlobalPartial; + type Many = T | ReadonlyArray; + type ImpChain = + T extends { __trapAny: any } ? Collection & Function & Object & Primitive & String : + T extends null | undefined ? Primitive : + T extends string | null | undefined ? String : + T extends (...args: any) => any ? Function : + T extends List | null | undefined ? Collection : + T extends object | null | undefined ? Object : + Primitive; + type ExpChain = + T extends { __trapAny: any } ? CollectionChain & FunctionChain & ObjectChain & PrimitiveChain & StringChain : + T extends null | undefined ? PrimitiveChain : + T extends string ? StringChain : + T extends string | null | undefined ? StringNullableChain : + T extends (...args: any) => any ? FunctionChain : + T extends List | null | undefined ? CollectionChain : + T extends object | null | undefined ? ObjectChain : + PrimitiveChain; + interface LoDashStatic { + /** + * Creates a lodash object which wraps value to enable implicit method chain sequences. + * Methods that operate on and return arrays, collections, and functions can be chained together. + * Methods that retrieve a single value or may return a primitive value will automatically end the + * chain sequence and return the unwrapped value. Otherwise, the value must be unwrapped with value(). + * + * Explicit chain sequences, which must be unwrapped with value(), may be enabled using _.chain. + * + * The execution of chained methods is lazy, that is, it's deferred until value() is + * implicitly or explicitly called. + * + * Lazy evaluation allows several methods to support shortcut fusion. Shortcut fusion + * is an optimization to merge iteratee calls; this avoids the creation of intermediate + * arrays and can greatly reduce the number of iteratee executions. Sections of a chain + * sequence qualify for shortcut fusion if the section is applied to an array and iteratees + * accept only one argument. The heuristic for whether a section qualifies for shortcut + * fusion is subject to change. + * + * Chaining is supported in custom builds as long as the value() method is directly or + * indirectly included in the build. + * + * In addition to lodash methods, wrappers have Array and String methods. + * The wrapper Array methods are: + * concat, join, pop, push, shift, sort, splice, and unshift. + * The wrapper String methods are: + * replace and split. + * + * The wrapper methods that support shortcut fusion are: + * at, compact, drop, dropRight, dropWhile, filter, find, findLast, head, initial, last, + * map, reject, reverse, slice, tail, take, takeRight, takeRightWhile, takeWhile, and toArray + * + * The chainable wrapper methods are: + * after, ary, assign, assignIn, assignInWith, assignWith, at, before, bind, bindAll, bindKey, + * castArray, chain, chunk, commit, compact, concat, conforms, constant, countBy, create, + * curry, debounce, defaults, defaultsDeep, defer, delay, difference, differenceBy, differenceWith, + * drop, dropRight, dropRightWhile, dropWhile, extend, extendWith, fill, filter, flatMap, + * flatMapDeep, flatMapDepth, flatten, flattenDeep, flattenDepth, flip, flow, flowRight, + * fromPairs, functions, functionsIn, groupBy, initial, intersection, intersectionBy, intersectionWith, + * invert, invertBy, invokeMap, iteratee, keyBy, keys, keysIn, map, mapKeys, mapValues, + * matches, matchesProperty, memoize, merge, mergeWith, method, methodOf, mixin, negate, + * nthArg, omit, omitBy, once, orderBy, over, overArgs, overEvery, overSome, partial, partialRight, + * partition, pick, pickBy, plant, property, propertyOf, pull, pullAll, pullAllBy, pullAllWith, pullAt, + * push, range, rangeRight, rearg, reject, remove, rest, reverse, sampleSize, set, setWith, + * shuffle, slice, sort, sortBy, sortedUniq, sortedUniqBy, splice, spread, tail, take, + * takeRight, takeRightWhile, takeWhile, tap, throttle, thru, toArray, toPairs, toPairsIn, + * toPath, toPlainObject, transform, unary, union, unionBy, unionWith, uniq, uniqBy, uniqWith, + * unset, unshift, unzip, unzipWith, update, updateWith, values, valuesIn, without, wrap, + * xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, and zipWith. + * + * The wrapper methods that are not chainable by default are: + * add, attempt, camelCase, capitalize, ceil, clamp, clone, cloneDeep, cloneDeepWith, cloneWith, + * conformsTo, deburr, defaultTo, divide, each, eachRight, endsWith, eq, escape, escapeRegExp, + * every, find, findIndex, findKey, findLast, findLastIndex, findLastKey, first, floor, forEach, + * forEachRight, forIn, forInRight, forOwn, forOwnRight, get, gt, gte, has, hasIn, head, + * identity, includes, indexOf, inRange, invoke, isArguments, isArray, isArrayBuffer, + * isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isElement, isEmpty, isEqual, isEqualWith, + * isError, isFinite, isFunction, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN, + * isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isRegExp, + * isSafeInteger, isSet, isString, isUndefined, isTypedArray, isWeakMap, isWeakSet, join, + * kebabCase, last, lastIndexOf, lowerCase, lowerFirst, lt, lte, max, maxBy, mean, meanBy, + * min, minBy, multiply, noConflict, noop, now, nth, pad, padEnd, padStart, parseInt, pop, + * random, reduce, reduceRight, repeat, result, round, runInContext, sample, shift, size, + * snakeCase, some, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy, startCase, + * startsWith, stubArray, stubFalse, stubObject, stubString, stubTrue, subtract, sum, sumBy, + * template, times, toFinite, toInteger, toJSON, toLength, toLower, toNumber, toSafeInteger, + * toString, toUpper, trim, trimEnd, trimStart, truncate, unescape, uniqueId, upperCase, + * upperFirst, value, and words. + **/ + (value: TrapAny): Collection & Function & Object & Primitive & String; + (value: T): Primitive; + (value: string | null | undefined): String; + any>(value: T): Function; + (value: List | null | undefined): Collection; + (value: T | null | undefined): Object; + (value: T): Primitive; + /** + * The semantic version number. + **/ + VERSION: string; + /** + * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby + * (ERB). Change the following template settings to use alternative delimiters. + **/ + templateSettings: TemplateSettings; + } + /** + * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby + * (ERB). Change the following template settings to use alternative delimiters. + **/ + interface TemplateSettings { + /** + * The "escape" delimiter. + **/ + escape?: RegExp; + /** + * The "evaluate" delimiter. + **/ + evaluate?: RegExp; + /** + * An object to import into the template as local variables. + */ + imports?: Dictionary; + /** + * The "interpolate" delimiter. + */ + interpolate?: RegExp; + /** + * Used to reference the data object in the template text. + */ + variable?: string; + } + /** + * Creates a cache object to store key/value pairs. + */ + interface MapCache { + /** + * Removes `key` and its value from the cache. + * @param key The key of the value to remove. + * @return Returns `true` if the entry was removed successfully, else `false`. + */ + delete(key: any): boolean; + /** + * Gets the cached value for `key`. + * @param key The key of the value to get. + * @return Returns the cached value. + */ + get(key: any): any; + /** + * Checks if a cached value for `key` exists. + * @param key The key of the entry to check. + * @return Returns `true` if an entry for `key` exists, else `false`. + */ + has(key: any): boolean; + /** + * Sets `value` to `key` of the cache. + * @param key The key of the value to cache. + * @param value The value to cache. + * @return Returns the cache object. + */ + set(key: any, value: any): this; + /** + * Removes all key-value entries from the map. + */ + clear?: () => void; + } + interface MapCacheConstructor { + new (): MapCache; + } + interface Collection { + pop(): T | undefined; + push(...items: T[]): this; + shift(): T | undefined; + sort(compareFn?: (a: T, b: T) => number): this; + splice(start: number, deleteCount?: number, ...items: T[]): this; + unshift(...items: T[]): this; + } + interface CollectionChain { + pop(): ExpChain; + push(...items: T[]): this; + shift(): ExpChain; + sort(compareFn?: (a: T, b: T) => number): this; + splice(start: number, deleteCount?: number, ...items: T[]): this; + unshift(...items: T[]): this; + } + interface Function any> extends LoDashImplicitWrapper { + } + interface String extends LoDashImplicitWrapper { + } + interface Object extends LoDashImplicitWrapper { + } + interface Collection extends LoDashImplicitWrapper> { + } + interface Primitive extends LoDashImplicitWrapper { + } + interface FunctionChain any> extends LoDashExplicitWrapper { + } + interface StringChain extends LoDashExplicitWrapper { + } + interface StringNullableChain extends LoDashExplicitWrapper { + } + interface ObjectChain extends LoDashExplicitWrapper { + } + interface CollectionChain extends LoDashExplicitWrapper> { + } + interface CollectionNullableChain extends LoDashExplicitWrapper | undefined> { + } + interface PrimitiveChain extends LoDashExplicitWrapper { + } + type NotVoid = unknown; + type IterateeShorthand = PropertyName | [PropertyName, any] | PartialDeep; + type ArrayIterator = (value: T, index: number, collection: T[]) => TResult; + type ListIterator = (value: T, index: number, collection: List) => TResult; + type ListIteratee = ListIterator | IterateeShorthand; + type ListIterateeCustom = ListIterator | IterateeShorthand; + type ListIteratorTypeGuard = (value: T, index: number, collection: List) => value is S; + // Note: key should be string, not keyof T, because the actual object may contain extra properties that were not specified in the type. + type ObjectIterator = (value: TObject[keyof TObject], key: string, collection: TObject) => TResult; + type ObjectIteratee = ObjectIterator | IterateeShorthand; + type ObjectIterateeCustom = ObjectIterator | IterateeShorthand; + type ObjectIteratorTypeGuard = (value: TObject[keyof TObject], key: string, collection: TObject) => value is S; + type StringIterator = (char: string, index: number, string: string) => TResult; + /** @deprecated Use MemoVoidArrayIterator or MemoVoidDictionaryIterator instead. */ + type MemoVoidIterator = (prev: TResult, curr: T, indexOrKey: any, list: T[]) => void; + /** @deprecated Use MemoListIterator or MemoObjectIterator instead. */ + type MemoIterator = (prev: TResult, curr: T, indexOrKey: any, list: T[]) => TResult; + type MemoListIterator = (prev: TResult, curr: T, index: number, list: TList) => TResult; + type MemoObjectIterator = (prev: TResult, curr: T, key: string, list: TList) => TResult; + type MemoIteratorCapped = (prev: TResult, curr: T) => TResult; + type MemoIteratorCappedRight = (curr: T, prev: TResult) => TResult; + type MemoVoidArrayIterator = (acc: TResult, curr: T, index: number, arr: T[]) => void; + type MemoVoidDictionaryIterator = (acc: TResult, curr: T, key: string, dict: Dictionary) => void; + type MemoVoidIteratorCapped = (acc: TResult, curr: T) => void; + type ValueIteratee = ((value: T) => NotVoid) | IterateeShorthand; + type ValueIterateeCustom = ((value: T) => TResult) | IterateeShorthand; + type ValueIteratorTypeGuard = (value: T) => value is S; + type ValueKeyIteratee = ((value: T, key: string) => NotVoid) | IterateeShorthand; + type ValueKeyIterateeTypeGuard = (value: T, key: string) => value is S; + type Comparator = (a: T, b: T) => boolean; + type Comparator2 = (a: T1, b: T2) => boolean; + type PropertyName = string | number | symbol; + type PropertyPath = Many; + /** Common interface between Arrays and jQuery objects */ + type List = ArrayLike; + interface Dictionary { + [index: string]: T; + } + interface NumericDictionary { + [index: number]: T; + } + // Crazy typedef needed get _.omit to work properly with Dictionary and NumericDictionary + type AnyKindOfDictionary = + | Dictionary + | NumericDictionary; + interface Cancelable { + cancel(): void; + flush(): void; + } + type PartialDeep = { + [P in keyof T]?: PartialDeep; + }; + // For backwards compatibility + type LoDashImplicitArrayWrapper = LoDashImplicitWrapper; + type LoDashImplicitNillableArrayWrapper = LoDashImplicitWrapper; + type LoDashImplicitObjectWrapper = LoDashImplicitWrapper; + type LoDashImplicitNillableObjectWrapper = LoDashImplicitWrapper; + type LoDashImplicitNumberArrayWrapper = LoDashImplicitWrapper; + type LoDashImplicitStringWrapper = LoDashImplicitWrapper; + type LoDashExplicitArrayWrapper = LoDashExplicitWrapper; + type LoDashExplicitNillableArrayWrapper = LoDashExplicitWrapper; + type LoDashExplicitObjectWrapper = LoDashExplicitWrapper; + type LoDashExplicitNillableObjectWrapper = LoDashExplicitWrapper; + type LoDashExplicitNumberArrayWrapper = LoDashExplicitWrapper; + type LoDashExplicitStringWrapper = LoDashExplicitWrapper; + type DictionaryIterator = ObjectIterator, TResult>; + type DictionaryIteratee = ObjectIteratee>; + type DictionaryIteratorTypeGuard = ObjectIteratorTypeGuard, S>; + // NOTE: keys of objects at run time are always strings, even when a NumericDictionary is being iterated. + type NumericDictionaryIterator = (value: T, key: string, collection: NumericDictionary) => TResult; + type NumericDictionaryIteratee = NumericDictionaryIterator | IterateeShorthand; + type NumericDictionaryIterateeCustom = NumericDictionaryIterator | IterateeShorthand; +} diff --git a/types/lodash/ts3.1/common/date.d.ts b/types/lodash/ts3.1/common/date.d.ts new file mode 100644 index 0000000000..cc652ae6c6 --- /dev/null +++ b/types/lodash/ts3.1/common/date.d.ts @@ -0,0 +1,23 @@ +import _ = require("../index"); +declare module "../index" { + interface LoDashStatic { + /* + * Gets the number of milliseconds that have elapsed since the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @return The number of milliseconds. + */ + now(): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.now + */ + now(): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.now + */ + now(): PrimitiveChain; + } +} diff --git a/types/lodash/ts3.1/common/function.d.ts b/types/lodash/ts3.1/common/function.d.ts new file mode 100644 index 0000000000..3c43825e3a --- /dev/null +++ b/types/lodash/ts3.1/common/function.d.ts @@ -0,0 +1,1392 @@ +import _ = require("../index"); +declare module "../index" { + interface LoDashStatic { + /** + * The opposite of _.before; this method creates a function that invokes func once it’s called n or more times. + * + * @param n The number of calls before func is invoked. + * @param func The function to restrict. + * @return Returns the new restricted function. + */ + after any>(n: number, func: TFunc): TFunc; + } + interface Primitive { + /** + * @see _.after + */ + after any>(func: TFunc): Function; + } + interface PrimitiveChain { + /** + * @see _.after + */ + after any>(func: TFunc): FunctionChain; + } + interface LoDashStatic { + /** + * Creates a function that accepts up to n arguments ignoring any additional arguments. + * + * @param func The function to cap arguments for. + * @param n The arity cap. + * @returns Returns the new function. + */ + ary(func: (...args: any[]) => any, n?: number): (...args: any[]) => any; + } + interface Function { + /** + * @see _.ary + */ + ary(n?: number): Function<(...args: any[]) => any>; + } + interface FunctionChain { + /** + * @see _.ary + */ + ary(n?: number): FunctionChain<(...args: any[]) => any>; + } + interface LoDashStatic { + /** + * Creates a function that invokes func, with the this binding and arguments of the created function, while + * it’s called less than n times. Subsequent calls to the created function return the result of the last func + * invocation. + * + * @param n The number of calls at which func is no longer invoked. + * @param func The function to restrict. + * @return Returns the new restricted function. + */ + before any>(n: number, func: TFunc): TFunc; + } + interface Primitive { + /** + * @see _.before + */ + before any>(func: TFunc): Function; + } + interface PrimitiveChain { + /** + * @see _.before + */ + before any>(func: TFunc): FunctionChain; + } + interface FunctionBind { + /** + * @see _.placeholder + */ + placeholder: __; + (func: (...args: any[]) => any, thisArg: any, ...partials: any[]): (...args: any[]) => any; + } + interface LoDashStatic { + /** + * Creates a function that invokes func with the this binding of thisArg and prepends any additional _.bind + * arguments to those provided to the bound function. + * + * The _.bind.placeholder value, which defaults to _ in monolithic builds, may be used as a placeholder for + * partially applied arguments. + * + * Note: Unlike native Function#bind this method does not set the "length" property of bound functions. + * + * @param func The function to bind. + * @param thisArg The this binding of func. + * @param partials The arguments to be partially applied. + * @return Returns the new bound function. + */ + bind: FunctionBind; + } + interface LoDashImplicitWrapper { + /** + * @see _.bind + */ + bind(thisArg: any, ...partials: any[]): Function<(...args: any[]) => any>; + } + interface LoDashExplicitWrapper { + /** + * @see _.bind + */ + bind(thisArg: any, ...partials: any[]): FunctionChain<(...args: any[]) => any>; + } + interface FunctionBindKey { + placeholder: __; + (object: object, key: string, ...partials: any[]): (...args: any[]) => any; + } + interface LoDashStatic { + /** + * Creates a function that invokes the method at object[key] and prepends any additional _.bindKey arguments + * to those provided to the bound function. + * + * This method differs from _.bind by allowing bound functions to reference methods that may be redefined + * or don’t yet exist. See Peter Michaux’s article for more details. + * + * The _.bindKey.placeholder value, which defaults to _ in monolithic builds, may be used as a placeholder + * for partially applied arguments. + * + * @param object The object the method belongs to. + * @param key The key of the method. + * @param partials The arguments to be partially applied. + * @return Returns the new bound function. + */ + bindKey: FunctionBindKey; + } + interface LoDashImplicitWrapper { + /** + * @see _.bindKey + */ + bindKey(key: string, ...partials: any[]): Function<(...args: any[]) => any>; + } + interface LoDashExplicitWrapper { + /** + * @see _.bindKey + */ + bindKey(key: string, ...partials: any[]): FunctionChain<(...args: any[]) => any>; + } + interface Curry { + (func: (t1: T1) => R, arity?: number): CurriedFunction1; + (func: (t1: T1, t2: T2) => R, arity?: number): CurriedFunction2; + (func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): CurriedFunction3; + (func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): CurriedFunction4; + (func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): CurriedFunction5; + (func: (...args: any[]) => any, arity?: number): (...args: any[]) => any; + placeholder: __; + } + interface LoDashStatic { + curry: Curry; + } + interface CurriedFunction1 { + (): CurriedFunction1; + (t1: T1): R; + } + interface CurriedFunction2 { + (): CurriedFunction2; + (t1: T1): CurriedFunction1; + (t1: __, t2: T2): CurriedFunction1; + (t1: T1, t2: T2): R; + } + interface CurriedFunction3 { + (): CurriedFunction3; + (t1: T1): CurriedFunction2; + (t1: __, t2: T2): CurriedFunction2; + (t1: T1, t2: T2): CurriedFunction1; + (t1: __, t2: __, t3: T3): CurriedFunction2; + (t1: T1, t2: __, t3: T3): CurriedFunction1; + (t1: __, t2: T2, t3: T3): CurriedFunction1; + (t1: T1, t2: T2, t3: T3): R; + } + interface CurriedFunction4 { + (): CurriedFunction4; + (t1: T1): CurriedFunction3; + (t1: __, t2: T2): CurriedFunction3; + (t1: T1, t2: T2): CurriedFunction2; + (t1: __, t2: __, t3: T3): CurriedFunction3; + (t1: __, t2: __, t3: T3): CurriedFunction2; + (t1: __, t2: T2, t3: T3): CurriedFunction2; + (t1: T1, t2: T2, t3: T3): CurriedFunction1; + (t1: __, t2: __, t3: __, t4: T4): CurriedFunction3; + (t1: T1, t2: __, t3: __, t4: T4): CurriedFunction2; + (t1: __, t2: T2, t3: __, t4: T4): CurriedFunction2; + (t1: __, t2: __, t3: T3, t4: T4): CurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: T4): CurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4): CurriedFunction1; + (t1: __, t2: T2, t3: T3, t4: T4): CurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4): R; + } + interface CurriedFunction5 { + (): CurriedFunction5; + (t1: T1): CurriedFunction4; + (t1: __, t2: T2): CurriedFunction4; + (t1: T1, t2: T2): CurriedFunction3; + (t1: __, t2: __, t3: T3): CurriedFunction4; + (t1: T1, t2: __, t3: T3): CurriedFunction3; + (t1: __, t2: T2, t3: T3): CurriedFunction3; + (t1: T1, t2: T2, t3: T3): CurriedFunction2; + (t1: __, t2: __, t3: __, t4: T4): CurriedFunction4; + (t1: T1, t2: __, t3: __, t4: T4): CurriedFunction3; + (t1: __, t2: T2, t3: __, t4: T4): CurriedFunction3; + (t1: __, t2: __, t3: T3, t4: T4): CurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: T4): CurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: T4): CurriedFunction2; + (t1: __, t2: T2, t3: T3, t4: T4): CurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: T4): CurriedFunction1; + (t1: __, t2: __, t3: __, t4: __, t5: T5): CurriedFunction4; + (t1: T1, t2: __, t3: __, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: T2, t3: __, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: __, t3: T3, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: __, t3: __, t4: T4, t5: T5): CurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: __, t5: T5): CurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __, t5: T5): CurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4, t5: T5): CurriedFunction2; + (t1: __, t2: T2, t3: T3, t4: __, t5: T5): CurriedFunction2; + (t1: __, t2: T2, t3: __, t4: T4, t5: T5): CurriedFunction2; + (t1: __, t2: __, t3: T3, t4: T4, t5: T5): CurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: __, t5: T5): CurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4, t5: T5): CurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4, t5: T5): CurriedFunction1; + (t1: __, t2: T2, t3: T3, t4: T4, t5: T5): CurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; + } + interface RightCurriedFunction1 { + (): RightCurriedFunction1; + (t1: T1): R; + } + interface RightCurriedFunction2 { + (): RightCurriedFunction2; + (t2: T2): RightCurriedFunction1; + (t1: T1, t2: __): RightCurriedFunction1; + (t1: T1, t2: T2): R; + } + interface RightCurriedFunction3 { + (): RightCurriedFunction3; + (t3: T3): RightCurriedFunction2; + (t2: T2, t3: __): RightCurriedFunction2; + (t2: T2, t3: T3): RightCurriedFunction1; + (t1: T1, t2: __, t3: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3): R; + } + interface RightCurriedFunction4 { + (): RightCurriedFunction4; + (t4: T4): RightCurriedFunction3; + (t3: T3, t4: __): RightCurriedFunction3; + (t3: T3, t4: T4): RightCurriedFunction2; + (t2: T2, t3: __, t4: __): RightCurriedFunction3; + (t2: T2, t3: T3, t4: __): RightCurriedFunction2; + (t2: T2, t3: __, t4: T4): RightCurriedFunction2; + (t2: T2, t3: T3, t4: T4): RightCurriedFunction1; + (t1: T1, t2: __, t3: __, t4: __): RightCurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4): RightCurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: __): RightCurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4): R; + } + interface RightCurriedFunction5 { + (): RightCurriedFunction5; + (t5: T5): RightCurriedFunction4; + (t4: T4, t5: __): RightCurriedFunction4; + (t4: T4, t5: T5): RightCurriedFunction3; + (t3: T3, t4: __, t5: __): RightCurriedFunction4; + (t3: T3, t4: T4, t5: __): RightCurriedFunction3; + (t3: T3, t4: __, t5: T5): RightCurriedFunction3; + (t3: T3, t4: T4, t5: T5): RightCurriedFunction2; + (t2: T2, t3: __, t4: __, t5: __): RightCurriedFunction4; + (t2: T2, t3: T3, t4: __, t5: __): RightCurriedFunction3; + (t2: T2, t3: __, t4: T4, t5: __): RightCurriedFunction3; + (t2: T2, t3: __, t4: __, t5: T5): RightCurriedFunction3; + (t2: T2, t3: T3, t4: T4, t5: __): RightCurriedFunction2; + (t2: T2, t3: T3, t4: __, t5: T5): RightCurriedFunction2; + (t2: T2, t3: __, t4: T4, t5: T5): RightCurriedFunction2; + (t2: T2, t3: T3, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: __, t3: __, t4: __, t5: __): RightCurriedFunction4; + (t1: T1, t2: T2, t3: __, t4: __, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: T3, t4: __, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: __, t4: T4, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: __, t4: __, t5: T5): RightCurriedFunction3; + (t1: T1, t2: T2, t3: T3, t4: __, t5: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: T4, t5: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: __, t5: T5): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: T4, t5: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __, t5: T5): RightCurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4, t5: T5): RightCurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: __): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: __, t5: T5): RightCurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; + } + interface Function { + /** + * @see _.curry + */ + curry(arity?: number): + T extends (arg1: infer T1) => infer R ? Function> : + T extends (arg1: infer T1, arg2: infer T2) => infer R ? Function> : + T extends (arg1: infer T1, arg2: infer T2, arg3: infer T3) => infer R ? Function> : + T extends (arg1: infer T1, arg2: infer T2, arg3: infer T3, arg4: infer T4) => infer R ? Function> : + T extends (arg1: infer T1, arg2: infer T2, arg3: infer T3, arg4: infer T4, arg5: infer T5) => infer R ? Function> : + Function<(...args: any[]) => any>; + } + interface FunctionChain { + /** + * @see _.curry + */ + curry(arity?: number): + T extends (arg1: infer T1) => infer R ? FunctionChain> : + T extends (arg1: infer T1, arg2: infer T2) => infer R ? FunctionChain> : + T extends (arg1: infer T1, arg2: infer T2, arg3: infer T3) => infer R ? FunctionChain> : + T extends (arg1: infer T1, arg2: infer T2, arg3: infer T3, arg4: infer T4) => infer R ? FunctionChain> : + T extends (arg1: infer T1, arg2: infer T2, arg3: infer T3, arg4: infer T4, arg5: infer T5) => infer R ? FunctionChain> : + FunctionChain<(...args: any[]) => any>; + } + interface CurryRight { + (func: (t1: T1) => R, arity?: number): RightCurriedFunction1; + (func: (t1: T1, t2: T2) => R, arity?: number): RightCurriedFunction2; + (func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): RightCurriedFunction3; + (func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): RightCurriedFunction4; + (func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): RightCurriedFunction5; + (func: (...args: any[]) => any, arity?: number): (...args: any[]) => any; + placeholder: __; + } + interface LoDashStatic { + curryRight: CurryRight; + } + interface Function { + /** + * @see _.curryRight + */ + curryRight(arity?: number): + T extends (arg1: infer T1) => infer R ? Function> : + T extends (arg1: infer T1, arg2: infer T2) => infer R ? Function> : + T extends (arg1: infer T1, arg2: infer T2, arg3: infer T3) => infer R ? Function> : + T extends (arg1: infer T1, arg2: infer T2, arg3: infer T3, arg4: infer T4) => infer R ? Function> : + T extends (arg1: infer T1, arg2: infer T2, arg3: infer T3, arg4: infer T4, arg5: infer T5) => infer R ? Function> : + Function<(...args: any[]) => any>; + } + interface FunctionChain { + /** + * @see _.curryRight + */ + curryRight(arity?: number): + T extends (arg1: infer T1) => infer R ? FunctionChain> : + T extends (arg1: infer T1, arg2: infer T2) => infer R ? FunctionChain> : + T extends (arg1: infer T1, arg2: infer T2, arg3: infer T3) => infer R ? FunctionChain> : + T extends (arg1: infer T1, arg2: infer T2, arg3: infer T3, arg4: infer T4) => infer R ? FunctionChain> : + T extends (arg1: infer T1, arg2: infer T2, arg3: infer T3, arg4: infer T4, arg5: infer T5) => infer R ? FunctionChain> : + FunctionChain<(...args: any[]) => any>; + } + interface DebounceSettings { + /** + * @see _.leading + */ + leading?: boolean; + /** + * @see _.maxWait + */ + maxWait?: number; + /** + * @see _.trailing + */ + trailing?: boolean; + } + interface LoDashStatic { + /** + * Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since + * the last time the debounced function was invoked. The debounced function comes with a cancel method to + * cancel delayed invocations and a flush method to immediately invoke them. Provide an options object to + * indicate that func should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent + * calls to the debounced function return the result of the last func invocation. + * + * Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only + * if the the debounced function is invoked more than once during the wait timeout. + * + * See David Corbacho’s article for details over the differences between _.debounce and _.throttle. + * + * @param func The function to debounce. + * @param wait The number of milliseconds to delay. + * @param options The options object. + * @param options.leading Specify invoking on the leading edge of the timeout. + * @param options.maxWait The maximum time func is allowed to be delayed before it’s invoked. + * @param options.trailing Specify invoking on the trailing edge of the timeout. + * @return Returns the new debounced function. + */ + debounce any>(func: T, wait?: number, options?: DebounceSettings): T & Cancelable; + } + interface Function any> { + /** + * @see _.debounce + */ + debounce(wait?: number, options?: DebounceSettings): Function; + } + interface FunctionChain any> { + /** + * @see _.debounce + */ + debounce(wait?: number, options?: DebounceSettings): FunctionChain; + } + interface LoDashStatic { + /** + * Defers invoking the func until the current call stack has cleared. Any additional arguments are provided to + * func when it’s invoked. + * + * @param func The function to defer. + * @param args The arguments to invoke the function with. + * @return Returns the timer id. + */ + defer(func: (...args: any[]) => any, ...args: any[]): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.defer + */ + defer(...args: any[]): Primitive; + } + interface LoDashExplicitWrapper { + /** + * @see _.defer + */ + defer(...args: any[]): PrimitiveChain; + } + interface LoDashStatic { + /** + * Invokes func after wait milliseconds. Any additional arguments are provided to func when it’s invoked. + * + * @param func The function to delay. + * @param wait The number of milliseconds to delay invocation. + * @param args The arguments to invoke the function with. + * @return Returns the timer id. + */ + delay(func: (...args: any[]) => any, wait: number, ...args: any[]): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.delay + */ + delay(wait: number, ...args: any[]): Primitive; + } + interface LoDashExplicitWrapper { + /** + * @see _.delay + */ + delay(wait: number, ...args: any[]): PrimitiveChain; + } + interface LoDashStatic { + /** + * Creates a function that invokes `func` with arguments reversed. + * + * @category Function + * @param func The function to flip arguments for. + * @returns Returns the new function. + * @example + * + * var flipped = _.flip(function() { + * return _.toArray(arguments); + * }); + * + * flipped('a', 'b', 'c', 'd'); + * // => ['d', 'c', 'b', 'a'] + */ + flip any>(func: T): T; + } + interface Function any> { + /** + * @see _.flip + */ + flip(): this; + } + interface FunctionChain any> { + /** + * @see _.flip + */ + flip(): this; + } + interface MemoizedFunction { + /** + * @see _.cache + */ + cache: MapCache; + } + interface LoDashStatic { + /** + * Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for + * storing the result based on the arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with + * the this binding of the memoized function. + * + * @param func The function to have its output memoized. + * @param resolver The function to resolve the cache key. + * @return Returns the new memoizing function. + */ + memoize: { + any>(func: T, resolver?: (...args: any[]) => any): T & MemoizedFunction; + Cache: MapCacheConstructor; + }; + } + interface Function any> { + /** + * @see _.memoize + */ + memoize(resolver?: (...args: any[]) => any): Function; + } + interface FunctionChain any> { + /** + * @see _.memoize + */ + memoize(resolver?: (...args: any[]) => any): FunctionChain; + } + interface LoDashStatic { + /** + * Creates a function that negates the result of the predicate func. The func predicate is invoked with + * the this binding and arguments of the created function. + * + * @param predicate The predicate to negate. + * @return Returns the new function. + */ + negate(predicate: (...args: T) => any): (...args: T) => boolean; + } + interface Function any> { + /** + * @see _.negate + */ + negate(): Function<(...args: Parameters) => boolean>; + } + interface FunctionChain any> { + /** + * @see _.negate + */ + negate(): FunctionChain<(...args: Parameters) => boolean>; + } + interface LoDashStatic { + /** + * Creates a function that is restricted to invoking func once. Repeat calls to the function return the value + * of the first call. The func is invoked with the this binding and arguments of the created function. + * + * @param func The function to restrict. + * @return Returns the new restricted function. + */ + once any>(func: T): T; + } + interface Function any> { + /** + * @see _.once + */ + once(): Function; + } + interface FunctionChain any> { + /** + * @see _.once + */ + once(): FunctionChain; + } + interface LoDashStatic { + /** + * Creates a function that runs each argument through a corresponding transform function. + * + * @param func The function to wrap. + * @param transforms The functions to transform arguments, specified as individual functions or arrays + * of functions. + * @return Returns the new function. + */ + overArgs(func: (...args: any[]) => any, ...transforms: Array any>>): (...args: any[]) => any; + } + interface Function { + /** + * @see _.overArgs + */ + overArgs(...transforms: Array any>>): Function<(...args: any[]) => any>; + } + interface FunctionChain { + /** + * @see _.overArgs + */ + overArgs(...transforms: Array any>>): FunctionChain<(...args: any[]) => any>; + } + interface LoDashStatic { + /** + * Creates a function that, when called, invokes func with any additional partial arguments + * prepended to those provided to the new function. This method is similar to _.bind except + * it does not alter the this binding. + * @param func The function to partially apply arguments to. + * @param args Arguments to be partially applied. + * @return The new partially applied function. + */ + partial: Partial; + } + type __ = LoDashStatic; + type Function0 = () => R; + type Function1 = (t1: T1) => R; + type Function2 = (t1: T1, t2: T2) => R; + type Function3 = (t1: T1, t2: T2, t3: T3) => R; + type Function4 = (t1: T1, t2: T2, t3: T3, t4: T4) => R; + interface Partial { + (func: Function2, plc1: __, arg2: T2): Function1; + (func: Function3, plc1: __, arg2: T2): Function2; + (func: Function3, plc1: __, plc2: __, arg3: T3): Function2; + (func: Function3, arg1: T1, plc2: __, arg3: T3): Function1; + (func: Function3, plc1: __, arg2: T2, arg3: T3): Function1; + (func: Function4, plc1: __, arg2: T2): Function3; + (func: Function4, plc1: __, plc2: __, arg3: T3): Function3; + (func: Function4, arg1: T1, plc2: __, arg3: T3): Function2; + (func: Function4, plc1: __, arg2: T2, arg3: T3): Function2; + (func: Function4, arg1: T1, arg2: T2, arg3: T3): Function1; + (func: Function4, plc1: __, plc2: __, plc3: __, arg4: T4): Function3; + (func: Function4, arg1: T1, plc2: __, plc3: __, arg4: T4): Function2; + (func: Function4, plc1: __, arg2: T2, plc3: __, arg4: T4): Function2; + (func: Function4, arg1: T1, arg2: T2, plc3: __, arg4: T4): Function1; + (func: Function4, plc1: __, plc2: __, arg3: T3, arg4: T4): Function2; + (func: Function4, arg1: T1, plc2: __, arg3: T3, arg4: T4): Function1; + (func: Function4, plc1: __, arg2: T2, arg3: T3, arg4: T4): Function1; + (func: (...ts: TS) => R): (...ts: TS) => R; + (func: (t1: T1, ...ts: TS) => R, arg1: T1): (...ts: TS) => R; + (func: (t1: T1, t2: T2, ...ts: TS) => R, t1: T1, t2: T2): (...ts: TS) => R; + (func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: T1, t2: T2, t3: T3): (...ts: TS) => R; + (func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4): (...ts: TS) => R; + placeholder: __; + } + interface Function { + /** + * @see _.partial + */ + partial(plc1: __, arg2: T2): Function< + T extends Function2 ? Function1 : + T extends Function3 ? Function2 : + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partial + */ + partial(plc1: __, plc2: __, arg3: T3): Function< + T extends Function3 ? Function2 : + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, plc2: __, arg3: T3): Function< + T extends Function3 ? Function1 : + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partial + */ + partial(plc1: __, arg2: T2, arg3: T3): Function< + T extends Function3 ? Function1 : + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partial + */ + partial(plc1: __, plc2: __, arg3: T3): Function< + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, plc2: __, plc3: __, arg4: T4): Function< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partial + */ + partial(plc1: __, arg2: T2, plc3: __, arg4: T4): Function< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, arg2: T2, plc3: __, arg4: T4): Function< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partial + */ + partial(plc1: __, plc2: __, arg3: T3, arg4: T4): Function< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, plc2: __, arg3: T3, arg4: T4): Function< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partial + */ + partial(plc1: __, arg2: T2, arg3: T3, arg4: T4): Function< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, arg2: T2, arg3: T3, arg4: T4): Function< + T extends (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: infer TS) => infer R ? (...ts: TS) => R : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, arg2: T2, arg3: T3): Function< + T extends (t1: T1, t2: T2, t3: T3, ...ts: infer TS) => infer R ? (...ts: TS) => R : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, arg2: T2): Function< + T extends (t1: T1, t2: T2, ...ts: infer TS) => infer R ? (...ts: TS) => R : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1): Function< + T extends (t1: T1, ...ts: infer TS) => infer R ? (...ts: TS) => R : + any + >; + /** + * @see _.partial + */ + partial(): Function any ? T : any>; + } + interface FunctionChain { + /** + * @see _.partial + */ + partial(plc1: __, arg2: T2): FunctionChain< + T extends Function2 ? Function1 : + T extends Function3 ? Function2 : + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partial + */ + partial(plc1: __, plc2: __, arg3: T3): FunctionChain< + T extends Function3 ? Function2 : + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, plc2: __, arg3: T3): FunctionChain< + T extends Function3 ? Function1 : + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partial + */ + partial(plc1: __, arg2: T2, arg3: T3): FunctionChain< + T extends Function3 ? Function1 : + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partial + */ + partial(plc1: __, plc2: __, arg3: T3): FunctionChain< + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, plc2: __, plc3: __, arg4: T4): FunctionChain< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partial + */ + partial(plc1: __, arg2: T2, plc3: __, arg4: T4): FunctionChain< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, arg2: T2, plc3: __, arg4: T4): FunctionChain< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partial + */ + partial(plc1: __, plc2: __, arg3: T3, arg4: T4): FunctionChain< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, plc2: __, arg3: T3, arg4: T4): FunctionChain< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partial + */ + partial(plc1: __, arg2: T2, arg3: T3, arg4: T4): FunctionChain< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, arg2: T2, arg3: T3, arg4: T4): FunctionChain< + T extends (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: infer TS) => infer R ? (...ts: TS) => R : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, arg2: T2, arg3: T3): FunctionChain< + T extends (t1: T1, t2: T2, t3: T3, ...ts: infer TS) => infer R ? (...ts: TS) => R : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1, arg2: T2): FunctionChain< + T extends (t1: T1, t2: T2, ...ts: infer TS) => infer R ? (...ts: TS) => R : + any + >; + /** + * @see _.partial + */ + partial(arg1: T1): FunctionChain< + T extends (t1: T1, ...ts: infer TS) => infer R ? (...ts: TS) => R : + any + >; + /** + * @see _.partial + */ + partial(): FunctionChain any ? T : any>; + } + interface LoDashStatic { + /** + * This method is like _.partial except that partial arguments are appended to those provided + * to the new function. + * @param func The function to partially apply arguments to. + * @param args Arguments to be partially applied. + * @return The new partially applied function. + */ + partialRight: PartialRight; + } + interface PartialRight { + (func: Function0): Function0; + (func: Function1): Function1; + (func: Function1, arg1: T1): Function0; + (func: Function2): Function2; + (func: Function2, arg1: T1, plc2: __): Function1; + (func: Function2, arg2: T2): Function1; + (func: Function2, arg1: T1, arg2: T2): Function0; + (func: Function3): Function3; + (func: Function3, arg1: T1, plc2: __, plc3: __): Function2; + (func: Function3, arg2: T2, plc3: __): Function2; + (func: Function3, arg1: T1, arg2: T2, plc3: __): Function1; + (func: Function3, arg3: T3): Function2; + (func: Function3, arg1: T1, plc2: __, arg3: T3): Function1; + (func: Function3, arg2: T2, arg3: T3): Function1; + (func: Function3, arg1: T1, arg2: T2, arg3: T3): Function0; + (func: Function4): Function4; + (func: Function4, arg1: T1, plc2: __, plc3: __, plc4: __): Function3; + (func: Function4, arg2: T2, plc3: __, plc4: __): Function3; + (func: Function4, arg1: T1, arg2: T2, plc3: __, plc4: __): Function2; + (func: Function4, arg3: T3, plc4: __): Function3; + (func: Function4, arg1: T1, plc2: __, arg3: T3, plc4: __): Function2; + (func: Function4, arg2: T2, arg3: T3, plc4: __): Function2; + (func: Function4, arg1: T1, arg2: T2, arg3: T3, plc4: __): Function1; + (func: Function4, arg4: T4): Function3; + (func: Function4, arg1: T1, plc2: __, plc3: __, arg4: T4): Function2; + (func: Function4, arg2: T2, plc3: __, arg4: T4): Function2; + (func: Function4, arg1: T1, arg2: T2, plc3: __, arg4: T4): Function1; + (func: Function4, arg3: T3, arg4: T4): Function2; + (func: Function4, arg1: T1, plc2: __, arg3: T3, arg4: T4): Function1; + (func: Function4, arg2: T2, arg3: T3, arg4: T4): Function1; + (func: Function4, arg1: T1, arg2: T2, arg3: T3, arg4: T4): Function0; + (func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any; + placeholder: __; + } + interface Function { + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __): Function< + T extends Function2 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2): Function< + T extends Function2 ? Function1 : any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __, plc3: __): Function< + T extends Function3 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2, plc3: __): Function< + T extends Function3 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, arg2: T2, plc3: __): Function< + T extends Function3 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg3: T3): Function< + T extends Function3 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __, arg3: T3): Function< + T extends Function3 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2, arg3: T3): Function< + T extends Function3 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __, plc3: __, plc4: __): Function< + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2, plc3: __, plc4: __): Function< + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, arg2: T2, plc3: __, plc4: __): Function< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg3: T3, plc4: __): Function< + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __, arg3: T3, plc4: __): Function< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2, arg3: T3, plc4: __): Function< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, arg2: T2, arg3: T3, plc4: __): Function< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg4: T4): Function< + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __, plc3: __, arg4: T4): Function< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2, plc3: __, arg4: T4): Function< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, arg2: T2, plc3: __, arg4: T4): Function< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg3: T3, arg4: T4): Function< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __, arg3: T3, arg4: T4): Function< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2, arg3: T3, arg4: T4): Function< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(...ts: TS): Function infer R ? () => R : any>; + /** + * @see _.partialRight + */ + partialRight(): Function any ? T : any>; + } + interface FunctionChain { + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __): FunctionChain< + T extends Function2 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2): FunctionChain< + T extends Function2 ? Function1 : any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __, plc3: __): FunctionChain< + T extends Function3 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2, plc3: __): FunctionChain< + T extends Function3 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, arg2: T2, plc3: __): FunctionChain< + T extends Function3 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg3: T3): FunctionChain< + T extends Function3 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __, arg3: T3): FunctionChain< + T extends Function3 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2, arg3: T3): FunctionChain< + T extends Function3 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __, plc3: __, plc4: __): FunctionChain< + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2, plc3: __, plc4: __): FunctionChain< + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, arg2: T2, plc3: __, plc4: __): FunctionChain< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg3: T3, plc4: __): FunctionChain< + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __, arg3: T3, plc4: __): FunctionChain< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2, arg3: T3, plc4: __): FunctionChain< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, arg2: T2, arg3: T3, plc4: __): FunctionChain< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg4: T4): FunctionChain< + T extends Function4 ? Function3 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __, plc3: __, arg4: T4): FunctionChain< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2, plc3: __, arg4: T4): FunctionChain< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, arg2: T2, plc3: __, arg4: T4): FunctionChain< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg3: T3, arg4: T4): FunctionChain< + T extends Function4 ? Function2 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg1: T1, plc2: __, arg3: T3, arg4: T4): FunctionChain< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(arg2: T2, arg3: T3, arg4: T4): FunctionChain< + T extends Function4 ? Function1 : + any + >; + /** + * @see _.partialRight + */ + partialRight(...ts: TS): FunctionChain infer R ? () => R : any>; + /** + * @see _.partialRight + */ + partialRight(): FunctionChain any ? T : any>; + } + interface LoDashStatic { + /** + * Creates a function that invokes func with arguments arranged according to the specified indexes where the + * argument value at the first index is provided as the first argument, the argument value at the second index + * is provided as the second argument, and so on. + * @param func The function to rearrange arguments for. + * @param indexes The arranged argument indexes, specified as individual indexes or arrays of indexes. + * @return Returns the new function. + */ + rearg(func: (...args: any[]) => any, ...indexes: Array>): (...args: any[]) => any; + } + interface Function { + /** + * @see _.rearg + */ + rearg(...indexes: Array>): Function<(...args: any[]) => any>; + } + interface FunctionChain { + /** + * @see _.rearg + */ + rearg(...indexes: Array>): FunctionChain<(...args: any[]) => any>; + } + interface LoDashStatic { + /** + * Creates a function that invokes func with the this binding of the created function and arguments from start + * and beyond provided as an array. + * + * Note: This method is based on the rest parameter. + * + * @param func The function to apply a rest parameter to. + * @param start The start position of the rest parameter. + * @return Returns the new function. + */ + rest(func: (...args: any[]) => any, start?: number): (...args: any[]) => any; + } + interface Function any> { + /** + * @see _.rest + */ + rest(start?: number): Function<(...args: any[]) => any>; + } + interface FunctionChain any> { + /** + * @see _.rest + */ + rest(start?: number): FunctionChain<(...args: any[]) => any>; + } + interface LoDashStatic { + /** + * Creates a function that invokes func with the this binding of the created function and an array of arguments + * much like Function#apply. + * + * Note: This method is based on the spread operator. + * + * @param func The function to spread arguments over. + * @return Returns the new function. + */ + spread(func: (...args: any[]) => TResult, start?: number): (...args: any[]) => TResult; + } + interface Function { + /** + * @see _.spread + */ + spread(start?: number): Function<(...args: any[]) => ReturnType>; + } + interface FunctionChain { + /** + * @see _.spread + */ + spread(start?: number): FunctionChain<(...args: any[]) => ReturnType>; + } + interface ThrottleSettings { + /** + * @see _.leading + */ + leading?: boolean; + /** + * @see _.trailing + */ + trailing?: boolean; + } + interface LoDashStatic { + /** + * Creates a throttled function that only invokes func at most once per every wait milliseconds. The throttled + * function comes with a cancel method to cancel delayed invocations and a flush method to immediately invoke + * them. Provide an options object to indicate that func should be invoked on the leading and/or trailing edge + * of the wait timeout. Subsequent calls to the throttled function return the result of the last func call. + * + * Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only if + * the the throttled function is invoked more than once during the wait timeout. + * + * @param func The function to throttle. + * @param wait The number of milliseconds to throttle invocations to. + * @param options The options object. + * @param options.leading Specify invoking on the leading edge of the timeout. + * @param options.trailing Specify invoking on the trailing edge of the timeout. + * @return Returns the new throttled function. + */ + throttle any>(func: T, wait?: number, options?: ThrottleSettings): T & Cancelable; + } + interface Function any> { + /** + * @see _.throttle + */ + throttle(wait?: number, options?: ThrottleSettings): Function; + } + interface FunctionChain any> { + /** + * @see _.throttle + */ + throttle(wait?: number, options?: ThrottleSettings): FunctionChain; + } + interface LoDashStatic { + /** + * Creates a function that accepts up to one argument, ignoring any + * additional arguments. + * + * @category Function + * @param func The function to cap arguments for. + * @returns Returns the new function. + * @example + * + * _.map(['6', '8', '10'], _.unary(parseInt)); + * // => [6, 8, 10] + */ + unary(func: (arg1: T, ...args: any[]) => TResult): (arg1: T) => TResult; + } + interface Function { + /** + * @see _.unary + */ + unary(): Function<(arg1: Parameters['0']) => ReturnType>; + } + interface FunctionChain { + /** + * @see _.unary + */ + unary(): FunctionChain<(arg1: Parameters['0']) => ReturnType>; + } + interface LoDashStatic { + /** + * Creates a function that provides value to the wrapper function as its first argument. Any additional + * arguments provided to the function are appended to those provided to the wrapper function. The wrapper is + * invoked with the this binding of the created function. + * + * @param value The value to wrap. + * @param wrapper The wrapper function. + * @return Returns the new function. + */ + wrap(value: T, wrapper: (value: T, ...args: TArgs[]) => TResult): (...args: TArgs[]) => TResult; + } + interface LoDashImplicitWrapper { + /** + * @see _.wrap + */ + wrap(wrapper: (value: TValue, ...args: TArgs[]) => TResult): Function<(...args: TArgs[]) => TResult>; + } + interface LoDashExplicitWrapper { + /** + * @see _.wrap + */ + wrap(wrapper: (value: TValue, ...args: TArgs[]) => TResult): FunctionChain<(...args: TArgs[]) => TResult>; + } +} diff --git a/types/lodash/ts3.1/common/lang.d.ts b/types/lodash/ts3.1/common/lang.d.ts new file mode 100644 index 0000000000..3d18086353 --- /dev/null +++ b/types/lodash/ts3.1/common/lang.d.ts @@ -0,0 +1,1694 @@ +import _ = require("../index"); +// tslint:disable-next-line:strict-export-declare-modifiers +type GlobalFunction = Function; +declare module "../index" { + type FunctionBase = GlobalFunction; + interface LoDashStatic { + /** + * Casts value as an array if it’s not one. + * + * @param value The value to inspect. + * @return Returns the cast array. + */ + castArray(value?: Many): T[]; + } + interface Collection { + /** + * @see _.castArray + */ + castArray(): Collection; + } + interface String { + /** + * @see _.castArray + */ + castArray(): Collection; + } + interface Object { + /** + * @see _.castArray + */ + castArray(): Collection; + } + interface Function any> { + /** + * @see _.castArray + */ + castArray(): Collection; + } + interface Primitive { + /** + * @see _.castArray + */ + castArray(): Collection; + } + interface CollectionChain { + /** + * @see _.castArray + */ + castArray(): CollectionChain; + } + interface StringChain { + /** + * @see _.castArray + */ + castArray(): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.castArray + */ + castArray(): CollectionChain; + } + interface ObjectChain { + /** + * @see _.castArray + */ + castArray(): CollectionChain; + } + interface FunctionChain any> { + /** + * @see _.castArray + */ + castArray(): CollectionChain; + } + interface PrimitiveChain { + /** + * @see _.castArray + */ + castArray(): CollectionChain; + } + + interface LoDashStatic { + /** + * Creates a shallow clone of value. + * + * Note: This method is loosely based on the structured clone algorithm and supports cloning arrays, + * array buffers, booleans, date objects, maps, numbers, Object objects, regexes, sets, strings, symbols, + * and typed arrays. The own enumerable properties of arguments objects are cloned as plain objects. An empty + * object is returned for uncloneable values such as error objects, functions, DOM nodes, and WeakMaps. + * + * @param value The value to clone. + * @return Returns the cloned value. + */ + clone(value: T): T; + } + + interface LoDashImplicitWrapper { + /** + * @see _.clone + */ + clone(): TValue; + /** + * @see _.cloneDeep + */ + cloneDeep(): TValue; + /** + * @see _.cloneDeepWith + */ + cloneDeepWith(customizer: CloneDeepWithCustomizer): any; + /** + * @see _.cloneDeepWith + */ + cloneDeepWith(): TValue; + /** + * @see _.cloneWith + */ + cloneWith(customizer: CloneWithCustomizer): TResult; + /** + * @see _.cloneWith + */ + cloneWith(customizer: CloneWithCustomizer): TResult | TValue; + /** + * @see _.cloneWith + */ + cloneWith(): TValue; + } + interface LoDashExplicitWrapper { + /** + * @see _.clone + */ + clone(): this; + /** + * @see _.cloneDeep + */ + cloneDeep(): this; + /** + * @see _.cloneDeepWith + */ + cloneDeepWith(customizer: CloneDeepWithCustomizer): LoDashExplicitWrapper; + /** + * @see _.cloneDeepWith + */ + cloneDeepWith(): this; + /** + * @see _.cloneWith + */ + cloneWith(customizer: CloneWithCustomizer): ExpChain; + /** + * @see _.cloneWith + */ + cloneWith(customizer: CloneWithCustomizer): ExpChain; + /** + * @see _.cloneWith + */ + cloneWith(): this; + } + + interface LoDashStatic { + /** + * This method is like _.clone except that it recursively clones value. + * + * @param value The value to recursively clone. + * @return Returns the deep cloned value. + */ + cloneDeep(value: T): T; + } + type CloneDeepWithCustomizer = (value: any, key: number | string | undefined, object: TObject | undefined, stack: any) => any; + interface LoDashStatic { + /** + * This method is like _.cloneWith except that it recursively clones value. + * + * @param value The value to recursively clone. + * @param customizer The function to customize cloning. + * @return Returns the deep cloned value. + */ + cloneDeepWith(value: T, customizer: CloneDeepWithCustomizer): any; + /** + * @see _.cloneDeepWith + */ + cloneDeepWith(value: T): T; + } + type CloneWithCustomizer = (value: TValue, key: number | string | undefined, object: any, stack: any) => TResult; + interface LoDashStatic { + /** + * This method is like _.clone except that it accepts customizer which is invoked to produce the cloned value. + * If customizer returns undefined cloning is handled by the method instead. + * + * @param value The value to clone. + * @param customizer The function to customize cloning. + * @return Returns the cloned value. + */ + cloneWith(value: T, customizer: CloneWithCustomizer): TResult; + /** + * @see _.cloneWith + */ + cloneWith(value: T, customizer: CloneWithCustomizer): TResult | T; + /** + * @see _.cloneWith + */ + cloneWith(value: T): T; + } + interface LoDashStatic { + /** + * Checks if object conforms to source by invoking the predicate properties of source with the + * corresponding property values of object. + * + * Note: This method is equivalent to _.conforms when source is partially applied. + */ + conformsTo(object: T, source: ConformsPredicateObject): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.conformsTo + */ + conformsTo(source: ConformsPredicateObject): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.conformsTo + */ + conformsTo(source: ConformsPredicateObject): PrimitiveChain; + } + type CondPair = [(val: T) => boolean, (val: T) => R]; + interface LoDashStatic { + /** + * Performs a [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @category Lang + * @param value The value to compare. + * @param other The other value to compare. + * @returns Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'user': 'fred' }; + * var other = { 'user': 'fred' }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ + eq(value: any, other: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.eq + */ + eq(other: any): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.eq + */ + eq(other: any): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is greater than other. + * + * @param value The value to compare. + * @param other The other value to compare. + * @return Returns true if value is greater than other, else false. + */ + gt(value: any, other: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.gt + */ + gt(other: any): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.gt + */ + gt(other: any): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is greater than or equal to other. + * + * @param value The value to compare. + * @param other The other value to compare. + * @return Returns true if value is greater than or equal to other, else false. + */ + gte(value: any, other: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.gte + */ + gte(other: any): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.gte + */ + gte(other: any): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as an arguments object. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isArguments(value?: any): value is IArguments; + } + interface LoDashImplicitWrapper { + /** + * @see _.isArguments + */ + isArguments(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isArguments + */ + isArguments(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as an Array object. + * @param value The value to check. + * + * @return Returns true if value is correctly classified, else false. + */ + isArray(value?: any): value is any[]; + /** + * @see _.isArray + */ + isArray(value?: any): value is any[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.isArray + */ + isArray(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isArray + */ + isArray(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as an ArrayBuffer object. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isArrayBuffer(value?: any): value is ArrayBuffer; + } + interface LoDashImplicitWrapper { + /** + * @see _.isArrayBuffer + */ + isArrayBuffer(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isArrayBuffer + */ + isArrayBuffer(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @category Lang + * @param value The value to check. + * @returns Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ + isArrayLike(t: T): boolean; + /** + * @see _.isArrayLike + */ + isArrayLike(value: ((...args: any[]) => any) | null | undefined): value is never; + /** + * @see _.isArrayLike + */ + isArrayLike(value: any): value is { length: number }; + } + interface LoDashImplicitWrapper { + /** + * @see _.isArrayLike + */ + isArrayLike(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isArrayLike + */ + isArrayLike(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @category Lang + * @param value The value to check. + * @returns Returns `true` if `value` is an array-like object, else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false + */ + isArrayLikeObject(value: T): boolean; + // tslint:disable-next-line:ban-types (type guard doesn't seem to work correctly without the Function type) + /** + * @see _.isArrayLikeObject + */ + isArrayLikeObject(value: ((...args: any[]) => any) | FunctionBase | string | boolean | number | null | undefined): value is never; + /** + * @see _.isArrayLikeObject + */ + isArrayLikeObject(value: any): value is object & { length: number }; + } + interface LoDashImplicitWrapper { + /** + * @see _.isArrayLikeObject + */ + isArrayLikeObject(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isArrayLikeObject + */ + isArrayLikeObject(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as a boolean primitive or object. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isBoolean(value?: any): value is boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isBoolean + */ + isBoolean(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isBoolean + */ + isBoolean(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is a buffer. + * + * @param value The value to check. + * @return Returns true if value is a buffer, else false. + */ + isBuffer(value?: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isBuffer + */ + isBuffer(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isBuffer + */ + isBuffer(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as a Date object. + * @param value The value to check. + * + * @return Returns true if value is correctly classified, else false. + */ + isDate(value?: any): value is Date; + } + interface LoDashImplicitWrapper { + /** + * @see _.isDate + */ + isDate(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isDate + */ + isDate(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is a DOM element. + * + * @param value The value to check. + * @return Returns true if value is a DOM element, else false. + */ + isElement(value?: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isElement + */ + isElement(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isElement + */ + isElement(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is empty. A value is considered empty unless it’s an arguments object, array, string, or + * jQuery-like collection with a length greater than 0 or an object with own enumerable properties. + * + * @param value The value to inspect. + * @return Returns true if value is empty, else false. + */ + isEmpty(value?: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isEmpty + */ + isEmpty(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isEmpty + */ + isEmpty(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Performs a deep comparison between two values to determine if they are + * equivalent. + * + * **Note:** This method supports comparing arrays, array buffers, booleans, + * date objects, error objects, maps, numbers, `Object` objects, regexes, + * sets, strings, symbols, and typed arrays. `Object` objects are compared + * by their own, not inherited, enumerable properties. Functions and DOM + * nodes are **not** supported. + * + * @category Lang + * @param value The value to compare. + * @param other The other value to compare. + * @returns Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'user': 'fred' }; + * var other = { 'user': 'fred' }; + * + * _.isEqual(object, other); + * // => true + * + * object === other; + * // => false + */ + isEqual(value: any, other: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isEqual + */ + isEqual(other: any): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isEqual + */ + isEqual(other: any): PrimitiveChain; + } + + type IsEqualCustomizer = (value: any, other: any, indexOrKey: PropertyName | undefined, parent: any, otherParent: any, stack: any) => boolean | undefined; + interface LoDashStatic { + /** + * This method is like `_.isEqual` except that it accepts `customizer` which is + * invoked to compare values. If `customizer` returns `undefined` comparisons are + * handled by the method instead. The `customizer` is invoked with up to seven arguments: + * (objValue, othValue [, index|key, object, other, stack]). + * + * @category Lang + * @param value The value to compare. + * @param other The other value to compare. + * @param [customizer] The function to customize comparisons. + * @returns Returns `true` if the values are equivalent, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, othValue) { + * if (isGreeting(objValue) && isGreeting(othValue)) { + * return true; + * } + * } + * + * var array = ['hello', 'goodbye']; + * var other = ['hi', 'goodbye']; + * + * _.isEqualWith(array, other, customizer); + * // => true + */ + isEqualWith(value: any, other: any, customizer?: IsEqualCustomizer): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isEqualWith + */ + isEqualWith(other: any, customizer?: IsEqualCustomizer): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isEqualWith + */ + isEqualWith(other: any, customizer?: IsEqualCustomizer): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is an Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, or URIError + * object. + * + * @param value The value to check. + * @return Returns true if value is an error object, else false. + */ + isError(value: any): value is Error; + } + interface LoDashImplicitWrapper { + /** + * @see _.isError + */ + isError(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isError + */ + isError(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is a finite primitive number. + * + * Note: This method is based on Number.isFinite. + * + * @param value The value to check. + * @return Returns true if value is a finite number, else false. + */ + isFinite(value?: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isFinite + */ + isFinite(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isFinite + */ + isFinite(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is a callable function. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isFunction(value: any): value is (...args: any[]) => any; + } + interface LoDashImplicitWrapper { + /** + * @see _.isFunction + */ + isFunction(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isFunction + */ + isFunction(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if `value` is an integer. + * + * **Note:** This method is based on [`Number.isInteger`](https://mdn.io/Number/isInteger). + * + * @category Lang + * @param value The value to check. + * @returns Returns `true` if `value` is an integer, else `false`. + * @example + * + * _.isInteger(3); + * // => true + * + * _.isInteger(Number.MIN_VALUE); + * // => false + * + * _.isInteger(Infinity); + * // => false + * + * _.isInteger('3'); + * // => false + */ + isInteger(value?: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isInteger + */ + isInteger(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isInteger + */ + isInteger(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if `value` is a valid array-like length. + * + * **Note:** This function is loosely based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength). + * + * @category Lang + * @param value The value to check. + * @returns Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ + isLength(value?: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isLength + */ + isLength(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isLength + */ + isLength(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as a Map object. + * + * @param value The value to check. + * @returns Returns true if value is correctly classified, else false. + */ + isMap(value?: any): value is Map; + } + interface LoDashImplicitWrapper { + /** + * @see _.isMap + */ + isMap(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isMap + */ + isMap(): PrimitiveChain; + } + + type isMatchCustomizer = (value: any, other: any, indexOrKey?: PropertyName) => boolean; + interface LoDashStatic { + /** + * Performs a deep comparison between `object` and `source` to determine if + * `object` contains equivalent property values. + * + * **Note:** This method supports comparing the same values as `_.isEqual`. + * + * @category Lang + * @param object The object to inspect. + * @param source The object of property values to match. + * @returns Returns `true` if `object` is a match, else `false`. + * @example + * + * var object = { 'user': 'fred', 'age': 40 }; + * + * _.isMatch(object, { 'age': 40 }); + * // => true + * + * _.isMatch(object, { 'age': 36 }); + * // => false + */ + isMatch(object: object, source: object): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isMatch + */ + isMatch(source: object): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isMatch + */ + isMatch(source: object): PrimitiveChain; + } + + type isMatchWithCustomizer = (value: any, other: any, indexOrKey: PropertyName, object: object, source: object) => boolean; + interface LoDashStatic { + /** + * This method is like `_.isMatch` except that it accepts `customizer` which + * is invoked to compare values. If `customizer` returns `undefined` comparisons + * are handled by the method instead. The `customizer` is invoked with three + * arguments: (objValue, srcValue, index|key, object, source). + * + * @category Lang + * @param object The object to inspect. + * @param source The object of property values to match. + * @param [customizer] The function to customize comparisons. + * @returns Returns `true` if `object` is a match, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, srcValue) { + * if (isGreeting(objValue) && isGreeting(srcValue)) { + * return true; + * } + * } + * + * var object = { 'greeting': 'hello' }; + * var source = { 'greeting': 'hi' }; + * + * _.isMatchWith(object, source, customizer); + * // => true + */ + isMatchWith(object: object, source: object, customizer: isMatchWithCustomizer): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isMatchWith + */ + isMatchWith(source: object, customizer: isMatchWithCustomizer): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isMatchWith + */ + isMatchWith(source: object, customizer: isMatchWithCustomizer): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is NaN. + * + * Note: This method is not the same as isNaN which returns true for undefined and other non-numeric values. + * + * @param value The value to check. + * @return Returns true if value is NaN, else false. + */ + isNaN(value?: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isNaN + */ + isNaN(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isNaN + */ + isNaN(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is a native function. + * @param value The value to check. + * + * @retrun Returns true if value is a native function, else false. + */ + isNative(value: any): value is (...args: any[]) => any; + } + interface LoDashImplicitWrapper { + /** + * @see _.isNative + */ + isNative(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isNative + */ + isNative(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if `value` is `null` or `undefined`. + * + * @category Lang + * @param value The value to check. + * @returns Returns `true` if `value` is nullish, else `false`. + * @example + * + * _.isNil(null); + * // => true + * + * _.isNil(void 0); + * // => true + * + * _.isNil(NaN); + * // => false + */ + isNil(value: any): value is null | undefined; + } + interface LoDashImplicitWrapper { + /** + * @see _.isNil + */ + isNil(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isNil + */ + isNil(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is null. + * + * @param value The value to check. + * @return Returns true if value is null, else false. + */ + isNull(value: any): value is null; + } + interface LoDashImplicitWrapper { + /** + * @see _.isNull + */ + isNull(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isNull + */ + isNull(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as a Number primitive or object. + * + * Note: To exclude Infinity, -Infinity, and NaN, which are classified as numbers, use the _.isFinite method. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isNumber(value?: any): value is number; + } + interface LoDashImplicitWrapper { + /** + * @see _.isNumber + */ + isNumber(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isNumber + */ + isNumber(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is the language type of Object. (e.g. arrays, functions, objects, regexes, new Number(0), + * and new String('')) + * + * @param value The value to check. + * @return Returns true if value is an object, else false. + */ + isObject(value?: any): value is object; + } + interface LoDashImplicitWrapper { + /** + * @see _.isObject + */ + isObject(): this is LoDashImplicitWrapper; + } + interface LoDashExplicitWrapper { + /** + * @see _.isObject + */ + isObject(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @category Lang + * @param value The value to check. + * @returns Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ + isObjectLike(value?: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isObjectLike + */ + isObjectLike(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isObjectLike + */ + isObjectLike(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is a plain object, that is, an object created by the Object constructor or one with a + * [[Prototype]] of null. + * + * Note: This method assumes objects created by the Object constructor have no inherited enumerable properties. + * + * @param value The value to check. + * @return Returns true if value is a plain object, else false. + */ + isPlainObject(value?: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isPlainObject + */ + isPlainObject(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isPlainObject + */ + isPlainObject(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as a RegExp object. + * @param value The value to check. + * + * @return Returns true if value is correctly classified, else false. + */ + isRegExp(value?: any): value is RegExp; + } + interface LoDashImplicitWrapper { + /** + * @see _.isRegExp + */ + isRegExp(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isRegExp + */ + isRegExp(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754 + * double precision number which isn't the result of a rounded unsafe integer. + * + * **Note:** This method is based on [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger). + * + * @category Lang + * @param value The value to check. + * @returns Returns `true` if `value` is a safe integer, else `false`. + * @example + * + * _.isSafeInteger(3); + * // => true + * + * _.isSafeInteger(Number.MIN_VALUE); + * // => false + * + * _.isSafeInteger(Infinity); + * // => false + * + * _.isSafeInteger('3'); + * // => false + */ + isSafeInteger(value: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isSafeInteger + */ + isSafeInteger(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isSafeInteger + */ + isSafeInteger(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as a Set object. + * + * @param value The value to check. + * @returns Returns true if value is correctly classified, else false. + */ + isSet(value?: any): value is Set; + } + interface LoDashImplicitWrapper { + /** + * @see _.isSet + */ + isSet(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isSet + */ + isSet(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as a String primitive or object. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isString(value?: any): value is string; + } + interface LoDashImplicitWrapper { + /** + * @see _.isString + */ + isString(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isString + */ + isString(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @category Lang + * @param value The value to check. + * @returns Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ + isSymbol(value: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isSymbol + */ + isSymbol(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isSymbol + */ + isSymbol(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as a typed array. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isTypedArray(value: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.isTypedArray + */ + isTypedArray(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isTypedArray + */ + isTypedArray(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is undefined. + * + * @param value The value to check. + * @return Returns true if value is undefined, else false. + */ + isUndefined(value: any): value is undefined; + } + interface LoDashImplicitWrapper { + /** + * @see _.isUndefined + */ + isUndefined(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isUndefined + */ + isUndefined(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as a WeakMap object. + * + * @param value The value to check. + * @returns Returns true if value is correctly classified, else false. + */ + isWeakMap(value?: any): value is WeakMap; + } + interface LoDashImplicitWrapper { + /** + * @see _.isWeakMap + */ + isWeakMap(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isWeakMap + */ + isWeakMap(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is classified as a WeakSet object. + * + * @param value The value to check. + * @returns Returns true if value is correctly classified, else false. + */ + isWeakSet(value?: any): value is WeakSet; + } + interface LoDashImplicitWrapper { + /** + * @see _.isWeakSet + */ + isWeakSet(): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.isWeakSet + */ + isWeakSet(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is less than other. + * + * @param value The value to compare. + * @param other The other value to compare. + * @return Returns true if value is less than other, else false. + */ + lt(value: any, other: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.lt + */ + lt(other: any): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.lt + */ + lt(other: any): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Checks if value is less than or equal to other. + * + * @param value The value to compare. + * @param other The other value to compare. + * @return Returns true if value is less than or equal to other, else false. + */ + lte(value: any, other: any): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.lte + */ + lte(other: any): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.lte + */ + lte(other: any): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Converts value to an array. + * + * @param value The value to convert. + * @return Returns the converted array. + */ + toArray(value: Dictionary | NumericDictionary | null | undefined): T[]; + /** + * @see _.toArray + */ + toArray(value: T): Array; + /** + * @see _.toArray + */ + toArray(): any[]; + } + interface String { + /** + * @see _.toArray + */ + toArray(): Collection; + } + interface Collection { + /** + * @see _.toArray + */ + toArray(): Collection; + } + interface Object { + /** + * @see _.toArray + */ + toArray(): Collection; + } + interface StringChain { + /** + * @see _.toArray + */ + toArray(): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.toArray + */ + toArray(): CollectionChain; + } + interface CollectionChain { + /** + * @see _.toArray + */ + toArray(): CollectionChain; + } + interface ObjectChain { + /** + * @see _.toArray + */ + toArray(): CollectionChain; + } + + interface LoDashStatic { + /** + * Converts `value` to a finite number. + * + * @since 4.12.0 + * @category Lang + * @param value The value to convert. + * @returns Returns the converted number. + * @example + * + * _.toFinite(3.2); + * // => 3.2 + * + * _.toFinite(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toFinite(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toFinite('3.2'); + * // => 3.2 + */ + toFinite(value: any): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.toFinite + */ + toFinite(): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.toFinite + */ + toFinite(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Converts `value` to an integer. + * + * **Note:** This function is loosely based on [`ToInteger`](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger). + * + * @category Lang + * @param value The value to convert. + * @returns Returns the converted integer. + * @example + * + * _.toInteger(3); + * // => 3 + * + * _.toInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toInteger(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toInteger('3'); + * // => 3 + */ + toInteger(value: any): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.toInteger + */ + toInteger(): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.toInteger + */ + toInteger(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Converts `value` to an integer suitable for use as the length of an + * array-like object. + * + * **Note:** This method is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength). + * + * @category Lang + * @param value The value to convert. + * @return Returns the converted integer. + * @example + * + * _.toLength(3); + * // => 3 + * + * _.toLength(Number.MIN_VALUE); + * // => 0 + * + * _.toLength(Infinity); + * // => 4294967295 + * + * _.toLength('3'); + * // => 3 + */ + toLength(value: any): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.toLength + */ + toLength(): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.toLength + */ + toLength(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Converts `value` to a number. + * + * @category Lang + * @param value The value to process. + * @returns Returns the number. + * @example + * + * _.toNumber(3); + * // => 3 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3'); + * // => 3 + */ + toNumber(value: any): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.toNumber + */ + toNumber(): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.toNumber + */ + toNumber(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Converts value to a plain object flattening inherited enumerable properties of value to own properties + * of the plain object. + * + * @param value The value to convert. + * @return Returns the converted plain object. + */ + toPlainObject(value?: any): any; + } + interface LoDashImplicitWrapper { + /** + * @see _.toPlainObject + */ + toPlainObject(): Object; + } + interface LoDashExplicitWrapper { + /** + * @see _.toPlainObject + */ + toPlainObject(): ObjectChain; + } + + interface LoDashStatic { + /** + * Converts `value` to a safe integer. A safe integer can be compared and + * represented correctly. + * + * @category Lang + * @param value The value to convert. + * @returns Returns the converted integer. + * @example + * + * _.toSafeInteger(3); + * // => 3 + * + * _.toSafeInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toSafeInteger(Infinity); + * // => 9007199254740991 + * + * _.toSafeInteger('3'); + * // => 3 + */ + toSafeInteger(value: any): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.toSafeInteger + */ + toSafeInteger(): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.toSafeInteger + */ + toSafeInteger(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Converts `value` to a string if it's not one. An empty string is returned + * for `null` and `undefined` values. The sign of `-0` is preserved. + * + * @category Lang + * @param value The value to process. + * @returns Returns the string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ + toString(value: any): string; + } +} diff --git a/types/lodash/ts3.1/common/math.d.ts b/types/lodash/ts3.1/common/math.d.ts new file mode 100644 index 0000000000..d68d3ff6e0 --- /dev/null +++ b/types/lodash/ts3.1/common/math.d.ts @@ -0,0 +1,405 @@ +import _ = require("../index"); +declare module "../index" { + interface LoDashStatic { + /** + * Adds two numbers. + * + * @param augend The first number to add. + * @param addend The second number to add. + * @return Returns the sum. + */ + add(augend: number, addend: number): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.add + */ + add(addend: number): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.add + */ + add(addend: number): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Calculates n rounded up to precision. + * + * @param n The number to round up. + * @param precision The precision to round up to. + * @return Returns the rounded up number. + */ + ceil(n: number, precision?: number): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.ceil + */ + ceil(precision?: number): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.ceil + */ + ceil(precision?: number): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Divide two numbers. + * + * @param dividend The first number in a division. + * @param divisor The second number in a division. + * @returns Returns the quotient. + */ + divide(dividend: number, divisor: number): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.divide + */ + divide(divisor: number): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.divide + */ + divide(divisor: number): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Calculates n rounded down to precision. + * + * @param n The number to round down. + * @param precision The precision to round down to. + * @return Returns the rounded down number. + */ + floor(n: number, precision?: number): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.floor + */ + floor(precision?: number): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.floor + */ + floor(precision?: number): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Computes the maximum value of `array`. If `array` is empty or falsey + * `undefined` is returned. + * + * @category Math + * @param array The array to iterate over. + * @returns Returns the maximum value. + */ + max(collection: List | null | undefined): T | undefined; + } + interface Collection { + /** + * @see _.max + */ + max(): T | undefined; + } + interface CollectionChain { + /** + * @see _.max + */ + max(): ExpChain; + } + + interface LoDashStatic { + /** + * This method is like `_.max` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the criterion by which + * the value is ranked. The iteratee is invoked with one argument: (value). + * + * @category Math + * @param array The array to iterate over. + * @param iteratee The iteratee invoked per element. + * @returns Returns the maximum value. + * @example + * + * var objects = [{ 'n': 1 }, { 'n': 2 }]; + * + * _.maxBy(objects, function(o) { return o.a; }); + * // => { 'n': 2 } + * + * // using the `_.property` iteratee shorthand + * _.maxBy(objects, 'n'); + * // => { 'n': 2 } + */ + maxBy(collection: List | null | undefined, iteratee?: ValueIteratee): T | undefined; + } + interface Collection { + /** + * @see _.maxBy + */ + maxBy(iteratee?: ValueIteratee): T | undefined; + } + interface CollectionChain { + /** + * @see _.maxBy + */ + maxBy(iteratee?: ValueIteratee): ExpChain; + } + + interface LoDashStatic { + /** + * Computes the mean of the values in `array`. + * + * @category Math + * @param array The array to iterate over. + * @returns Returns the mean. + * @example + * + * _.mean([4, 2, 8, 6]); + * // => 5 + */ + mean(collection: List | null | undefined): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.mean + */ + mean(): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.mean + */ + mean(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Computes the mean of the provided propties of the objects in the `array` + * + * @category Math + * @param array The array to iterate over. + * @param iteratee The iteratee invoked per element. + * @returns Returns the mean. + * @example + * + * _.mean([{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }], 'n'); + * // => 5 + */ + meanBy(collection: List | null | undefined, iteratee?: ValueIteratee): number; + } + interface Collection { + /** + * @see _.meanBy + */ + meanBy(iteratee?: ValueIteratee): number; + } + interface CollectionChain { + /** + * @see _.meanBy + */ + meanBy(iteratee?: ValueIteratee): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Computes the minimum value of `array`. If `array` is empty or falsey + * `undefined` is returned. + * + * @category Math + * @param array The array to iterate over. + * @returns Returns the minimum value. + */ + min(collection: List | null | undefined): T | undefined; + } + interface Collection { + /** + * @see _.min + */ + min(): T | undefined; + } + interface CollectionChain { + /** + * @see _.min + */ + min(): ExpChain; + } + + interface LoDashStatic { + /** + * This method is like `_.min` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the criterion by which + * the value is ranked. The iteratee is invoked with one argument: (value). + * + * @category Math + * @param array The array to iterate over. + * @param iteratee The iteratee invoked per element. + * @returns Returns the minimum value. + * @example + * + * var objects = [{ 'n': 1 }, { 'n': 2 }]; + * + * _.minBy(objects, function(o) { return o.a; }); + * // => { 'n': 1 } + * + * // using the `_.property` iteratee shorthand + * _.minBy(objects, 'n'); + * // => { 'n': 1 } + */ + minBy(collection: List | null | undefined, iteratee?: ValueIteratee): T | undefined; + } + interface Collection { + /** + * @see _.minBy + */ + minBy(iteratee?: ValueIteratee): T | undefined; + } + interface CollectionChain { + /** + * @see _.minBy + */ + minBy(iteratee?: ValueIteratee): ExpChain; + } + + interface LoDashStatic { + /** + * Multiply two numbers. + * @param multiplier The first number in a multiplication. + * @param multiplicand The second number in a multiplication. + * @returns Returns the product. + */ + multiply(multiplier: number, multiplicand: number): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.multiply + */ + multiply(multiplicand: number): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.multiply + */ + multiply(multiplicand: number): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Calculates n rounded to precision. + * + * @param n The number to round. + * @param precision The precision to round to. + * @return Returns the rounded number. + */ + round(n: number, precision?: number): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.round + */ + round(precision?: number): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.round + */ + round(precision?: number): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Subtract two numbers. + * + * @category Math + * @param minuend The first number in a subtraction. + * @param subtrahend The second number in a subtraction. + * @returns Returns the difference. + * @example + * + * _.subtract(6, 4); + * // => 2 + */ + subtract(minuend: number, subtrahend: number): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.subtract + */ + subtract(subtrahend: number): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.subtract + */ + subtract(subtrahend: number): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Computes the sum of the values in `array`. + * + * @category Math + * @param array The array to iterate over. + * @returns Returns the sum. + * @example + * + * _.sum([4, 2, 8, 6]); + * // => 20 + */ + sum(collection: List | null | undefined): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.sum + */ + sum(): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.sum + */ + sum(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * This method is like `_.sum` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the value to be summed. + * The iteratee is invoked with one argument: (value). + * + * @category Math + * @param array The array to iterate over. + * @param [iteratee=_.identity] The iteratee invoked per element. + * @returns Returns the sum. + * @example + * + * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }]; + * + * _.sumBy(objects, function(o) { return o.n; }); + * // => 20 + * + * // using the `_.property` iteratee shorthand + * _.sumBy(objects, 'n'); + * // => 20 + */ + sumBy(collection: List | null | undefined, iteratee?: ((value: T) => number) | string): number; + } + interface Collection { + /** + * @see _.sumBy + */ + sumBy(iteratee?: ((value: T) => number) | string): number; + } + interface CollectionChain { + /** + * @see _.sumBy + */ + sumBy(iteratee?: ((value: T) => number) | string): PrimitiveChain; + } +} diff --git a/types/lodash/ts3.1/common/number.d.ts b/types/lodash/ts3.1/common/number.d.ts new file mode 100644 index 0000000000..ad9ce72ac4 --- /dev/null +++ b/types/lodash/ts3.1/common/number.d.ts @@ -0,0 +1,131 @@ +import _ = require("../index"); +declare module "../index" { + // clamp + interface LoDashStatic { + /** + * Clamps `number` within the inclusive `lower` and `upper` bounds. + * + * @category Number + * @param number The number to clamp. + * @param [lower] The lower bound. + * @param upper The upper bound. + * @returns Returns the clamped number. + * @example + * + * _.clamp(-10, -5, 5); + * // => -5 + * + * _.clamp(10, -5, 5); + * // => 5 + * Clamps `number` within the inclusive `lower` and `upper` bounds. + * + * @category Number + * @param number The number to clamp. + * @param [lower] The lower bound. + * @param upper The upper bound. + * @returns Returns the clamped number. + * @example + * + * _.clamp(-10, -5, 5); + * // => -5 + * + * _.clamp(10, -5, 5); + */ + clamp(number: number, lower: number, upper: number): number; + /** + * @see _.clamp + */ + clamp(number: number, upper: number): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.clamp + */ + clamp(lower: number, upper: number): number; + /** + * @see _.clamp + */ + clamp(upper: number): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.clamp + */ + clamp(lower: number, upper: number): PrimitiveChain; + /** + * @see _.clamp + */ + clamp(upper: number): PrimitiveChain; + } + // inRange + interface LoDashStatic { + /** + * Checks if n is between start and up to but not including, end. If end is not specified it’s set to start + * with start then set to 0. + * + * @param n The number to check. + * @param start The start of the range. + * @param end The end of the range. + * @return Returns true if n is in the range, else false. + */ + inRange(n: number, start: number, end?: number): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.inRange + */ + inRange(start: number, end?: number): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.inRange + */ + inRange(start: number, end?: number): PrimitiveChain; + } + // random + interface LoDashStatic { + /** + * Produces a random number between min and max (inclusive). If only one argument is provided a number between + * 0 and the given number is returned. If floating is true, or either min or max are floats, a floating-point + * number is returned instead of an integer. + * + * @param min The minimum possible value. + * @param max The maximum possible value. + * @param floating Specify returning a floating-point number. + * @return Returns the random number. + */ + random(floating?: boolean): number; + /** + * @see _.random + */ + random(max: number, floating?: boolean): number; + /** + * @see _.random + */ + random(min: number, max: number, floating?: boolean): number; + /** + * @see _.random + */ + random(min: number, index: string | number, guard: object): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.random + */ + random(floating?: boolean): number; + /** + * @see _.random + */ + random(max: number, floating?: boolean): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.random + */ + random(floating?: boolean): PrimitiveChain; + /** + * @see _.random + */ + random(max: number, floating?: boolean): PrimitiveChain; + } +} diff --git a/types/lodash/ts3.1/common/object.d.ts b/types/lodash/ts3.1/common/object.d.ts new file mode 100644 index 0000000000..1c8d5ca436 --- /dev/null +++ b/types/lodash/ts3.1/common/object.d.ts @@ -0,0 +1,2404 @@ +import _ = require("../index"); +declare module "../index" { + interface LoDashStatic { + /** + * Assigns own enumerable properties of source objects to the destination + * object. Source objects are applied from left to right. Subsequent sources + * overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object` and is loosely based on + * [`Object.assign`](https://mdn.io/Object/assign). + * + * @category Object + * @param object The destination object. + * @param [sources] The source objects. + * @returns Returns `object`. + * @example + * + * function Foo() { + * this.c = 3; + * } + * + * function Bar() { + * this.e = 5; + * } + * + * Foo.prototype.d = 4; + * Bar.prototype.f = 6; + * + * _.assign({ 'a': 1 }, new Foo, new Bar); + * // => { 'a': 1, 'c': 3, 'e': 5 } + */ + assign(object: TObject, source: TSource): TObject & TSource; + /** + * @see _.assign + */ + assign(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2; + /** + * @see _.assign + */ + assign(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3; + /** + * @see _.assign + */ + assign(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4; + /** + * @see _.assign + */ + assign(object: TObject): TObject; + /** + * @see _.assign + */ + assign(object: any, ...otherArgs: any[]): any; + } + interface Object { + /** + * @see _.assign + */ + assign(source: TSource): Object; + /** + * @see _.assign + */ + assign(source1: TSource1, source2: TSource2): Object; + /** + * @see _.assign + */ + assign(source1: TSource1, source2: TSource2, source3: TSource3): Object; + /** + * @see _.assign + */ + assign(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): Object; + /** + * @see _.assign + */ + assign(): Object; + /** + * @see _.assign + */ + assign(...otherArgs: any[]): Object; + } + interface ObjectChain { + /** + * @see _.assign + */ + assign(source: TSource): ObjectChain; + /** + * @see _.assign + */ + assign(source1: TSource1, source2: TSource2): ObjectChain; + /** + * @see _.assign + */ + assign(source1: TSource1, source2: TSource2, source3: TSource3): ObjectChain; + /** + * @see _.assign + */ + assign(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): ObjectChain; + /** + * @see _.assign + */ + assign(): ObjectChain; + /** + * @see _.assign + */ + assign(...otherArgs: any[]): ObjectChain; + } + interface LoDashStatic { + /** + * This method is like `_.assign` except that it iterates over own and + * inherited source properties. + * + * **Note:** This method mutates `object`. + * + * @alias extend + * @category Object + * @param object The destination object. + * @param [sources] The source objects. + * @returns Returns `object`. + * @example + * + * function Foo() { + * this.b = 2; + * } + * + * function Bar() { + * this.d = 4; + * } + * + * Foo.prototype.c = 3; + * Bar.prototype.e = 5; + * + * _.assignIn({ 'a': 1 }, new Foo, new Bar); + * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5 } + */ + assignIn(object: TObject, source: TSource): TObject & TSource; + /** + * @see _.assignIn + */ + assignIn(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2; + /** + * @see _.assignIn + */ + assignIn(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3; + /** + * @see _.assignIn + */ + assignIn(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4; + /** + * @see _.assignIn + */ + assignIn(object: TObject): TObject; + /** + * @see _.assignIn + */ + assignIn(object: any, ...otherArgs: any[]): TResult; + } + interface Object { + /** + * @see _.assignIn + */ + assignIn(source: TSource): Object; + /** + * @see _.assignIn + */ + assignIn(source1: TSource1, source2: TSource2): Object; + /** + * @see _.assignIn + */ + assignIn(source1: TSource1, source2: TSource2, source3: TSource3): Object; + /** + * @see _.assignIn + */ + assignIn(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): Object; + /** + * @see _.assignIn + */ + assignIn(): Object; + /** + * @see _.assignIn + */ + assignIn(...otherArgs: any[]): Object; + } + interface ObjectChain { + /** + * @see _.assignIn + */ + assignIn(source: TSource): ObjectChain; + /** + * @see _.assignIn + */ + assignIn(source1: TSource1, source2: TSource2): ObjectChain; + /** + * @see _.assignIn + */ + assignIn(source1: TSource1, source2: TSource2, source3: TSource3): ObjectChain; + /** + * @see _.assignIn + */ + assignIn(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): ObjectChain; + /** + * @see _.assignIn + */ + assignIn(): ObjectChain; + /** + * @see _.assignIn + */ + assignIn(...otherArgs: any[]): ObjectChain; + } + type AssignCustomizer = (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}) => any; + interface LoDashStatic { + /** + * This method is like `_.assignIn` except that it accepts `customizer` which + * is invoked to produce the assigned values. If `customizer` returns `undefined` + * assignment is handled by the method instead. The `customizer` is invoked + * with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. + * + * @alias extendWith + * @category Object + * @param object The destination object. + * @param sources The source objects. + * @param [customizer] The function to customize assigned values. + * @returns Returns `object`. + * @example + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignInWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ + assignInWith(object: TObject, source: TSource, customizer: AssignCustomizer): TObject & TSource; + /** + * @see _.assignInWith + */ + assignInWith(object: TObject, source1: TSource1, source2: TSource2, customizer: AssignCustomizer): TObject & TSource1 & TSource2; + /** + * @see _.assignInWith + */ + assignInWith(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer): TObject & TSource1 & TSource2 & TSource3; + /** + * @see _.assignInWith + */ + assignInWith(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer): TObject & TSource1 & TSource2 & TSource3 & TSource4; + /** + * @see _.assignInWith + */ + assignInWith(object: TObject): TObject; + /** + * @see _.assignInWith + */ + assignInWith(object: any, ...otherArgs: any[]): TResult; + } + interface Object { + /** + * @see _.assignInWith + */ + assignInWith(source: TSource, customizer: AssignCustomizer): Object; + /** + * @see _.assignInWith + */ + assignInWith(source1: TSource1, source2: TSource2, customizer: AssignCustomizer): Object; + /** + * @see _.assignInWith + */ + assignInWith(source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer): Object; + /** + * @see _.assignInWith + */ + assignInWith(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer): Object; + /** + * @see _.assignInWith + */ + assignInWith(): Object; + /** + * @see _.assignInWith + */ + assignInWith(...otherArgs: any[]): Object; + } + interface ObjectChain { + /** + * @see _.assignInWith + */ + assignInWith(source: TSource, customizer: AssignCustomizer): ObjectChain; + /** + * @see _.assignInWith + */ + assignInWith(source1: TSource1, source2: TSource2, customizer: AssignCustomizer): ObjectChain; + /** + * @see _.assignInWith + */ + assignInWith(source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer): ObjectChain; + /** + * @see _.assignInWith + */ + assignInWith(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer): ObjectChain; + /** + * @see _.assignInWith + */ + assignInWith(): ObjectChain; + /** + * @see _.assignInWith + */ + assignInWith(...otherArgs: any[]): ObjectChain; + } + interface LoDashStatic { + /** + * This method is like `_.assign` except that it accepts `customizer` which + * is invoked to produce the assigned values. If `customizer` returns `undefined` + * assignment is handled by the method instead. The `customizer` is invoked + * with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. + * + * @category Object + * @param object The destination object. + * @param sources The source objects. + * @param [customizer] The function to customize assigned values. + * @returns Returns `object`. + * @example + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ + assignWith(object: TObject, source: TSource, customizer: AssignCustomizer): TObject & TSource; + /** + * @see _.assignWith + */ + assignWith(object: TObject, source1: TSource1, source2: TSource2, customizer: AssignCustomizer): TObject & TSource1 & TSource2; + /** + * @see _.assignWith + */ + assignWith(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer): TObject & TSource1 & TSource2 & TSource3; + /** + * @see _.assignWith + */ + assignWith(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer): TObject & TSource1 & TSource2 & TSource3 & TSource4; + /** + * @see _.assignWith + */ + assignWith(object: TObject): TObject; + /** + * @see _.assignWith + */ + assignWith(object: any, ...otherArgs: any[]): TResult; + } + interface Object { + /** + * @see _.assignWith + */ + assignWith(source: TSource, customizer: AssignCustomizer): Object; + /** + * @see _.assignWith + */ + assignWith(source1: TSource1, source2: TSource2, customizer: AssignCustomizer): Object; + /** + * @see _.assignWith + */ + assignWith(source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer): Object; + /** + * @see _.assignWith + */ + assignWith(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer): Object; + /** + * @see _.assignWith + */ + assignWith(): Object; + /** + * @see _.assignWith + */ + assignWith(...otherArgs: any[]): Object; + } + interface ObjectChain { + /** + * @see _.assignWith + */ + assignWith(source: TSource, customizer: AssignCustomizer): ObjectChain; + /** + * @see _.assignWith + */ + assignWith(source1: TSource1, source2: TSource2, customizer: AssignCustomizer): ObjectChain; + /** + * @see _.assignWith + */ + assignWith(source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer): ObjectChain; + /** + * @see _.assignWith + */ + assignWith(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer): ObjectChain; + /** + * @see _.assignWith + */ + assignWith(): ObjectChain; + /** + * @see _.assignWith + */ + assignWith(...otherArgs: any[]): ObjectChain; + } + interface LoDashStatic { + /** + * Creates an array of elements corresponding to the given keys, or indexes, of collection. Keys may be + * specified as individual arguments or as arrays of keys. + * + * @param object The object to iterate over. + * @param props The property names or indexes of elements to pick, specified individually or in arrays. + * @return Returns the new array of picked elements. + */ + at(object: Dictionary | NumericDictionary | null | undefined, ...props: PropertyPath[]): T[]; + /** + * @see _.at + */ + at(object: T | null | undefined, ...props: Array>): Array; + } + interface Object { + /** + * @see _.at + */ + at(...props: Array>): Collection; + } + interface Collection { + /** + * @see _.at + */ + at(...props: PropertyPath[]): Collection; + } + interface ObjectChain { + /** + * @see _.at + */ + at(...props: Array>): CollectionChain; + } + interface CollectionChain { + /** + * @see _.at + */ + at(...props: PropertyPath[]): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an object that inherits from the given prototype object. If a properties object is provided its own + * enumerable properties are assigned to the created object. + * + * @param prototype The object to inherit from. + * @param properties The properties to assign to the object. + * @return Returns the new object. + */ + create(prototype: T, properties?: U): T & U; + } + interface Object { + /** + * @see _.create + */ + create(properties?: U): Object; + } + interface ObjectChain { + /** + * @see _.create + */ + create(properties?: U): ObjectChain; + } + interface LoDashStatic { + /** + * Assigns own enumerable properties of source object(s) to the destination object for all destination + * properties that resolve to undefined. Once a property is set, additional values of the same property are + * ignored. + * + * Note: This method mutates object. + * + * @param object The destination object. + * @param sources The source objects. + * @return The destination object. + */ + defaults(object: TObject, source: TSource): TSource & TObject; + /** + * @see _.defaults + */ + defaults(object: TObject, source1: TSource1, source2: TSource2): TSource2 & TSource1 & TObject; + /** + * @see _.defaults + */ + defaults(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TSource3 & TSource2 & TSource1 & TObject; + /** + * @see _.defaults + */ + defaults(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TSource4 & TSource3 & TSource2 & TSource1 & TObject; + /** + * @see _.defaults + */ + defaults(object: TObject): TObject; + /** + * @see _.defaults + */ + defaults(object: any, ...sources: any[]): any; + } + interface Object { + /** + * @see _.defaults + */ + defaults(source: TSource): Object; + /** + * @see _.defaults + */ + defaults(source1: TSource1, source2: TSource2): Object; + /** + * @see _.defaults + */ + defaults(source1: TSource1, source2: TSource2, source3: TSource3): Object; + /** + * @see _.defaults + */ + defaults(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): Object; + /** + * @see _.defaults + */ + defaults(): Object; + /** + * @see _.defaults + */ + defaults(...sources: any[]): Object; + } + interface ObjectChain { + /** + * @see _.defaults + */ + defaults(source: TSource): ObjectChain; + /** + * @see _.defaults + */ + defaults(source1: TSource1, source2: TSource2): ObjectChain; + /** + * @see _.defaults + */ + defaults(source1: TSource1, source2: TSource2, source3: TSource3): ObjectChain; + /** + * @see _.defaults + */ + defaults(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): ObjectChain; + /** + * @see _.defaults + */ + defaults(): ObjectChain; + /** + * @see _.defaults + */ + defaults(...sources: any[]): ObjectChain; + } + interface LoDashStatic { + /** + * This method is like _.defaults except that it recursively assigns default properties. + * @param object The destination object. + * @param sources The source objects. + * @return Returns object. + */ + defaultsDeep(object: any, ...sources: any[]): any; + } + interface Object { + /** + * @see _.defaultsDeep + */ + defaultsDeep(...sources: any[]): Object; + } + interface ObjectChain { + /** + * @see _.defaultsDeep + */ + defaultsDeep(...sources: any[]): ObjectChain; + } + interface LoDashStatic { + /** + * @see _.toPairs + */ + entries(object?: Dictionary | NumericDictionary): Array<[string, T]>; + /** + * @see _.entries + */ + entries(object?: object): Array<[string, any]>; + } + interface Object { + /** + * @see _.entries + */ + entries(): Collection<[string, T[keyof T]]>; + } + interface LoDashImplicitWrapper { + /** + * @see _.entries + */ + entries(): Collection<[string, any]>; + } + interface ObjectChain { + /** + * @see _.entries + */ + entries(): CollectionChain<[string, T[keyof T]]>; + } + interface LoDashExplicitWrapper { + /** + * @see _.entries + */ + entries(): CollectionChain<[string, any]>; + } + interface LoDashStatic { + /** + * @see _.entriesIn + */ + entriesIn(object?: Dictionary | NumericDictionary): Array<[string, T]>; + /** + * @see _.entriesIn + */ + entriesIn(object?: object): Array<[string, any]>; + } + interface Object { + /** + * @see _.entriesIn + */ + entriesIn(): Collection<[string, T[keyof T]]>; + } + interface LoDashImplicitWrapper { + /** + * @see _.entriesIn + */ + entriesIn(): Collection<[string, any]>; + } + interface ObjectChain { + /** + * @see _.entriesIn + */ + entriesIn(): CollectionChain<[string, T[keyof T]]>; + } + interface LoDashExplicitWrapper { + /** + * @see _.entriesIn + */ + entriesIn(): CollectionChain<[string, any]>; + } + interface LoDashStatic { + /** + * @see _.extend + */ + extend(object: TObject, source: TSource): TObject & TSource; + /** + * @see _.extend + */ + extend(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2; + /** + * @see _.extend + */ + extend(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3; + /** + * @see _.extend + */ + extend(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4; + /** + * @see _.extend + */ + extend(object: TObject): TObject; + /** + * @see _.extend + */ + extend(object: any, ...otherArgs: any[]): TResult; + } + interface Object { + /** + * @see _.extend + */ + extend(source: TSource): Object; + /** + * @see _.extend + */ + extend(source1: TSource1, source2: TSource2): Object; + /** + * @see _.extend + */ + extend(source1: TSource1, source2: TSource2, source3: TSource3): Object; + /** + * @see _.extend + */ + extend(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): Object; + /** + * @see _.extend + */ + extend(): Object; + /** + * @see _.extend + */ + extend(...otherArgs: any[]): Object; + } + interface ObjectChain { + /** + * @see _.extend + */ + extend(source: TSource): ObjectChain; + /** + * @see _.extend + */ + extend(source1: TSource1, source2: TSource2): ObjectChain; + /** + * @see _.extend + */ + extend(source1: TSource1, source2: TSource2, source3: TSource3): ObjectChain; + /** + * @see _.extend + */ + extend(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): ObjectChain; + /** + * @see _.extend + */ + extend(): ObjectChain; + /** + * @see _.extend + */ + extend(...otherArgs: any[]): ObjectChain; + } + interface LoDashStatic { + /** + * @see _.extendWith + */ + extendWith(object: TObject, source: TSource, customizer: AssignCustomizer): TObject & TSource; + /** + * @see _.extendWith + */ + extendWith(object: TObject, source1: TSource1, source2: TSource2, customizer: AssignCustomizer): TObject & TSource1 & TSource2; + /** + * @see _.extendWith + */ + extendWith(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer): TObject & TSource1 & TSource2 & TSource3; + /** + * @see _.extendWith + */ + extendWith(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer): TObject & TSource1 & TSource2 & TSource3 & TSource4; + /** + * @see _.extendWith + */ + extendWith(object: TObject): TObject; + /** + * @see _.extendWith + */ + extendWith(object: any, ...otherArgs: any[]): TResult; + } + interface Object { + /** + * @see _.extendWith + */ + extendWith(source: TSource, customizer: AssignCustomizer): Object; + /** + * @see _.extendWith + */ + extendWith(source1: TSource1, source2: TSource2, customizer: AssignCustomizer): Object; + /** + * @see _.extendWith + */ + extendWith(source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer): Object; + /** + * @see _.extendWith + */ + extendWith(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer): Object; + /** + * @see _.extendWith + */ + extendWith(): Object; + /** + * @see _.extendWith + */ + extendWith(...otherArgs: any[]): Object; + } + interface ObjectChain { + /** + * @see _.extendWith + */ + extendWith(source: TSource, customizer: AssignCustomizer): ObjectChain; + /** + * @see _.extendWith + */ + extendWith(source1: TSource1, source2: TSource2, customizer: AssignCustomizer): ObjectChain; + /** + * @see _.extendWith + */ + extendWith(source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer): ObjectChain; + /** + * @see _.extendWith + */ + extendWith(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer): ObjectChain; + /** + * @see _.extendWith + */ + extendWith(): ObjectChain; + /** + * @see _.extendWith + */ + extendWith(...otherArgs: any[]): ObjectChain; + } + interface LoDashStatic { + /** + * This method is like _.find except that it returns the key of the first element predicate returns truthy for + * instead of the element itself. + * + * @param object The object to search. + * @param predicate The function invoked per iteration. + * @return Returns the key of the matched element, else undefined. + */ + findKey(object: T | null | undefined, predicate?: ObjectIteratee): string | undefined; + } + interface LoDashImplicitWrapper { + /** + * @see _.findKey + */ + findKey(predicate?: ObjectIteratee): string | undefined; + } + interface LoDashExplicitWrapper { + /** + * @see _.findKey + */ + findKey(predicate?: ObjectIteratee): StringNullableChain; + } + interface LoDashStatic { + /** + * This method is like _.findKey except that it iterates over elements of a collection in the opposite order. + * + * @param object The object to search. + * @param predicate The function invoked per iteration. + * @return Returns the key of the matched element, else undefined. + */ + findLastKey(object: T | null | undefined, predicate?: ObjectIteratee): string | undefined; + } + interface LoDashImplicitWrapper { + /** + * @see _.findLastKey + */ + findLastKey(predicate?: ObjectIteratee): string | undefined; + } + interface LoDashExplicitWrapper { + /** + * @see _.findLastKey + */ + findLastKey(predicate?: ObjectIteratee): StringNullableChain; + } + interface LoDashStatic { + /** + * Iterates over own and inherited enumerable properties of an object invoking iteratee for each property. The + * iteratee is invoked with three arguments: (value, key, object). Iteratee functions may + * exit iteration early by explicitly returning false. + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns object. + */ + forIn(object: T, iteratee?: ObjectIterator): T; + /** + * @see _.forIn + */ + forIn(object: T | null | undefined, iteratee?: ObjectIterator): T | null | undefined; + } + interface LoDashImplicitWrapper { + /** + * @see _.forIn + */ + forIn(iteratee?: ObjectIterator): this; + } + interface LoDashExplicitWrapper { + /** + * @see _.forIn + */ + forIn(iteratee?: ObjectIterator): this; + } + interface LoDashStatic { + /** + * This method is like _.forIn except that it iterates over properties of object in the opposite order. + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns object. + */ + forInRight(object: T, iteratee?: ObjectIterator): T; + /** + * @see _.forInRight + */ + forInRight(object: T | null | undefined, iteratee?: ObjectIterator): T | null | undefined; + } + interface LoDashImplicitWrapper { + /** + * @see _.forInRight + */ + forInRight(iteratee?: ObjectIterator): this; + } + interface LoDashExplicitWrapper { + /** + * @see _.forInRight + */ + forInRight(iteratee?: ObjectIterator): this; + } + interface LoDashStatic { + /** + * Iterates over own enumerable properties of an object invoking iteratee for each property. The iteratee is + * invoked with three arguments: (value, key, object). Iteratee functions may exit + * iteration early by explicitly returning false. + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns object. + */ + forOwn(object: T, iteratee?: ObjectIterator): T; + /** + * @see _.forOwn + */ + forOwn(object: T | null | undefined, iteratee?: ObjectIterator): T | null | undefined; + } + interface LoDashImplicitWrapper { + /** + * @see _.forOwn + */ + forOwn(iteratee?: ObjectIterator): this; + } + interface LoDashExplicitWrapper { + /** + * @see _.forOwn + */ + forOwn(iteratee?: ObjectIterator): this; + } + interface LoDashStatic { + /** + * This method is like _.forOwn except that it iterates over properties of object in the opposite order. + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns object. + */ + forOwnRight(object: T, iteratee?: ObjectIterator): T; + /** + * @see _.forOwnRight + */ + forOwnRight(object: T | null | undefined, iteratee?: ObjectIterator): T | null | undefined; + } + interface LoDashImplicitWrapper { + /** + * @see _.forOwnRight + */ + forOwnRight(iteratee?: ObjectIterator): this; + } + interface LoDashExplicitWrapper { + /** + * @see _.forOwnRight + */ + forOwnRight(iteratee?: ObjectIterator): this; + } + interface LoDashStatic { + /** + * Creates an array of function property names from own enumerable properties + * of `object`. + * + * @category Object + * @param object The object to inspect. + * @returns Returns the new array of property names. + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functions(new Foo); + * // => ['a', 'b'] + */ + functions(object: any): string[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.functions + */ + functions(): Collection; + } + interface LoDashExplicitWrapper { + /** + * @see _.functions + */ + functions(): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array of function property names from own and inherited + * enumerable properties of `object`. + * + * @category Object + * @param object The object to inspect. + * @returns Returns the new array of property names. + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functionsIn(new Foo); + * // => ['a', 'b', 'c'] + */ + functionsIn(object: any): string[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.functionsIn + */ + functionsIn(): Collection; + } + interface LoDashExplicitWrapper { + /** + * @see _.functionsIn + */ + functionsIn(): CollectionChain; + } + interface LoDashStatic { + /** + * Gets the property value at path of object. If the resolved value is undefined the defaultValue is used + * in its place. + * + * @param object The object to query. + * @param path The path of the property to get. + * @param defaultValue The value returned if the resolved value is undefined. + * @return Returns the resolved value. + */ + get(object: TObject, path: TKey | [TKey]): TObject[TKey]; + /** + * @see _.get + */ + get(object: TObject | null | undefined, path: TKey | [TKey]): TObject[TKey] | undefined; + /** + * @see _.get + */ + get(object: TObject | null | undefined, path: TKey | [TKey], defaultValue: TDefault): Exclude | TDefault; + /** + * @see _.get + */ + get(object: NumericDictionary, path: number): T; + /** + * @see _.get + */ + get(object: NumericDictionary | null | undefined, path: number): T | undefined; + /** + * @see _.get + */ + get(object: NumericDictionary | null | undefined, path: number, defaultValue: TDefault): T | TDefault; + /** + * @see _.get + */ + get(object: null | undefined, path: PropertyPath, defaultValue: TDefault): TDefault; + /** + * @see _.get + */ + get(object: null | undefined, path: PropertyPath): undefined; + /** + * @see _.get + */ + get(object: any, path: PropertyPath, defaultValue?: any): any; + } + interface String { + /** + * @see _.get + */ + get(path: number | number[]): string; + /** + * @see _.get + */ + get(path: number | number[], defaultValue: string): string; + } + interface Object { + /** + * @see _.get + */ + get(path: TKey | [TKey]): T[TKey]; + /** + * @see _.get + */ + get(path: TKey | [TKey], defaultValue: TDefault): Exclude | TDefault; + /** + * @see _.get + */ + get(path: PropertyPath, defaultValue?: any): any; + } + interface Collection { + /** + * @see _.get + */ + get(path: number): T; + /** + * @see _.get + */ + get(path: number, defaultValue: TDefault): T | TDefault; + } + interface StringChain { + /** + * @see _.get + */ + get(path: number | number[]): StringChain; + /** + * @see _.get + */ + get(path: number | number[], defaultValue: string): StringChain; + } + interface StringNullableChain { + /** + * @see _.get + */ + get(path: number | number[]): StringNullableChain; + /** + * @see _.get + */ + get(path: number | number[], defaultValue: string): StringChain; + } + interface ObjectChain { + /** + * @see _.get + */ + get(path: TKey | [TKey]): ExpChain; + /** + * @see _.get + */ + get(path: TKey | [TKey], defaultValue: TDefault): ExpChain | TDefault>; + /** + * @see _.get + */ + get(path: PropertyPath, defaultValue?: any): LoDashExplicitWrapper; + } + interface CollectionChain { + /** + * @see _.get + */ + get(path: number): ExpChain; + /** + * @see _.get + */ + get(path: number, defaultValue: TDefault): ExpChain; + } + interface LoDashStatic { + /** + * Checks if `path` is a direct property of `object`. + * + * @category Object + * @param object The object to query. + * @param path The path to check. + * @returns Returns `true` if `path` exists, else `false`. + * @example + * + * var object = { 'a': { 'b': { 'c': 3 } } }; + * var other = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) }); + * + * _.has(object, 'a'); + * // => true + * + * _.has(object, 'a.b.c'); + * // => true + * + * _.has(object, ['a', 'b', 'c']); + * // => true + * + * _.has(other, 'a'); + * // => false + */ + has(object: T, path: PropertyPath): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.has + */ + has(path: PropertyPath): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.has + */ + has(path: PropertyPath): PrimitiveChain; + } + interface LoDashStatic { + /** + * Checks if `path` is a direct or inherited property of `object`. + * + * @category Object + * @param object The object to query. + * @param path The path to check. + * @returns Returns `true` if `path` exists, else `false`. + * @example + * + * var object = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) }); + * + * _.hasIn(object, 'a'); + * // => true + * + * _.hasIn(object, 'a.b.c'); + * // => true + * + * _.hasIn(object, ['a', 'b', 'c']); + * // => true + * + * _.hasIn(object, 'b'); + * // => false + */ + hasIn(object: T, path: PropertyPath): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.hasIn + */ + hasIn(path: PropertyPath): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.hasIn + */ + hasIn(path: PropertyPath): PrimitiveChain; + } + interface LoDashStatic { + /** + * Creates an object composed of the inverted keys and values of object. If object contains duplicate values, + * subsequent values overwrite property assignments of previous values unless multiValue is true. + * + * @param object The object to invert. + * @param multiValue Allow multiple values per key. + * @return Returns the new inverted object. + */ + invert(object: object): Dictionary; + } + interface LoDashImplicitWrapper { + /** + * @see _.invert + */ + invert(): Object>; + } + interface LoDashExplicitWrapper { + /** + * @see _.invert + */ + invert(): ObjectChain>; + } + interface LoDashStatic { + /** + * This method is like _.invert except that the inverted object is generated from the results of running each + * element of object through iteratee. The corresponding inverted value of each inverted key is an array of + * keys responsible for generating the inverted value. The iteratee is invoked with one argument: (value). + * + * @param object The object to invert. + * @param interatee The iteratee invoked per element. + * @return Returns the new inverted object. + */ + invertBy(object: Dictionary | NumericDictionary | null | undefined, interatee?: ValueIteratee): Dictionary; + /** + * @see _.invertBy + */ + invertBy(object: T | null | undefined, interatee?: ValueIteratee): Dictionary; + } + interface String { + /** + * @see _.invertBy + */ + invertBy(iteratee?: ValueIteratee): Object>; + } + interface Collection { + /** + * @see _.invertBy + */ + invertBy(iteratee?: ValueIteratee): Object>; + } + interface Object { + /** + * @see _.invertBy + */ + invertBy(iteratee?: ValueIteratee): Object>; + } + interface StringChain { + /** + * @see _.invertBy + */ + invertBy(iteratee?: ValueIteratee): ObjectChain>; + } + interface StringNullableChain { + /** + * @see _.invertBy + */ + invertBy(iteratee?: ValueIteratee): ObjectChain>; + } + interface CollectionChain { + /** + * @see _.invertBy + */ + invertBy(iteratee?: ValueIteratee): ObjectChain>; + } + interface ObjectChain { + /** + * @see _.invertBy + */ + invertBy(iteratee?: ValueIteratee): ObjectChain>; + } + interface LoDashStatic { + /** + * Invokes the method at path of object. + * @param object The object to query. + * @param path The path of the method to invoke. + * @param args The arguments to invoke the method with. + */ + invoke(object: any, path: PropertyPath, ...args: any[]): any; + } + interface LoDashImplicitWrapper { + /** + * @see _.invoke + */ + invoke(path: PropertyPath, ...args: any[]): any; + } + interface LoDashExplicitWrapper { + /** + * @see _.invoke + */ + invoke(path: PropertyPath, ...args: any[]): LoDashExplicitWrapper; + } + interface LoDashStatic { + /** + * Creates an array of the own enumerable property names of object. + * + * Note: Non-object values are coerced to objects. See the ES spec for more details. + * + * @param object The object to query. + * @return Returns the array of property names. + */ + keys(object?: any): string[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.keys + */ + keys(): Collection; + } + interface LoDashExplicitWrapper { + /** + * @see _.keys + */ + keys(): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array of the own and inherited enumerable property names of object. + * + * Note: Non-object values are coerced to objects. + * + * @param object The object to query. + * @return An array of property names. + */ + keysIn(object?: any): string[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.keysIn + */ + keysIn(): Collection; + } + interface LoDashExplicitWrapper { + /** + * @see _.keysIn + */ + keysIn(): CollectionChain; + } + interface LoDashStatic { + /** + * The opposite of _.mapValues; this method creates an object with the same values as object and keys generated + * by running each own enumerable property of object through iteratee. + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns the new mapped object. + */ + mapKeys(object: List | null | undefined, iteratee?: ListIteratee): Dictionary; + /** + * @see _.mapKeys + */ + mapKeys(object: T | null | undefined, iteratee?: ObjectIteratee): Dictionary; + } + interface Collection { + /** + * @see _.mapKeys + */ + mapKeys(iteratee?: ListIteratee): Object>; + } + interface Object { + /** + * @see _.mapKeys + */ + mapKeys(iteratee?: ObjectIteratee): Object>; + } + interface CollectionChain { + /** + * @see _.mapKeys + */ + mapKeys(iteratee?: ListIteratee): ObjectChain>; + } + interface ObjectChain { + /** + * @see _.mapKeys + */ + mapKeys(iteratee?: ObjectIteratee): ObjectChain>; + } + interface LoDashStatic { + /** + * Creates an object with the same keys as object and values generated by running each own + * enumerable property of object through iteratee. The iteratee function is + * invoked with three arguments: (value, key, object). + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns the new mapped object. + */ + mapValues(obj: string | null | undefined, callback: StringIterator): NumericDictionary; + /** + * @see _.mapValues + */ + mapValues(obj: Dictionary | NumericDictionary | null | undefined, callback: DictionaryIterator): Dictionary; + /** + * @see _.mapValues + */ + mapValues(obj: T | null | undefined, callback: ObjectIterator): { [P in keyof T]: TResult }; + /** + * @see _.mapValues + */ + mapValues(obj: Dictionary | NumericDictionary | null | undefined, iteratee: object): Dictionary; + /** + * @see _.mapValues + */ + mapValues(obj: T | null | undefined, iteratee: object): { [P in keyof T]: boolean }; + /** + * @see _.mapValues + */ + mapValues(obj: Dictionary | NumericDictionary | null | undefined, iteratee: TKey): Dictionary; + /** + * @see _.mapValues + */ + mapValues(obj: Dictionary | NumericDictionary | null | undefined, iteratee: string): Dictionary; + /** + * @see _.mapValues + */ + mapValues(obj: T | null | undefined, iteratee: string): { [P in keyof T]: any }; + /** + * @see _.mapValues + */ + mapValues(obj: string | null | undefined): NumericDictionary; + /** + * @see _.mapValues + */ + mapValues(obj: Dictionary | NumericDictionary | null | undefined): Dictionary; + /** + * @see _.mapValues + */ + mapValues(obj: T): T; + /** + * @see _.mapValues + */ + mapValues(obj: T | null | undefined): PartialObject; + } + interface String { + /** + * @see _.mapValues + */ + mapValues(callback: StringIterator): Object>; + /** + * @see _.mapValues + */ + mapValues(): Object>; + } + interface Collection { + /** + * @see _.mapValues + */ + mapValues(callback: DictionaryIterator): Object>; + /** + * @see _.mapValues + */ + mapValues(iteratee: TKey): Object>; + /** + * @see _.mapValues + */ + mapValues(iteratee: object): Object>; + /** + * @see _.mapValues + */ + mapValues(iteratee: string): Object>; + /** + * @see _.mapValues + */ + mapValues(): Object>; + } + interface Object { + /** + * @see _.mapValues + */ + mapValues(callback: ObjectIterator): Object<{ [P in keyof T]: TResult }>; + /** + * @see _.mapValues + */ + mapValues(callback: DictionaryIterator): Object>; + /** + * @see _.mapValues + */ + mapValues(iteratee: object): Object<{ [P in keyof T]: boolean }>; + /** + * @see _.mapValues + */ + mapValues(iteratee: TKey): Object>; + /** + * @see _.mapValues + */ + mapValues(iteratee: string): Object<{ [P in keyof T]: any }>; + /** + * @see _.mapValues + */ + mapValues(): Object; + } + interface StringChain { + /** + * @see _.mapValues + */ + mapValues(callback: StringIterator): ObjectChain>; + /** + * @see _.mapValues + */ + mapValues(): ObjectChain>; + } + interface StringNullableChain { + /** + * @see _.mapValues + */ + mapValues(callback: StringIterator): ObjectChain>; + /** + * @see _.mapValues + */ + mapValues(): ObjectChain>; + } + interface CollectionChain { + /** + * @see _.mapValues + */ + mapValues(callback: DictionaryIterator): ObjectChain>; + /** + * @see _.mapValues + */ + mapValues(iteratee: TKey): ObjectChain>; + /** + * @see _.mapValues + */ + mapValues(iteratee: object): ObjectChain>; + /** + * @see _.mapValues + */ + mapValues(iteratee: string): ObjectChain>; + /** + * @see _.mapValues + */ + mapValues(): ObjectChain>; + } + interface ObjectChain { + /** + * @see _.mapValues + */ + mapValues(callback: ObjectIterator): ObjectChain<{ [P in keyof T]: TResult }>; + /** + * @see _.mapValues + */ + mapValues(callback: DictionaryIterator): ObjectChain>; + /** + * @see _.mapValues + */ + mapValues(iteratee: object): ObjectChain<{ [P in keyof T]: boolean }>; + /** + * @see _.mapValues + */ + mapValues(iteratee: TKey): ObjectChain>; + /** + * @see _.mapValues + */ + mapValues(iteratee: string): ObjectChain<{ [P in keyof T]: any }>; + /** + * @see _.mapValues + */ + mapValues(): ObjectChain; + } + interface LoDashStatic { + /** + * Recursively merges own and inherited enumerable properties of source + * objects into the destination object, skipping source properties that resolve + * to `undefined`. Array and plain object properties are merged recursively. + * Other objects and value types are overridden by assignment. Source objects + * are applied from left to right. Subsequent sources overwrite property + * assignments of previous sources. + * + * **Note:** This method mutates `object`. + * + * @category Object + * @param object The destination object. + * @param [sources] The source objects. + * @returns Returns `object`. + * @example + * + * var users = { + * 'data': [{ 'user': 'barney' }, { 'user': 'fred' }] + * }; + * + * var ages = { + * 'data': [{ 'age': 36 }, { 'age': 40 }] + * }; + * + * _.merge(users, ages); + * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] } + */ + merge(object: TObject, source: TSource): TObject & TSource; + /** + * @see _.merge + */ + merge(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2; + /** + * @see _.merge + */ + merge(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3; + /** + * @see _.merge + */ + merge(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4; + /** + * @see _.merge + */ + merge(object: any, ...otherArgs: any[]): any; + } + interface Object { + /** + * @see _.merge + */ + merge(source: TSource): Object; + /** + * @see _.merge + */ + merge(source1: TSource1, source2: TSource2): Object; + /** + * @see _.merge + */ + merge(source1: TSource1, source2: TSource2, source3: TSource3): Object; + /** + * @see _.merge + */ + merge(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): Object; + /** + * @see _.merge + */ + merge(...otherArgs: any[]): Object; + } + interface ObjectChain { + /** + * @see _.merge + */ + merge(source: TSource): ObjectChain; + /** + * @see _.merge + */ + merge(source1: TSource1, source2: TSource2): ObjectChain; + /** + * @see _.merge + */ + merge(source1: TSource1, source2: TSource2, source3: TSource3): ObjectChain; + /** + * @see _.merge + */ + merge(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): ObjectChain; + /** + * @see _.merge + */ + merge(...otherArgs: any[]): ObjectChain; + } + type MergeWithCustomizer = { bivariantHack(value: any, srcValue: any, key: string, object: any, source: any): any; }["bivariantHack"]; + // TODO: Probably should just put all these methods on Object and forget about it. + // oh, except for Collection I GUESS + interface LoDashStatic { + /** + * This method is like `_.merge` except that it accepts `customizer` which + * is invoked to produce the merged values of the destination and source + * properties. If `customizer` returns `undefined` merging is handled by the + * method instead. The `customizer` is invoked with seven arguments: + * (objValue, srcValue, key, object, source, stack). + * + * @category Object + * @param object The destination object. + * @param sources The source objects. + * @param customizer The function to customize assigned values. + * @returns Returns `object`. + * @example + * + * function customizer(objValue, srcValue) { + * if (_.isArray(objValue)) { + * return objValue.concat(srcValue); + * } + * } + * + * var object = { + * 'fruits': ['apple'], + * 'vegetables': ['beet'] + * }; + * + * var other = { + * 'fruits': ['banana'], + * 'vegetables': ['carrot'] + * }; + * + * _.merge(object, other, customizer); + * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] } + */ + mergeWith(object: TObject, source: TSource, customizer: MergeWithCustomizer): TObject & TSource; + /** + * @see _.mergeWith + */ + mergeWith(object: TObject, source1: TSource1, source2: TSource2, customizer: MergeWithCustomizer): TObject & TSource1 & TSource2; + /** + * @see _.mergeWith + */ + mergeWith(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: MergeWithCustomizer): TObject & TSource1 & TSource2 & TSource3; + /** + * @see _.mergeWith + */ + mergeWith(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: MergeWithCustomizer): TObject & TSource1 & TSource2 & TSource3 & TSource4; + /** + * @see _.mergeWith + */ + mergeWith(object: any, ...otherArgs: any[]): any; + } + interface Object { + /** + * @see _.mergeWith + */ + mergeWith(source: TSource, customizer: MergeWithCustomizer): Object; + /** + * @see _.mergeWith + */ + mergeWith(source1: TSource1, source2: TSource2, customizer: MergeWithCustomizer): Object; + /** + * @see _.mergeWith + */ + mergeWith(source1: TSource1, source2: TSource2, source3: TSource3, customizer: MergeWithCustomizer): Object; + /** + * @see _.mergeWith + */ + mergeWith(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: MergeWithCustomizer): Object; + /** + * @see _.mergeWith + */ + mergeWith(...otherArgs: any[]): Object; + } + interface ObjectChain { + /** + * @see _.mergeWith + */ + mergeWith(source: TSource, customizer: MergeWithCustomizer): ObjectChain; + /** + * @see _.mergeWith + */ + mergeWith(source1: TSource1, source2: TSource2, customizer: MergeWithCustomizer): ObjectChain; + /** + * @see _.mergeWith + */ + mergeWith(source1: TSource1, source2: TSource2, source3: TSource3, customizer: MergeWithCustomizer): ObjectChain; + /** + * @see _.mergeWith + */ + mergeWith(source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: MergeWithCustomizer): ObjectChain; + /** + * @see _.mergeWith + */ + mergeWith(...otherArgs: any[]): ObjectChain; + } + interface LoDashStatic { + /** + * The opposite of `_.pick`; this method creates an object composed of the + * own and inherited enumerable properties of `object` that are not omitted. + * + * @category Object + * @param object The source object. + * @param [paths] The property names to omit, specified + * individually or in arrays.. + * @returns Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omit(object, ['a', 'c']); + * // => { 'b': '2' } + */ + omit(object: T | null | undefined, ...paths: Array>): Omit; + /** + * @see _.omit + */ + omit(object: T | null | undefined, ...paths: Array>): PartialObject; + } + interface Collection { + /** + * @see _.omit + */ + omit(...paths: Array>): Collection; + } + interface Object { + /** + * @see _.omit + */ + omit(...paths: Array>): Object>; + /** + * @see _.omit + */ + omit(...paths: Array>>): Object>; + } + interface CollectionChain { + /** + * @see _.omit + */ + omit(...paths: Array>): CollectionChain; + } + interface ObjectChain { + /** + * @see _.omit + */ + omit(...paths: Array>): ObjectChain>; + /** + * @see _.omit + */ + omit(...paths: Array>): ObjectChain>; + } + interface LoDashStatic { + /** + * The opposite of `_.pickBy`; this method creates an object composed of the + * own and inherited enumerable properties of `object` that `predicate` + * doesn't return truthy for. + * + * @category Object + * @param object The source object. + * @param [predicate=_.identity] The function invoked per property. + * @returns Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omitBy(object, _.isNumber); + * // => { 'b': '2' } + */ + omitBy(object: Dictionary | null | undefined, predicate?: ValueKeyIteratee): Dictionary; + /** + * @see _.omitBy + */ + omitBy(object: NumericDictionary | null | undefined, predicate?: ValueKeyIteratee): NumericDictionary; + /** + * @see _.omitBy + */ + omitBy(object: T | null | undefined, predicate: ValueKeyIteratee): PartialObject; + } + interface Collection { + /** + * @see _.omitBy + */ + omitBy(predicate?: ValueKeyIteratee): Object>; + } + interface Object { + /** + * @see _.omitBy + */ + omitBy(predicate: ValueKeyIteratee): Object>; + } + interface CollectionChain { + /** + * @see _.omitBy + */ + omitBy(predicate?: ValueKeyIteratee): ObjectChain>; + } + interface ObjectChain { + /** + * @see _.omitBy + */ + omitBy(predicate: ValueKeyIteratee): ObjectChain>; + } + interface LoDashStatic { + /** + * Creates an object composed of the picked `object` properties. + * + * @category Object + * @param object The source object. + * @param [props] The property names to pick, specified + * individually or in arrays. + * @returns Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pick(object, ['a', 'c']); + * // => { 'a': 1, 'c': 3 } + */ + pick(object: T, ...props: Array>): Pick; + /** + * @see _.pick + */ + pick(object: T | null | undefined, ...props: PropertyPath[]): PartialDeep; + } + interface Object { + /** + * @see _.pick + */ + pick(...props: Array>): Object>; + /** + * @see _.pick + */ + pick(...props: PropertyPath[]): Object>; + } + interface ObjectChain { + /** + * @see _.pick + */ + pick(...props: Array>): ObjectChain>; + /** + * @see _.pick + */ + pick(...props: PropertyPath[]): ObjectChain>; + } + interface LoDashStatic { + /** + * Creates an object composed of the `object` properties `predicate` returns + * truthy for. The predicate is invoked with two arguments: (value, key). + * + * @category Object + * @param object The source object. + * @param [predicate=_.identity] The function invoked per property. + * @returns Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pickBy(object, _.isNumber); + * // => { 'a': 1, 'c': 3 } + */ + pickBy(object: Dictionary | null | undefined, predicate: ValueKeyIterateeTypeGuard): Dictionary; + /** + * @see _.pickBy + */ + pickBy(object: NumericDictionary | null | undefined, predicate: ValueKeyIterateeTypeGuard): NumericDictionary; + /** + * @see _.pickBy + */ + pickBy(object: Dictionary | null | undefined, predicate?: ValueKeyIteratee): Dictionary; + /** + * @see _.pickBy + */ + pickBy(object: NumericDictionary | null | undefined, predicate?: ValueKeyIteratee): NumericDictionary; + /** + * @see _.pickBy + */ + pickBy(object: T | null | undefined, predicate?: ValueKeyIteratee): PartialObject; + } + interface Collection { + /** + * @see _.pickBy + */ + pickBy(predicate: ValueKeyIterateeTypeGuard): Object>; + /** + * @see _.pickBy + */ + pickBy(predicate?: ValueKeyIteratee): Object>; + } + interface Object { + /** + * @see _.pickBy + */ + pickBy(predicate: ValueKeyIterateeTypeGuard): Object extends T ? NumericDictionary : Dictionary>; + /** + * @see _.pickBy + */ + pickBy(predicate?: ValueKeyIteratee): Object>; + } + interface CollectionChain { + /** + * @see _.pickBy + */ + pickBy(predicate: ValueKeyIterateeTypeGuard): ObjectChain>; + /** + * @see _.pickBy + */ + pickBy(predicate?: ValueKeyIteratee): ObjectChain>; + } + interface ObjectChain { + /** + * @see _.pickBy + */ + pickBy(predicate: ValueKeyIterateeTypeGuard): ObjectChain extends T ? NumericDictionary : Dictionary>; + /** + * @see _.pickBy + */ + pickBy(predicate?: ValueKeyIteratee): ObjectChain>; + } + interface LoDashStatic { + /** + * This method is like _.get except that if the resolved value is a function it’s invoked with the this binding + * of its parent object and its result is returned. + * + * @param object The object to query. + * @param path The path of the property to resolve. + * @param defaultValue The value returned if the resolved value is undefined. + * @return Returns the resolved value. + */ + result(object: any, path: PropertyPath, defaultValue?: TResult | ((...args: any[]) => TResult)): TResult; + } + interface LoDashImplicitWrapper { + /** + * @see _.result + */ + result(path: PropertyPath, defaultValue?: TResult | ((...args: any[]) => TResult)): TResult; + } + interface LoDashExplicitWrapper { + /** + * @see _.result + */ + result(path: PropertyPath, defaultValue?: TResult | ((...args: any[]) => TResult)): ExpChain; + } + interface LoDashStatic { + /** + * Sets the value at path of object. If a portion of path doesn’t exist it’s created. Arrays are created for + * missing index properties while objects are created for all other missing properties. Use _.setWith to + * customize path creation. + * + * @param object The object to modify. + * @param path The path of the property to set. + * @param value The value to set. + * @return Returns object. + */ + set(object: T, path: PropertyPath, value: any): T; + /** + * @see _.set + */ + set(object: object, path: PropertyPath, value: any): TResult; + } + interface LoDashImplicitWrapper { + /** + * @see _.set + */ + set(path: PropertyPath, value: any): this; + /** + * @see _.set + */ + set(path: PropertyPath, value: any): ImpChain; + } + interface LoDashExplicitWrapper { + /** + * @see _.set + */ + set(path: PropertyPath, value: any): this; + /** + * @see _.set + */ + set(path: PropertyPath, value: any): ExpChain; + } + type SetWithCustomizer = (nsValue: any, key: string, nsObject: T) => any; + interface LoDashStatic { + /** + * This method is like _.set except that it accepts customizer which is invoked to produce the objects of + * path. If customizer returns undefined path creation is handled by the method instead. The customizer is + * invoked with three arguments: (nsValue, key, nsObject). + * + * @param object The object to modify. + * @param path The path of the property to set. + * @param value The value to set. + * @param customizer The function to customize assigned values. + * @return Returns object. + */ + setWith(object: T, path: PropertyPath, value: any, customizer?: SetWithCustomizer): T; + /** + * @see _.setWith + */ + setWith(object: T, path: PropertyPath, value: any, customizer?: SetWithCustomizer): TResult; + } + interface LoDashImplicitWrapper { + /** + * @see _.setWith + */ + setWith(path: PropertyPath, value: any, customizer?: SetWithCustomizer): this; + /** + * @see _.setWith + */ + setWith(path: PropertyPath, value: any, customizer?: SetWithCustomizer): ImpChain; + } + interface LoDashExplicitWrapper { + /** + * @see _.setWith + */ + setWith(path: PropertyPath, value: any, customizer?: SetWithCustomizer): this; + /** + * @see _.setWith + */ + setWith(path: PropertyPath, value: any, customizer?: SetWithCustomizer): ExpChain; + } + interface LoDashStatic { + /** + * Creates an array of own enumerable key-value pairs for object. + * + * @param object The object to query. + * @return Returns the new array of key-value pairs. + */ + toPairs(object?: Dictionary | NumericDictionary): Array<[string, T]>; + /** + * @see _.toPairs + */ + toPairs(object?: object): Array<[string, any]>; + } + interface LoDashImplicitWrapper { + /** + * @see _.toPairs + */ + toPairs(): Collection<[string, TValue extends Dictionary ? U : TValue extends NumericDictionary ? V : any]>; + } + interface LoDashExplicitWrapper { + /** + * @see _.toPairs + */ + toPairs(): CollectionChain<[string, TValue extends Dictionary ? U : TValue extends NumericDictionary ? V : any]>; + } + interface LoDashStatic { + /** + * Creates an array of own and inherited enumerable key-value pairs for object. + * + * @param object The object to query. + * @return Returns the new array of key-value pairs. + */ + toPairsIn(object?: Dictionary | NumericDictionary): Array<[string, T]>; + /** + * @see _.toPairsIn + */ + toPairsIn(object?: object): Array<[string, any]>; + } + interface LoDashImplicitWrapper { + /** + * @see _.toPairsIn + */ + toPairsIn(): Collection<[string, TValue extends Dictionary ? U : TValue extends NumericDictionary ? V : any]>; + } + interface LoDashExplicitWrapper { + /** + * @see _.toPairsIn + */ + toPairsIn(): CollectionChain<[string, TValue extends Dictionary ? U : TValue extends NumericDictionary ? V : any]>; + } + interface LoDashStatic { + /** + * An alternative to _.reduce; this method transforms object to a new accumulator object which is the result of + * running each of its own enumerable properties through iteratee, with each invocation potentially mutating + * the accumulator object. The iteratee is invoked with four arguments: (accumulator, + * value, key, object). Iteratee functions may exit iteration early by explicitly returning false. + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @param accumulator The custom accumulator value. + * @return Returns the accumulated value. + */ + transform(object: T[], iteratee: MemoVoidArrayIterator, accumulator?: TResult): TResult; + /** + * @see _.transform + */ + transform(object: Dictionary, iteratee: MemoVoidDictionaryIterator, accumulator?: TResult): TResult; + /** + * @see _.transform + */ + transform(object: any[]): any[]; + /** + * @see _.transform + */ + transform(object: object): Dictionary; + } + interface Collection { + /** + * @see _.transform + */ + transform(iteratee: MemoVoidArrayIterator, accumulator?: TResult): ImpChain; + /** + * @see _.transform + */ + transform(): Collection; + } + interface Object { + /** + * @see _.transform + */ + transform(iteratee: MemoVoidDictionaryIterator, accumulator?: TResult): ImpChain; + /** + * @see _.transform + */ + transform(): ImpChain ? Dictionary : T>; + } + interface CollectionChain { + /** + * @see _.transform + */ + transform(iteratee: MemoVoidArrayIterator, accumulator?: TResult): ExpChain; + /** + * @see _.transform + */ + transform(): CollectionChain; + } + interface ObjectChain { + /** + * @see _.transform + */ + transform(iteratee: MemoVoidDictionaryIterator, accumulator?: TResult): ExpChain; + /** + * @see _.transform + */ + transform(): ExpChain ? Dictionary : T>; + } + interface LoDashStatic { + /** + * Removes the property at path of object. + * + * Note: This method mutates object. + * + * @param object The object to modify. + * @param path The path of the property to unset. + * @return Returns true if the property is deleted, else false. + */ + unset(object: any, path: PropertyPath): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.unset + */ + unset(path: PropertyPath): Primitive; + } + interface LoDashExplicitWrapper { + /** + * @see _.unset + */ + unset(path: PropertyPath): PrimitiveChain; + } + interface LoDashStatic { + /** + * This method is like _.set except that accepts updater to produce the value to set. Use _.updateWith to + * customize path creation. The updater is invoked with one argument: (value). + * + * @param object The object to modify. + * @param path The path of the property to set. + * @param updater The function to produce the updated value. + * @return Returns object. + */ + update(object: object, path: PropertyPath, updater: (value: any) => any): any; + } + interface LoDashImplicitWrapper { + /** + * @see _.update + */ + update(path: PropertyPath, updater: (value: any) => any): Object; + } + interface LoDashExplicitWrapper { + /** + * @see _.update + */ + update(path: PropertyPath, updater: (value: any) => any): ObjectChain; + } + interface LoDashStatic { + /** + * This method is like `_.update` except that it accepts `customizer` which is + * invoked to produce the objects of `path`. If `customizer` returns `undefined` + * path creation is handled by the method instead. The `customizer` is invoked + * with three arguments: (nsValue, key, nsObject). + * + * **Note:** This method mutates `object`. + * + * @since 4.6.0 + * @category Object + * @param object The object to modify. + * @param path The path of the property to set. + * @param updater The function to produce the updated value. + * @param [customizer] The function to customize assigned values. + * @returns Returns `object`. + * @example + * + * var object = {}; + * + * _.updateWith(object, '[0][1]', _.constant('a'), Object); + * // => { '0': { '1': 'a' } } + */ + updateWith(object: T, path: PropertyPath, updater: (oldValue: any) => any, customizer?: SetWithCustomizer): T; + /** + * @see _.updateWith + */ + updateWith(object: T, path: PropertyPath, updater: (oldValue: any) => any, customizer?: SetWithCustomizer): TResult; + } + interface Object { + /** + * @see _.updateWith + */ + updateWith(path: PropertyPath, updater: (oldValue: any) => any, customizer?: SetWithCustomizer): this; + /** + * @see _.updateWith + */ + updateWith(path: PropertyPath, updater: (oldValue: any) => any, customizer?: SetWithCustomizer): Object; + } + interface ObjectChain { + /** + * @see _.updateWith + */ + updateWith(path: PropertyPath, updater: (oldValue: any) => any, customizer?: SetWithCustomizer): this; + /** + * @see _.updateWith + */ + updateWith(path: PropertyPath, updater: (oldValue: any) => any, customizer?: SetWithCustomizer): ObjectChain; + } + interface LoDashStatic { + /** + * Creates an array of the own enumerable property values of object. + * + * @param object The object to query. + * @return Returns an array of property values. + */ + values(object: Dictionary | NumericDictionary | List | null | undefined): T[]; + /** + * @see _.values + */ + values(object: T | null | undefined): Array; + /** + * @see _.values + */ + values(object: any): any[]; + } + interface String { + /** + * @see _.values + */ + values(): Collection; + } + interface Object { + /** + * @see _.values + */ + values(): Collection; + } + interface ObjectChain { + /** + * @see _.values + */ + values(): CollectionChain; + } + interface StringChain { + /** + * @see _.values + */ + values(): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.values + */ + values(): CollectionChain; + } + interface LoDashStatic { + /** + * Creates an array of the own and inherited enumerable property values of object. + * + * @param object The object to query. + * @return Returns the array of property values. + */ + valuesIn(object: Dictionary | NumericDictionary | List | null | undefined): T[]; + /** + * @see _.valuesIn + */ + valuesIn(object: T | null | undefined): Array; + } + interface String { + /** + * @see _.valuesIn + */ + valuesIn(): Collection; + } + interface Object { + /** + * @see _.valuesIn + */ + valuesIn(): Collection; + } + interface StringChain { + /** + * @see _.valuesIn + */ + valuesIn(): CollectionChain; + } + interface StringNullableChain { + /** + * @see _.valuesIn + */ + valuesIn(): CollectionChain; + } + interface ObjectChain { + /** + * @see _.valuesIn + */ + valuesIn(): CollectionChain; + } +} diff --git a/types/lodash/ts3.1/common/seq.d.ts b/types/lodash/ts3.1/common/seq.d.ts new file mode 100644 index 0000000000..8a0ef1ce18 --- /dev/null +++ b/types/lodash/ts3.1/common/seq.d.ts @@ -0,0 +1,210 @@ +import _ = require("../index"); +declare module "../index" { + // chain + interface LoDashStatic { + /** + * Creates a lodash object that wraps value with explicit method chaining enabled. + * + * @param value The value to wrap. + * @return Returns the new lodash wrapper instance. + */ + chain(value: TrapAny): CollectionChain & FunctionChain & ObjectChain & PrimitiveChain & StringChain; + /** + * @see _.chain + */ + chain(value: T): PrimitiveChain; + /** + * @see _.chain + */ + chain(value: string): StringChain; + /** + * @see _.chain + */ + chain(value: string | null | undefined): StringNullableChain; + /** + * @see _.chain + */ + chain any>(value: T): FunctionChain; + /** + * @see _.chain + */ + chain(value: List | null | undefined): CollectionChain; + /** + * @see _.chain + */ + chain(value: T | null | undefined): ObjectChain; + /** + * @see _.chain + */ + chain(value: T): PrimitiveChain; + } + interface Collection { + /** + * @see _.chain + */ + chain(): CollectionChain; + } + interface String { + /** + * @see _.chain + */ + chain(): StringChain; + } + interface Object { + /** + * @see _.chain + */ + chain(): ObjectChain; + } + interface Primitive { + /** + * @see _.chain + */ + chain(): PrimitiveChain; + } + interface Function any> { + /** + * @see _.chain + */ + chain(): FunctionChain; + } + interface LoDashExplicitWrapper { + /** + * @see _.chain + */ + chain(): this; + } + // prototype.commit + interface LoDashImplicitWrapper { + /** + * @see _.commit + */ + commit(): this; + } + interface LoDashExplicitWrapper { + /** + * @see _.commit + */ + commit(): this; + } + // prototype.plant + interface LoDashImplicitWrapper { + /** + * @see _.plant + */ + plant(value: unknown): this; + } + interface LoDashExplicitWrapper { + /** + * @see _.plant + */ + plant(value: unknown): this; + } + // prototype.reverse + interface LoDashImplicitWrapper { + /** + * @see _.reverse + */ + reverse(): this; + } + interface LoDashExplicitWrapper { + /** + * @see _.reverse + */ + reverse(): this; + } + // prototype.toJSON + interface LoDashImplicitWrapper { + /** + * @see _.toJSON + */ + toJSON(): TValue; + } + interface LoDashExplicitWrapper { + /** + * @see _.toJSON + */ + toJSON(): TValue; + } + // prototype.toString + interface LoDashWrapper { + /** + * @see _.toString + */ + toString(): string; + } + // prototype.value + interface LoDashImplicitWrapper { + /** + * @see _.value + */ + value(): TValue; + } + interface LoDashExplicitWrapper { + /** + * @see _.value + */ + value(): TValue; + } + // prototype.valueOf + interface LoDashImplicitWrapper { + /** + * @see _.valueOf + */ + valueOf(): TValue; + } + interface LoDashExplicitWrapper { + /** + * @see _.valueOf + */ + valueOf(): TValue; + } + // tap + interface LoDashStatic { + /** + * This method invokes interceptor and returns value. The interceptor is invoked with one + * argument; (value). The purpose of this method is to "tap into" a method chain in order to perform operations + * on intermediate results within the chain. + * + * @param value The value to provide to interceptor. + * @param interceptor The function to invoke. + * @return Returns value. + */ + tap(value: T, interceptor: (value: T) => void): T; + } + interface LoDashImplicitWrapper { + /** + * @see _.tap + */ + tap(interceptor: (value: TValue) => void): this; + } + interface LoDashExplicitWrapper { + /** + * @see _.tap + */ + tap(interceptor: (value: TValue) => void): this; + } + // thru + interface LoDashStatic { + /** + * This method is like _.tap except that it returns the result of interceptor. + * + * @param value The value to provide to interceptor. + * @param interceptor The function to invoke. + * @return Returns the result of interceptor. + */ + thru(value: T, interceptor: (value: T) => TResult): TResult; + } + interface LoDashImplicitWrapper { + /** + * @see _.thru + */ + thru(interceptor: (value: TValue) => TResult): ImpChain; + } + interface LoDashExplicitWrapper { + /** + * @see _.thru + */ + thru(interceptor: (value: TValue) => TResult): ExpChain; + } +} diff --git a/types/lodash/ts3.1/common/string.d.ts b/types/lodash/ts3.1/common/string.d.ts new file mode 100644 index 0000000000..9942a6023c --- /dev/null +++ b/types/lodash/ts3.1/common/string.d.ts @@ -0,0 +1,788 @@ +import _ = require("../index"); +declare module "../index" { + interface LoDashStatic { + /** + * Converts string to camel case. + * + * @param string The string to convert. + * @return Returns the camel cased string. + */ + camelCase(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.camelCase + */ + camelCase(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.camelCase + */ + camelCase(): StringChain; + } + + interface LoDashStatic { + /** + * Converts the first character of string to upper case and the remaining to lower case. + * + * @param string The string to capitalize. + * @return Returns the capitalized string. + */ + capitalize(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.capitalize + */ + capitalize(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.capitalize + */ + capitalize(): StringChain; + } + + interface LoDashStatic { + /** + * Deburrs string by converting latin-1 supplementary letters to basic latin letters and removing combining + * diacritical marks. + * + * @param string The string to deburr. + * @return Returns the deburred string. + */ + deburr(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.deburr + */ + deburr(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.deburr + */ + deburr(): StringChain; + } + + interface LoDashStatic { + /** + * Checks if string ends with the given target string. + * + * @param string The string to search. + * @param target The string to search for. + * @param position The position to search from. + * @return Returns true if string ends with target, else false. + */ + endsWith(string?: string, target?: string, position?: number): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.endsWith + */ + endsWith(target?: string, position?: number): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.endsWith + */ + endsWith(target?: string, position?: number): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Converts the characters "&", "<", ">", '"', "'", and "`" in string to their corresponding HTML entities. + * + * Note: No other characters are escaped. To escape additional characters use a third-party library like he. + * + * hough the ">" character is escaped for symmetry, characters like ">" and "/" don’t need escaping in HTML + * and have no special meaning unless they're part of a tag or unquoted attribute value. See Mathias Bynens’s + * article (under "semi-related fun fact") for more details. + * + * Backticks are escaped because in IE < 9, they can break out of attribute values or HTML comments. See #59, + * #102, #108, and #133 of the HTML5 Security Cheatsheet for more details. + * + * When working with HTML you should always quote attribute values to reduce XSS vectors. + * + * @param string The string to escape. + * @return Returns the escaped string. + */ + escape(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.escape + */ + escape(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.escape + */ + escape(): StringChain; + } + + interface LoDashStatic { + /** + * Escapes the RegExp special characters "^", "$", "\", ".", "*", "+", "?", "(", ")", "[", "]", + * "{", "}", and "|" in string. + * + * @param string The string to escape. + * @return Returns the escaped string. + */ + escapeRegExp(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.escapeRegExp + */ + escapeRegExp(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.escapeRegExp + */ + escapeRegExp(): StringChain; + } + + interface LoDashStatic { + /** + * Converts string to kebab case. + * + * @param string The string to convert. + * @return Returns the kebab cased string. + */ + kebabCase(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.kebabCase + */ + kebabCase(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.kebabCase + */ + kebabCase(): StringChain; + } + + interface LoDashStatic { + /** + * Converts `string`, as space separated words, to lower case. + * + * @param string The string to convert. + * @return Returns the lower cased string. + */ + lowerCase(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.lowerCase + */ + lowerCase(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.lowerCase + */ + lowerCase(): StringChain; + } + + interface LoDashStatic { + /** + * Converts the first character of `string` to lower case. + * + * @param string The string to convert. + * @return Returns the converted string. + */ + lowerFirst(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.lowerFirst + */ + lowerFirst(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.lowerFirst + */ + lowerFirst(): StringChain; + } + + interface LoDashStatic { + /** + * Pads string on the left and right sides if it’s shorter than length. Padding characters are truncated if + * they can’t be evenly divided by length. + * + * @param string The string to pad. + * @param length The padding length. + * @param chars The string used as padding. + * @return Returns the padded string. + */ + pad(string?: string, length?: number, chars?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.pad + */ + pad(length?: number, chars?: string): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.pad + */ + pad(length?: number, chars?: string): StringChain; + } + + interface LoDashStatic { + /** + * Pads string on the right side if it’s shorter than length. Padding characters are truncated if they exceed + * length. + * + * @param string The string to pad. + * @param length The padding length. + * @param chars The string used as padding. + * @return Returns the padded string. + */ + padEnd(string?: string, length?: number, chars?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.padEnd + */ + padEnd(length?: number, chars?: string): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.padEnd + */ + padEnd(length?: number, chars?: string): StringChain; + } + + interface LoDashStatic { + /** + * Pads string on the left side if it’s shorter than length. Padding characters are truncated if they exceed + * length. + * + * @param string The string to pad. + * @param length The padding length. + * @param chars The string used as padding. + * @return Returns the padded string. + */ + padStart(string?: string, length?: number, chars?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.padStart + */ + padStart(length?: number, chars?: string): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.padStart + */ + padStart(length?: number, chars?: string): StringChain; + } + + interface LoDashStatic { + /** + * Converts string to an integer of the specified radix. If radix is undefined or 0, a radix of 10 is used + * unless value is a hexadecimal, in which case a radix of 16 is used. + * + * Note: This method aligns with the ES5 implementation of parseInt. + * + * @param string The string to convert. + * @param radix The radix to interpret value by. + * @return Returns the converted integer. + */ + parseInt(string: string, radix?: number): number; + } + interface LoDashImplicitWrapper { + /** + * @see _.parseInt + */ + parseInt(radix?: number): number; + } + interface LoDashExplicitWrapper { + /** + * @see _.parseInt + */ + parseInt(radix?: number): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Repeats the given string n times. + * + * @param string The string to repeat. + * @param n The number of times to repeat the string. + * @return Returns the repeated string. + */ + repeat(string?: string, n?: number): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.repeat + */ + repeat(n?: number): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.repeat + */ + repeat(n?: number): StringChain; + } + type ReplaceFunction = (match: string, ...args: any[]) => string; + + interface LoDashStatic { + /** + * Replaces matches for pattern in string with replacement. + * + * Note: This method is based on String#replace. + * + * @return Returns the modified string. + */ + replace(string: string, pattern: RegExp | string, replacement: ReplaceFunction | string): string; + /** + * @see _.replace + */ + replace(pattern: RegExp | string, replacement: ReplaceFunction | string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.replace + */ + replace(pattern: RegExp | string, replacement: ReplaceFunction | string): string; + /** + * @see _.replace + */ + replace(replacement: ReplaceFunction | string): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.replace + */ + replace(pattern: RegExp | string, replacement: ReplaceFunction | string): StringChain; + /** + * @see _.replace + */ + replace(replacement: ReplaceFunction | string): StringChain; + } + + interface LoDashStatic { + /** + * Converts string to snake case. + * + * @param string The string to convert. + * @return Returns the snake cased string. + */ + snakeCase(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.snakeCase + */ + snakeCase(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.snakeCase + */ + snakeCase(): StringChain; + } + + interface LoDashStatic { + /** + * Splits string by separator. + * + * Note: This method is based on String#split. + * + * @param string The string to trim. + * @param separator The separator pattern to split by. + * @param limit The length to truncate results to. + * @return Returns the new array of string segments. + */ + split(string: string, separator?: RegExp | string, limit?: number): string[]; + /** + * @see _.split + */ + split(string: string, index: string | number, guard: object): string[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.split + */ + split(separator?: RegExp | string, limit?: number): Collection; + } + interface LoDashExplicitWrapper { + /** + * @see _.split + */ + split(separator?: RegExp | string, limit?: number): CollectionChain; + } + + interface LoDashStatic { + /** + * Converts string to start case. + * + * @param string The string to convert. + * @return Returns the start cased string. + */ + startCase(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.startCase + */ + startCase(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.startCase + */ + startCase(): StringChain; + } + + interface LoDashStatic { + /** + * Checks if string starts with the given target string. + * + * @param string The string to search. + * @param target The string to search for. + * @param position The position to search from. + * @return Returns true if string starts with target, else false. + */ + startsWith(string?: string, target?: string, position?: number): boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.startsWith + */ + startsWith(target?: string, position?: number): boolean; + } + interface LoDashExplicitWrapper { + /** + * @see _.startsWith + */ + startsWith(target?: string, position?: number): PrimitiveChain; + } + + interface TemplateOptions extends TemplateSettings { + /** + * @see _.sourceURL + */ + sourceURL?: string; + } + interface TemplateExecutor { + (data?: object): string; + /** + * @see _.source + */ + source: string; + } + interface LoDashStatic { + /** + * Creates a compiled template function that can interpolate data properties in "interpolate" delimiters, + * HTML-escape interpolated data properties in "escape" delimiters, and execute JavaScript in "evaluate" + * delimiters. Data properties may be accessed as free variables in the template. If a setting object is + * provided it takes precedence over _.templateSettings values. + * + * Note: In the development build _.template utilizes + * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) for easier + * debugging. + * + * For more information on precompiling templates see + * [lodash's custom builds documentation](https://lodash.com/custom-builds). + * + * For more information on Chrome extension sandboxes see + * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). + * + * @param string The template string. + * @param options The options object. + * @param options.escape The HTML "escape" delimiter. + * @param options.evaluate The "evaluate" delimiter. + * @param options.imports An object to import into the template as free variables. + * @param options.interpolate The "interpolate" delimiter. + * @param options.sourceURL The sourceURL of the template's compiled source. + * @param options.variable The data object variable name. + * @return Returns the compiled template function. + */ + template(string?: string, options?: TemplateOptions): TemplateExecutor; + } + interface LoDashImplicitWrapper { + /** + * @see _.template + */ + template(options?: TemplateOptions): TemplateExecutor; + } + interface LoDashExplicitWrapper { + /** + * @see _.template + */ + template(options?: TemplateOptions): FunctionChain; + } + + interface LoDashStatic { + /** + * Converts `string`, as a whole, to lower case. + * + * @param string The string to convert. + * @return Returns the lower cased string. + */ + toLower(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.toLower + */ + toLower(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.toLower + */ + toLower(): StringChain; + } + + interface LoDashStatic { + /** + * Converts `string`, as a whole, to upper case. + * + * @param string The string to convert. + * @return Returns the upper cased string. + */ + toUpper(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.toUpper + */ + toUpper(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.toUpper + */ + toUpper(): StringChain; + } + + interface LoDashStatic { + /** + * Removes leading and trailing whitespace or specified characters from string. + * + * @param string The string to trim. + * @param chars The characters to trim. + * @return Returns the trimmed string. + */ + trim(string?: string, chars?: string): string; + /** + * @see _.trim + */ + trim(string: string, index: string | number, guard: object): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.trim + */ + trim(chars?: string): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.trim + */ + trim(chars?: string): StringChain; + } + + interface LoDashStatic { + /** + * Removes trailing whitespace or specified characters from string. + * + * @param string The string to trim. + * @param chars The characters to trim. + * @return Returns the trimmed string. + */ + trimEnd(string?: string, chars?: string): string; + /** + * @see _.trimEnd + */ + trimEnd(string: string, index: string | number, guard: object): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.trimEnd + */ + trimEnd(chars?: string): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.trimEnd + */ + trimEnd(chars?: string): StringChain; + } + + interface LoDashStatic { + /** + * Removes leading whitespace or specified characters from string. + * + * @param string The string to trim. + * @param chars The characters to trim. + * @return Returns the trimmed string. + */ + trimStart(string?: string, chars?: string): string; + /** + * @see _.trimStart + */ + trimStart(string: string, index: string | number, guard: object): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.trimStart + */ + trimStart(chars?: string): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.trimStart + */ + trimStart(chars?: string): StringChain; + } + + interface TruncateOptions { + /** + * @see _.length + */ + length?: number; + /** + * @see _.omission + */ + omission?: string; + /** + * @see _.separator + */ + separator?: string | RegExp; + } + interface LoDashStatic { + /** + * Truncates string if it’s longer than the given maximum string length. The last characters of the truncated + * string are replaced with the omission string which defaults to "…". + * + * @param string The string to truncate. + * @param options The options object or maximum string length. + * @return Returns the truncated string. + */ + truncate(string?: string, options?: TruncateOptions): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.truncate + */ + truncate(options?: TruncateOptions): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.truncate + */ + truncate(options?: TruncateOptions): StringChain; + } + + interface LoDashStatic { + /** + * The inverse of _.escape; this method converts the HTML entities &, <, >, ", ', and ` + * in string to their corresponding characters. + * + * Note: No other HTML entities are unescaped. To unescape additional HTML entities use a third-party library + * like he. + * + * @param string The string to unescape. + * @return Returns the unescaped string. + */ + unescape(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.unescape + */ + unescape(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.unescape + */ + unescape(): StringChain; + } + + interface LoDashStatic { + /** + * Converts `string`, as space separated words, to upper case. + * + * @param string The string to convert. + * @return Returns the upper cased string. + */ + upperCase(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.upperCase + */ + upperCase(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.upperCase + */ + upperCase(): StringChain; + } + + interface LoDashStatic { + /** + * Converts the first character of `string` to upper case. + * + * @param string The string to convert. + * @return Returns the converted string. + */ + upperFirst(string?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.upperFirst + */ + upperFirst(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.upperFirst + */ + upperFirst(): StringChain; + } + + interface LoDashStatic { + /** + * Splits `string` into an array of its words. + * + * @param string The string to inspect. + * @param pattern The pattern to match words. + * @return Returns the words of `string`. + */ + words(string?: string, pattern?: string | RegExp): string[]; + /** + * @see _.words + */ + words(string: string, index: string | number, guard: object): string[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.words + */ + words(pattern?: string | RegExp): string[]; + } + interface LoDashExplicitWrapper { + /** + * @see _.words + */ + words(pattern?: string | RegExp): CollectionChain; + } +} diff --git a/types/lodash/ts3.1/common/util.d.ts b/types/lodash/ts3.1/common/util.d.ts new file mode 100644 index 0000000000..8e7e50a738 --- /dev/null +++ b/types/lodash/ts3.1/common/util.d.ts @@ -0,0 +1,1161 @@ +import _ = require("../index"); +declare module "../index" { + interface LoDashStatic { + /** + * Attempts to invoke func, returning either the result or the caught error object. Any additional arguments + * are provided to func when it’s invoked. + * + * @param func The function to attempt. + * @return Returns the func result or error object. + */ + attempt(func: (...args: any[]) => TResult, ...args: any[]): TResult | Error; + } + interface LoDashImplicitWrapper { + /** + * @see _.attempt + */ + attempt(...args: any[]): TResult | Error; + } + interface LoDashExplicitWrapper { + /** + * @see _.attempt + */ + attempt(...args: any[]): ExpChain; + } + + interface LoDashStatic { + /** + * Binds methods of an object to the object itself, overwriting the existing method. Method names may be + * specified as individual arguments or as arrays of method names. If no method names are provided all + * enumerable function properties, own and inherited, of object are bound. + * + * Note: This method does not set the "length" property of bound functions. + * + * @param object The object to bind and assign the bound methods to. + * @param methodNames The object method names to bind, specified as individual method names or arrays of + * method names. + * @return Returns object. + */ + bindAll(object: T, ...methodNames: Array>): T; + } + interface LoDashImplicitWrapper { + /** + * @see _.bindAll + */ + bindAll(...methodNames: Array>): this; + } + interface LoDashExplicitWrapper { + /** + * @see _.bindAll + */ + bindAll(...methodNames: Array>): this; + } + + interface LoDashStatic { + /** + * Creates a function that iterates over `pairs` and invokes the corresponding + * function of the first predicate to return truthy. The predicate-function + * pairs are invoked with the `this` binding and arguments of the created + * function. + * + * @since 4.0.0 + * @category Util + * @param pairs The predicate-function pairs. + * @returns Returns the new composite function. + * @example + * + * var func = _.cond([ + * [_.matches({ 'a': 1 }), _.constant('matches A')], + * [_.conforms({ 'b': _.isNumber }), _.constant('matches B')], + * [_.stubTrue, _.constant('no match')] + * ]); + * + * func({ 'a': 1, 'b': 2 }); + * // => 'matches A' + * + * func({ 'a': 0, 'b': 1 }); + * // => 'matches B' + * + * func({ 'a': '1', 'b': '2' }); + * // => 'no match' + */ + cond(pairs: Array>): (Target: T) => R; + } + + type ConformsPredicateObject = { + [P in keyof T]: T[P] extends (arg: infer A) => any ? A : any + }; + interface LoDashStatic { + /** + * Creates a function that invokes the predicate properties of `source` with the corresponding + * property values of a given object, returning true if all predicates return truthy, else false. + */ + conforms(source: ConformsPredicateObject): (value: T) => boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.conforms + */ + conforms(): Function<(value: ConformsPredicateObject) => boolean>; + } + interface LoDashExplicitWrapper { + /** + * @see _.conforms + */ + conforms(): FunctionChain<(value: ConformsPredicateObject) => boolean>; + } + + interface LoDashStatic { + /** + * Creates a function that returns value. + * + * @param value The value to return from the new function. + * @return Returns the new function. + */ + constant(value: T): () => T; + } + interface LoDashImplicitWrapper { + /** + * @see _.constant + */ + constant(): Function<() => TValue>; + } + interface LoDashExplicitWrapper { + /** + * @see _.constant + */ + constant(): FunctionChain<() => TValue>; + } + + interface LoDashStatic { + /** + * Checks `value` to determine whether a default value should be returned in + * its place. The `defaultValue` is returned if `value` is `NaN`, `null`, + * or `undefined`. + * + * @param value The value to check. + * @param defaultValue The default value. + * @returns Returns the resolved value. + */ + defaultTo(value: T | null | undefined, defaultValue: T): T; + /** + * @see _.defaultTo + */ + defaultTo(value: T | null | undefined, defaultValue: TDefault): T | TDefault; + } + interface LoDashImplicitWrapper { + /** + * @see _.defaultTo + */ + defaultTo(defaultValue: TValue): TValue; + /** + * @see _.defaultTo + */ + defaultTo(defaultValue: TDefault): TValue extends null | undefined ? TDefault : TValue | TDefault; + } + interface LoDashExplicitWrapper { + /** + * @see _.defaultTo + */ + defaultTo(defaultValue: TValue): ExpChain; + /** + * @see _.defaultTo + */ + defaultTo(defaultValue: TDefault): ExpChain; + } + + interface LoDashStatic { + /** + * Creates a function that returns the result of invoking the provided functions with the this binding of the + * created function, where each successive invocation is supplied the return value of the previous. + * + * @param funcs Functions to invoke. + * @return Returns the new function. + */ + flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (...args: A) => R7; + /** + * @see _.flow + */ + flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array any>>): (...args: A) => any; + /** + * @see _.flow + */ + flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (...args: A) => R6; + /** + * @see _.flow + */ + flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5; + /** + * @see _.flow + */ + flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4; + /** + * @see _.flow + */ + flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3; + /** + * @see _.flow + */ + flow(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2; + /** + * @see _.flow + */ + flow(...func: Array any>>): (...args: any[]) => any; + } + interface Function any> { + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): Function<(...args: Parameters) => R7>; + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array any>>): Function<(...args: Parameters) => any>; + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): Function<(...args: Parameters) => R6>; + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): Function<(...args: Parameters) => R5>; + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): Function<(...args: Parameters) => R4>; + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3): Function<(...args: Parameters) => R3>; + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2): Function<(...args: Parameters) => R2>; + /** + * @see _.flow + */ + flow(...func: Array any>>): Function<(...args: any[]) => any>; + } + interface FunctionChain { + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): FunctionChain<(...args: Parameters) => R7>; + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array any>>): FunctionChain<(...args: Parameters) => any>; + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): FunctionChain<(...args: Parameters) => R6>; + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): FunctionChain<(...args: Parameters) => R5>; + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): FunctionChain<(...args: Parameters) => R4>; + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2, f3: (a: R2) => R3): FunctionChain<(...args: Parameters) => R3>; + /** + * @see _.flow + */ + flow(f2: (a: ReturnType) => R2): FunctionChain<(...args: Parameters) => R2>; + /** + * @see _.flow + */ + flow(...func: Array any>>): FunctionChain<(...args: any[]) => any>; + } + + interface LoDashStatic { + /** + * This method is like _.flow except that it creates a function that invokes the provided functions from right + * to left. + * + * @param funcs Functions to invoke. + * @return Returns the new function. + */ + flowRight(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R7; + /** + * @see _.flowRight + */ + flowRight(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R6; + /** + * @see _.flowRight + */ + flowRight(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R5; + /** + * @see _.flowRight + */ + flowRight(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R4; + /** + * @see _.flowRight + */ + flowRight(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R3; + /** + * @see _.flowRight + */ + flowRight(f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R2; + /** + * @see _.flowRight + */ + flowRight(...func: Array any>>): (...args: any[]) => any; + } + interface Function { + /** + * @see _.flowRight + */ + flowRight(f6: (a: R5) => Parameters["0"], f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): Function<(...args: A) => ReturnType>; + /** + * @see _.flowRight + */ + flowRight(f5: (a: R4) => Parameters["0"], f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): Function<(...args: A) => ReturnType>; + /** + * @see _.flowRight + */ + flowRight(f4: (a: R3) => Parameters["0"], f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): Function<(...args: A) => ReturnType>; + /** + * @see _.flowRight + */ + flowRight(f3: (a: R2) => Parameters["0"], f2: (a: R1) => R2, f1: (...args: A) => R1): Function<(...args: A) => ReturnType>; + /** + * @see _.flowRight + */ + flowRight(f2: (a: R1) => Parameters["0"], f1: (...args: A) => R1): Function<(...args: A) => ReturnType>; + /** + * @see _.flowRight + */ + flowRight(f1: (...args: A) => Parameters["0"]): Function<(...args: A) => ReturnType>; + /** + * @see _.flowRight + */ + flowRight(...func: Array any>>): Function<(...args: any[]) => any>; + } + interface FunctionChain { + /** + * @see _.flowRight + */ + flowRight(f6: (a: R5) => Parameters["0"], f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType>; + /** + * @see _.flowRight + */ + flowRight(f5: (a: R4) => Parameters["0"], f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType>; + /** + * @see _.flowRight + */ + flowRight(f4: (a: R3) => Parameters["0"], f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType>; + /** + * @see _.flowRight + */ + flowRight(f3: (a: R2) => Parameters["0"], f2: (a: R1) => R2, f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType>; + /** + * @see _.flowRight + */ + flowRight(f2: (a: R1) => Parameters["0"], f1: (...args: A) => R1): FunctionChain<(...args: A) => ReturnType>; + /** + * @see _.flowRight + */ + flowRight(f1: (...args: A) => Parameters["0"]): FunctionChain<(...args: A) => ReturnType>; + /** + * @see _.flowRight + */ + flowRight(...func: Array any>>): FunctionChain<(...args: any[]) => any>; + } + + interface LoDashStatic { + /** + * This method returns the first argument provided to it. + * + * @param value Any value. + * @return Returns value. + */ + identity(value: T): T; + /** + * @see _.identity + */ + identity(): undefined; + } + interface LoDashImplicitWrapper { + /** + * @see _.identity + */ + identity(): TValue; + } + interface LoDashExplicitWrapper { + /** + * @see _.identity + */ + identity(): this; + } + + interface LoDashStatic { + /** + * Creates a function that invokes `func` with the arguments of the created + * function. If `func` is a property name the created callback returns the + * property value for a given element. If `func` is an object the created + * callback returns `true` for elements that contain the equivalent object properties, otherwise it returns `false`. + * + * @category Util + * @param [func=_.identity] The value to convert to a callback. + * @returns Returns the callback. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 } + * ]; + * + * // create custom iteratee shorthands + * _.iteratee = _.wrap(_.iteratee, function(callback, func) { + * var p = /^(\S+)\s*([<>])\s*(\S+)$/.exec(func); + * return !p ? callback(func) : function(object) { + * return (p[2] == '>' ? object[p[1]] > p[3] : object[p[1]] < p[3]); + * }; + * }); + * + * _.filter(users, 'age > 36'); + * // => [{ 'user': 'fred', 'age': 40 }] + */ + iteratee any>(func: TFunction): TFunction; + /** + * @see _.iteratee + */ + iteratee(func: string | object): (...args: any[]) => any; + } + interface Function any> { + /** + * @see _.iteratee + */ + iteratee(): Function; + } + interface Collection { + /** + * @see _.iteratee + */ + iteratee(): Function<(o: object) => boolean>; + } + interface Object { + /** + * @see _.iteratee + */ + iteratee(): Function<(o: T) => boolean>; + } + interface String { + /** + * @see _.iteratee + */ + iteratee(): Function<(o: object) => any>; + } + interface FunctionChain any> { + /** + * @see _.iteratee + */ + iteratee(): FunctionChain; + } + interface CollectionChain { + /** + * @see _.iteratee + */ + iteratee(): FunctionChain<(o: object) => boolean>; + } + interface ObjectChain { + /** + * @see _.iteratee + */ + iteratee(): FunctionChain<(o: T) => boolean>; + } + interface StringChain { + /** + * @see _.iteratee + */ + iteratee(): FunctionChain<(o: object) => any>; + } + interface StringNullableChain { + /** + * @see _.iteratee + */ + iteratee(): FunctionChain<(o: object) => any>; + } + + interface LoDashStatic { + /** + * Creates a function that performs a deep comparison between a given object and source, returning true if the + * given object has equivalent property values, else false. + * + * Note: This method supports comparing arrays, booleans, Date objects, numbers, Object objects, regexes, and + * strings. Objects are compared by their own, not inherited, enumerable properties. For comparing a single own + * or inherited property value see _.matchesProperty. + * + * @param source The object of property values to match. + * @return Returns the new function. + */ + matches(source: T): (value: any) => boolean; + /** + * @see _.matches + */ + matches(source: T): (value: V) => boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.matches + */ + matches(): Function<(value: V) => boolean>; + } + interface LoDashExplicitWrapper { + /** + * @see _.matches + */ + matches(): FunctionChain<(value: V) => boolean>; + } + + interface LoDashStatic { + /** + * Creates a function that compares the property value of path on a given object to value. + * + * Note: This method supports comparing arrays, booleans, Date objects, numbers, Object objects, regexes, and + * strings. Objects are compared by their own, not inherited, enumerable properties. + * + * @param path The path of the property to get. + * @param srcValue The value to match. + * @return Returns the new function. + */ + matchesProperty(path: PropertyPath, srcValue: T): (value: any) => boolean; + /** + * @see _.matchesProperty + */ + matchesProperty(path: PropertyPath, srcValue: T): (value: V) => boolean; + } + interface LoDashImplicitWrapper { + /** + * @see _.matchesProperty + */ + matchesProperty(srcValue: SrcValue): Function<(value: any) => boolean>; + /** + * @see _.matchesProperty + */ + matchesProperty(srcValue: SrcValue): Function<(value: Value) => boolean>; + } + interface LoDashExplicitWrapper { + /** + * @see _.matchesProperty + */ + matchesProperty(srcValue: SrcValue): FunctionChain<(value: any) => boolean>; + /** + * @see _.matchesProperty + */ + matchesProperty(srcValue: SrcValue): FunctionChain<(value: Value) => boolean>; + } + + interface LoDashStatic { + /** + * Creates a function that invokes the method at path on a given object. Any additional arguments are provided + * to the invoked method. + * + * @param path The path of the method to invoke. + * @param args The arguments to invoke the method with. + * @return Returns the new function. + */ + method(path: PropertyPath, ...args: any[]): (object: any) => any; + } + interface LoDashImplicitWrapper { + /** + * @see _.method + */ + method(...args: any[]): Function<(object: any) => any>; + } + interface LoDashExplicitWrapper { + /** + * @see _.method + */ + method(...args: any[]): FunctionChain<(object: any) => any>; + } + + interface LoDashStatic { + /** + * The opposite of _.method; this method creates a function that invokes the method at a given path on object. + * Any additional arguments are provided to the invoked method. + * + * @param object The object to query. + * @param args The arguments to invoke the method with. + * @return Returns the new function. + */ + methodOf(object: object, ...args: any[]): (path: PropertyPath) => any; + } + interface LoDashImplicitWrapper { + /** + * @see _.methodOf + */ + methodOf(...args: any[]): LoDashImplicitWrapper<(path: PropertyPath) => any>; + } + interface LoDashExplicitWrapper { + /** + * @see _.methodOf + */ + methodOf(...args: any[]): LoDashExplicitWrapper<(path: PropertyPath) => any>; + } + + interface MixinOptions { + /** + * @see _.chain + */ + chain?: boolean; + } + interface LoDashStatic { + /** + * Adds all own enumerable function properties of a source object to the destination object. If object is a + * function then methods are added to its prototype as well. + * + * Note: Use _.runInContext to create a pristine lodash function to avoid conflicts caused by modifying + * the original. + * + * @param object The destination object. + * @param source The object of functions to add. + * @param options The options object. + * @param options.chain Specify whether the functions added are chainable. + * @return Returns object. + */ + mixin(object: TObject, source: Dictionary<(...args: any[]) => any>, options?: MixinOptions): TObject; + /** + * @see _.mixin + */ + mixin(source: Dictionary<(...args: any[]) => any>, options?: MixinOptions): LoDashStatic; + } + interface LoDashImplicitWrapper { + /** + * @see _.mixin + */ + mixin(source: Dictionary<(...args: any[]) => any>, options?: MixinOptions): this; + /** + * @see _.mixin + */ + mixin(options?: MixinOptions): LoDashImplicitWrapper; + } + interface LoDashExplicitWrapper { + /** + * @see _.mixin + */ + mixin(source: Dictionary<(...args: any[]) => any>, options?: MixinOptions): this; + /** + * @see _.mixin + */ + mixin(options?: MixinOptions): LoDashExplicitWrapper; + } + + interface LoDashStatic { + /** + * Reverts the _ variable to its previous value and returns a reference to the lodash function. + * + * @return Returns the lodash function. + */ + noConflict(): typeof _; + } + interface LoDashImplicitWrapper { + /** + * @see _.noConflict + */ + noConflict(): typeof _; + } + interface LoDashExplicitWrapper { + /** + * @see _.noConflict + */ + noConflict(): LoDashExplicitWrapper; + } + + interface LoDashStatic { + /** + * A no-operation function that returns undefined regardless of the arguments it receives. + * + * @return undefined + */ + noop(...args: any[]): void; + } + interface LoDashImplicitWrapper { + /** + * @see _.noop + */ + noop(...args: any[]): void; + } + interface LoDashExplicitWrapper { + /** + * @see _.noop + */ + noop(...args: any[]): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Creates a function that returns its nth argument. + * + * @param n The index of the argument to return. + * @return Returns the new function. + */ + nthArg(n?: number): (...args: any[]) => any; + } + interface LoDashImplicitWrapper { + /** + * @see _.nthArg + */ + nthArg(): Function<(...args: any[]) => any>; + } + interface LoDashExplicitWrapper { + /** + * @see _.nthArg + */ + nthArg(): FunctionChain<(...args: any[]) => any>; + } + + interface LoDashStatic { + /** + * Creates a function that invokes iteratees with the arguments provided to the created function and returns + * their results. + * + * @param iteratees The iteratees to invoke. + * @return Returns the new function. + */ + over(...iteratees: Array TResult>>): (...args: any[]) => TResult[]; + } + interface Collection { + /** + * @see _.over + */ + over(...iteratees: Array TResult>>): Function<(...args: any[]) => TResult[]>; + } + interface Function { + /** + * @see _.over + */ + over(...iteratees: Array TResult>>): Function<(...args: any[]) => Array | TResult>>; + } + interface CollectionChain { + /** + * @see _.over + */ + over(...iteratees: Array TResult>>): FunctionChain<(...args: any[]) => TResult[]>; + } + interface FunctionChain { + /** + * @see _.over + */ + over(...iteratees: Array TResult>>): FunctionChain<(...args: any[]) => Array | TResult>>; + } + + interface LoDashStatic { + /** + * Creates a function that checks if all of the predicates return truthy when invoked with the arguments + * provided to the created function. + * + * @param predicates The predicates to check. + * @return Returns the new function. + */ + overEvery(...predicates: Array boolean>>): (...args: T[]) => boolean; + } + interface Collection { + /** + * @see _.overEvery + */ + overEvery(...iteratees: Array boolean>>): Function<(...args: TArgs[]) => boolean>; + } + interface Function { + /** + * @see _.overEvery + */ + overEvery(...iteratees: Array boolean>>): Function<(...args: Parameters | TArgs[]) => boolean>; + } + interface CollectionChain { + /** + * @see _.overEvery + */ + overEvery(...iteratees: Array boolean>>): FunctionChain<(...args: TArgs[]) => boolean>; + } + interface FunctionChain { + /** + * @see _.overEvery + */ + overEvery(...iteratees: Array boolean>>): FunctionChain<(...args: Parameters | TArgs[]) => boolean>; + } + + interface LoDashStatic { + /** + * Creates a function that checks if any of the predicates return truthy when invoked with the arguments + * provided to the created function. + * + * @param predicates The predicates to check. + * @return Returns the new function. + */ + overSome(...predicates: Array boolean>>): (...args: T[]) => boolean; + } + interface Collection { + /** + * @see _.overSome + */ + overSome(...iteratees: Array boolean>>): Function<(...args: TArgs[]) => boolean>; + } + interface Function { + /** + * @see _.overSome + */ + overSome(...iteratees: Array boolean>>): Function<(...args: Parameters | TArgs[]) => boolean>; + } + interface CollectionChain { + /** + * @see _.overSome + */ + overSome(...iteratees: Array boolean>>): FunctionChain<(...args: TArgs[]) => boolean>; + } + interface FunctionChain { + /** + * @see _.overSome + */ + overSome(...iteratees: Array boolean>>): FunctionChain<(...args: Parameters | TArgs[]) => boolean>; + } + + interface LoDashStatic { + /** + * Creates a function that returns the property value at path on a given object. + * + * @param path The path of the property to get. + * @return Returns the new function. + */ + property(path: PropertyPath): (obj: TObj) => TResult; + } + interface LoDashImplicitWrapper { + /** + * @see _.property + */ + property(): Function<(obj: TObj) => TResult>; + } + interface LoDashExplicitWrapper { + /** + * @see _.property + */ + property(): FunctionChain<(obj: TObj) => TResult>; + } + + interface LoDashStatic { + /** + * The opposite of _.property; this method creates a function that returns the property value at a given path + * on object. + * + * @param object The object to query. + * @return Returns the new function. + */ + propertyOf(object: T): (path: PropertyPath) => any; + } + interface LoDashImplicitWrapper { + /** + * @see _.propertyOf + */ + propertyOf(): LoDashImplicitWrapper<(path: PropertyPath) => any>; + } + interface LoDashExplicitWrapper { + /** + * @see _.propertyOf + */ + propertyOf(): LoDashExplicitWrapper<(path: PropertyPath) => any>; + } + + interface LoDashStatic { + /** + * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end. + * If end is not specified it’s set to start with start then set to 0. If end is less than start a zero-length + * range is created unless a negative step is specified. + * + * @param start The start of the range. + * @param end The end of the range. + * @param step The value to increment or decrement by. + * @return Returns a new range array. + */ + range(start: number, end?: number, step?: number): number[]; + /** + * @see _.range + */ + range(end: number, index: string | number, guard: object): number[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.range + */ + range(end?: number, step?: number): Collection; + } + interface LoDashExplicitWrapper { + /** + * @see _.range + */ + range(end?: number, step?: number): CollectionChain; + } + + interface LoDashStatic { + /** + * This method is like `_.range` except that it populates values in + * descending order. + * + * @category Util + * @param start The start of the range. + * @param end The end of the range. + * @param step The value to increment or decrement by. + * @returns Returns the new array of numbers. + * @example + * + * _.rangeRight(4); + * // => [3, 2, 1, 0] + * + * _.rangeRight(-4); + * // => [-3, -2, -1, 0] + * + * _.rangeRight(1, 5); + * // => [4, 3, 2, 1] + * + * _.rangeRight(0, 20, 5); + * // => [15, 10, 5, 0] + * + * _.rangeRight(0, -4, -1); + * // => [-3, -2, -1, 0] + * + * _.rangeRight(1, 4, 0); + * // => [1, 1, 1] + * + * _.rangeRight(0); + * // => [] + */ + rangeRight(start: number, end?: number, step?: number): number[]; + /** + * @see _.rangeRight + */ + rangeRight(end: number, index: string | number, guard: object): number[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.rangeRight + */ + rangeRight(end?: number, step?: number): Collection; + } + interface LoDashExplicitWrapper { + /** + * @see _.rangeRight + */ + rangeRight(end?: number, step?: number): CollectionChain; + } + + interface LoDashStatic { + /** + * Create a new pristine lodash function using the given context object. + * + * @param context The context object. + * @return Returns a new lodash function. + */ + runInContext(context?: object): LoDashStatic; + } + interface LoDashImplicitWrapper { + /** + * @see _.runInContext + */ + runInContext(): LoDashStatic; + } + + interface LoDashStatic { + /** + * This method returns a new empty array. + * + * @returns Returns the new empty array. + */ + stubArray(): any[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.stubArray + */ + stubArray(): any[]; + } + interface LoDashExplicitWrapper { + /** + * @see _.stubArray + */ + stubArray(): CollectionChain; + } + + interface LoDashStatic { + /** + * This method returns `false`. + * + * @returns Returns `false`. + */ + stubFalse(): false; + } + interface LoDashImplicitWrapper { + /** + * @see _.stubFalse + */ + stubFalse(): false; + } + interface LoDashExplicitWrapper { + /** + * @see _.stubFalse + */ + stubFalse(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * This method returns a new empty object. + * + * @returns Returns the new empty object. + */ + stubObject(): any; + } + interface LoDashImplicitWrapper { + /** + * @see _.stubObject + */ + stubObject(): any; + } + interface LoDashExplicitWrapper { + /** + * @see _.stubObject + */ + stubObject(): LoDashExplicitWrapper; + } + + interface LoDashStatic { + /** + * This method returns an empty string. + * + * @returns Returns the empty string. + */ + stubString(): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.stubString + */ + stubString(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.stubString + */ + stubString(): StringChain; + } + + interface LoDashStatic { + /** + * This method returns `true`. + * + * @returns Returns `true`. + */ + stubTrue(): true; + } + interface LoDashImplicitWrapper { + /** + * @see _.stubTrue + */ + stubTrue(): true; + } + interface LoDashExplicitWrapper { + /** + * @see _.stubTrue + */ + stubTrue(): PrimitiveChain; + } + + interface LoDashStatic { + /** + * Invokes the iteratee function n times, returning an array of the results of each invocation. The iteratee + * is invoked with one argument; (index). + * + * @param n The number of times to invoke iteratee. + * @param iteratee The function invoked per iteration. + * @return Returns the array of results. + */ + times(n: number, iteratee: (num: number) => TResult): TResult[]; + /** + * @see _.times + */ + times(n: number): number[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.times + */ + times(iteratee: (num: number) => TResult): TResult[]; + /** + * @see _.times + */ + times(): number[]; + } + interface LoDashExplicitWrapper { + /** + * @see _.times + */ + times(iteratee: (num: number) => TResult): CollectionChain; + /** + * @see _.times + */ + times(): CollectionChain; + } + + interface LoDashStatic { + /** + * Converts `value` to a property path array. + * + * @category Util + * @param value The value to convert. + * @returns Returns the new property path array. + * @example + * + * _.toPath('a.b.c'); + * // => ['a', 'b', 'c'] + * + * _.toPath('a[0].b.c'); + * // => ['a', '0', 'b', 'c'] + * + * var path = ['a', 'b', 'c'], + * newPath = _.toPath(path); + * + * console.log(newPath); + * // => ['a', 'b', 'c'] + * + * console.log(path === newPath); + * // => false + */ + toPath(value: any): string[]; + } + interface LoDashImplicitWrapper { + /** + * @see _.toPath + */ + toPath(): Collection; + } + interface LoDashExplicitWrapper { + /** + * @see _.toPath + */ + toPath(): CollectionChain; + } + + interface LoDashStatic { + /** + * Generates a unique ID. If prefix is provided the ID is appended to it. + * + * @param prefix The value to prefix the ID with. + * @return Returns the unique ID. + */ + uniqueId(prefix?: string): string; + } + interface LoDashImplicitWrapper { + /** + * @see _.uniqueId + */ + uniqueId(): string; + } + interface LoDashExplicitWrapper { + /** + * @see _.uniqueId + */ + uniqueId(): StringChain; + } +} diff --git a/types/lodash/ts3.1/compact.d.ts b/types/lodash/ts3.1/compact.d.ts new file mode 100644 index 0000000000..94a539778d --- /dev/null +++ b/types/lodash/ts3.1/compact.d.ts @@ -0,0 +1,2 @@ +import { compact } from "./index"; +export = compact; diff --git a/types/lodash/ts3.1/concat.d.ts b/types/lodash/ts3.1/concat.d.ts new file mode 100644 index 0000000000..f8c26122c7 --- /dev/null +++ b/types/lodash/ts3.1/concat.d.ts @@ -0,0 +1,2 @@ +import { concat } from "./index"; +export = concat; diff --git a/types/lodash/ts3.1/cond.d.ts b/types/lodash/ts3.1/cond.d.ts new file mode 100644 index 0000000000..a325bad4bb --- /dev/null +++ b/types/lodash/ts3.1/cond.d.ts @@ -0,0 +1,2 @@ +import { cond } from "./index"; +export = cond; diff --git a/types/lodash/ts3.1/conformsTo.d.ts b/types/lodash/ts3.1/conformsTo.d.ts new file mode 100644 index 0000000000..320b1806e0 --- /dev/null +++ b/types/lodash/ts3.1/conformsTo.d.ts @@ -0,0 +1,2 @@ +import { conformsTo } from "./index"; +export = conformsTo; diff --git a/types/lodash/ts3.1/constant.d.ts b/types/lodash/ts3.1/constant.d.ts new file mode 100644 index 0000000000..ebab572c1d --- /dev/null +++ b/types/lodash/ts3.1/constant.d.ts @@ -0,0 +1,2 @@ +import { constant } from "./index"; +export = constant; diff --git a/types/lodash/ts3.1/countBy.d.ts b/types/lodash/ts3.1/countBy.d.ts new file mode 100644 index 0000000000..db56ff3c11 --- /dev/null +++ b/types/lodash/ts3.1/countBy.d.ts @@ -0,0 +1,2 @@ +import { countBy } from "./index"; +export = countBy; diff --git a/types/lodash/ts3.1/create.d.ts b/types/lodash/ts3.1/create.d.ts new file mode 100644 index 0000000000..5c7dc7a21c --- /dev/null +++ b/types/lodash/ts3.1/create.d.ts @@ -0,0 +1,2 @@ +import { create } from "./index"; +export = create; diff --git a/types/lodash/ts3.1/curry.d.ts b/types/lodash/ts3.1/curry.d.ts new file mode 100644 index 0000000000..afbb8f47dc --- /dev/null +++ b/types/lodash/ts3.1/curry.d.ts @@ -0,0 +1,2 @@ +import { curry } from "./index"; +export = curry; diff --git a/types/lodash/ts3.1/curryRight.d.ts b/types/lodash/ts3.1/curryRight.d.ts new file mode 100644 index 0000000000..7d224c9722 --- /dev/null +++ b/types/lodash/ts3.1/curryRight.d.ts @@ -0,0 +1,2 @@ +import { curryRight } from "./index"; +export = curryRight; diff --git a/types/lodash/ts3.1/debounce.d.ts b/types/lodash/ts3.1/debounce.d.ts new file mode 100644 index 0000000000..983edd74c7 --- /dev/null +++ b/types/lodash/ts3.1/debounce.d.ts @@ -0,0 +1,2 @@ +import { debounce } from "./index"; +export = debounce; diff --git a/types/lodash/ts3.1/deburr.d.ts b/types/lodash/ts3.1/deburr.d.ts new file mode 100644 index 0000000000..cf1fa376f3 --- /dev/null +++ b/types/lodash/ts3.1/deburr.d.ts @@ -0,0 +1,2 @@ +import { deburr } from "./index"; +export = deburr; diff --git a/types/lodash/ts3.1/defaultTo.d.ts b/types/lodash/ts3.1/defaultTo.d.ts new file mode 100644 index 0000000000..89fb56505f --- /dev/null +++ b/types/lodash/ts3.1/defaultTo.d.ts @@ -0,0 +1,2 @@ +import { defaultTo } from "./index"; +export = defaultTo; diff --git a/types/lodash/ts3.1/defaults.d.ts b/types/lodash/ts3.1/defaults.d.ts new file mode 100644 index 0000000000..e83508d126 --- /dev/null +++ b/types/lodash/ts3.1/defaults.d.ts @@ -0,0 +1,2 @@ +import { defaults } from "./index"; +export = defaults; diff --git a/types/lodash/ts3.1/defaultsDeep.d.ts b/types/lodash/ts3.1/defaultsDeep.d.ts new file mode 100644 index 0000000000..19ff551296 --- /dev/null +++ b/types/lodash/ts3.1/defaultsDeep.d.ts @@ -0,0 +1,2 @@ +import { defaultsDeep } from "./index"; +export = defaultsDeep; diff --git a/types/lodash/ts3.1/defer.d.ts b/types/lodash/ts3.1/defer.d.ts new file mode 100644 index 0000000000..144bf5b014 --- /dev/null +++ b/types/lodash/ts3.1/defer.d.ts @@ -0,0 +1,2 @@ +import { defer } from "./index"; +export = defer; diff --git a/types/lodash/ts3.1/delay.d.ts b/types/lodash/ts3.1/delay.d.ts new file mode 100644 index 0000000000..ead89c1007 --- /dev/null +++ b/types/lodash/ts3.1/delay.d.ts @@ -0,0 +1,2 @@ +import { delay } from "./index"; +export = delay; diff --git a/types/lodash/ts3.1/difference.d.ts b/types/lodash/ts3.1/difference.d.ts new file mode 100644 index 0000000000..4a73c56599 --- /dev/null +++ b/types/lodash/ts3.1/difference.d.ts @@ -0,0 +1,2 @@ +import { difference } from "./index"; +export = difference; diff --git a/types/lodash/ts3.1/differenceBy.d.ts b/types/lodash/ts3.1/differenceBy.d.ts new file mode 100644 index 0000000000..34558c4ef3 --- /dev/null +++ b/types/lodash/ts3.1/differenceBy.d.ts @@ -0,0 +1,2 @@ +import { differenceBy } from "./index"; +export = differenceBy; diff --git a/types/lodash/ts3.1/differenceWith.d.ts b/types/lodash/ts3.1/differenceWith.d.ts new file mode 100644 index 0000000000..86aebd889e --- /dev/null +++ b/types/lodash/ts3.1/differenceWith.d.ts @@ -0,0 +1,2 @@ +import { differenceWith } from "./index"; +export = differenceWith; diff --git a/types/lodash/ts3.1/divide.d.ts b/types/lodash/ts3.1/divide.d.ts new file mode 100644 index 0000000000..3d8e393166 --- /dev/null +++ b/types/lodash/ts3.1/divide.d.ts @@ -0,0 +1,2 @@ +import { divide } from "./index"; +export = divide; diff --git a/types/lodash/ts3.1/drop.d.ts b/types/lodash/ts3.1/drop.d.ts new file mode 100644 index 0000000000..1283f99a58 --- /dev/null +++ b/types/lodash/ts3.1/drop.d.ts @@ -0,0 +1,2 @@ +import { drop } from "./index"; +export = drop; diff --git a/types/lodash/ts3.1/dropRight.d.ts b/types/lodash/ts3.1/dropRight.d.ts new file mode 100644 index 0000000000..4133c9850b --- /dev/null +++ b/types/lodash/ts3.1/dropRight.d.ts @@ -0,0 +1,2 @@ +import { dropRight } from "./index"; +export = dropRight; diff --git a/types/lodash/ts3.1/dropRightWhile.d.ts b/types/lodash/ts3.1/dropRightWhile.d.ts new file mode 100644 index 0000000000..0dda808d49 --- /dev/null +++ b/types/lodash/ts3.1/dropRightWhile.d.ts @@ -0,0 +1,2 @@ +import { dropRightWhile } from "./index"; +export = dropRightWhile; diff --git a/types/lodash/ts3.1/dropWhile.d.ts b/types/lodash/ts3.1/dropWhile.d.ts new file mode 100644 index 0000000000..894ebaa234 --- /dev/null +++ b/types/lodash/ts3.1/dropWhile.d.ts @@ -0,0 +1,2 @@ +import { dropWhile } from "./index"; +export = dropWhile; diff --git a/types/lodash/ts3.1/each.d.ts b/types/lodash/ts3.1/each.d.ts new file mode 100644 index 0000000000..608f8a9b92 --- /dev/null +++ b/types/lodash/ts3.1/each.d.ts @@ -0,0 +1,2 @@ +import { each } from "./index"; +export = each; diff --git a/types/lodash/ts3.1/eachRight.d.ts b/types/lodash/ts3.1/eachRight.d.ts new file mode 100644 index 0000000000..ae0bb6f878 --- /dev/null +++ b/types/lodash/ts3.1/eachRight.d.ts @@ -0,0 +1,2 @@ +import { eachRight } from "./index"; +export = eachRight; diff --git a/types/lodash/ts3.1/endsWith.d.ts b/types/lodash/ts3.1/endsWith.d.ts new file mode 100644 index 0000000000..d8475b13a9 --- /dev/null +++ b/types/lodash/ts3.1/endsWith.d.ts @@ -0,0 +1,2 @@ +import { endsWith } from "./index"; +export = endsWith; diff --git a/types/lodash/ts3.1/entries.d.ts b/types/lodash/ts3.1/entries.d.ts new file mode 100644 index 0000000000..24b241751b --- /dev/null +++ b/types/lodash/ts3.1/entries.d.ts @@ -0,0 +1,2 @@ +import { entries } from "./index"; +export = entries; diff --git a/types/lodash/ts3.1/entriesIn.d.ts b/types/lodash/ts3.1/entriesIn.d.ts new file mode 100644 index 0000000000..a68ab1e576 --- /dev/null +++ b/types/lodash/ts3.1/entriesIn.d.ts @@ -0,0 +1,2 @@ +import { entriesIn } from "./index"; +export = entriesIn; diff --git a/types/lodash/ts3.1/eq.d.ts b/types/lodash/ts3.1/eq.d.ts new file mode 100644 index 0000000000..88ec887912 --- /dev/null +++ b/types/lodash/ts3.1/eq.d.ts @@ -0,0 +1,2 @@ +import { eq } from "./index"; +export = eq; diff --git a/types/lodash/ts3.1/escape.d.ts b/types/lodash/ts3.1/escape.d.ts new file mode 100644 index 0000000000..9f628a3baa --- /dev/null +++ b/types/lodash/ts3.1/escape.d.ts @@ -0,0 +1,2 @@ +import { escape } from "./index"; +export = escape; diff --git a/types/lodash/ts3.1/escapeRegExp.d.ts b/types/lodash/ts3.1/escapeRegExp.d.ts new file mode 100644 index 0000000000..97519c10f3 --- /dev/null +++ b/types/lodash/ts3.1/escapeRegExp.d.ts @@ -0,0 +1,2 @@ +import { escapeRegExp } from "./index"; +export = escapeRegExp; diff --git a/types/lodash/ts3.1/every.d.ts b/types/lodash/ts3.1/every.d.ts new file mode 100644 index 0000000000..d9717d4b11 --- /dev/null +++ b/types/lodash/ts3.1/every.d.ts @@ -0,0 +1,2 @@ +import { every } from "./index"; +export = every; diff --git a/types/lodash/ts3.1/extend.d.ts b/types/lodash/ts3.1/extend.d.ts new file mode 100644 index 0000000000..1b3107a007 --- /dev/null +++ b/types/lodash/ts3.1/extend.d.ts @@ -0,0 +1,2 @@ +import { extend } from "./index"; +export = extend; diff --git a/types/lodash/ts3.1/extendWith.d.ts b/types/lodash/ts3.1/extendWith.d.ts new file mode 100644 index 0000000000..99ca5d04ea --- /dev/null +++ b/types/lodash/ts3.1/extendWith.d.ts @@ -0,0 +1,2 @@ +import { extendWith } from "./index"; +export = extendWith; diff --git a/types/lodash/ts3.1/fill.d.ts b/types/lodash/ts3.1/fill.d.ts new file mode 100644 index 0000000000..f595dfcd0b --- /dev/null +++ b/types/lodash/ts3.1/fill.d.ts @@ -0,0 +1,2 @@ +import { fill } from "./index"; +export = fill; diff --git a/types/lodash/ts3.1/filter.d.ts b/types/lodash/ts3.1/filter.d.ts new file mode 100644 index 0000000000..a4496de6a6 --- /dev/null +++ b/types/lodash/ts3.1/filter.d.ts @@ -0,0 +1,2 @@ +import { filter } from "./index"; +export = filter; diff --git a/types/lodash/ts3.1/find.d.ts b/types/lodash/ts3.1/find.d.ts new file mode 100644 index 0000000000..e8da4b4f50 --- /dev/null +++ b/types/lodash/ts3.1/find.d.ts @@ -0,0 +1,2 @@ +import { find } from "./index"; +export = find; diff --git a/types/lodash/ts3.1/findIndex.d.ts b/types/lodash/ts3.1/findIndex.d.ts new file mode 100644 index 0000000000..6b724446b7 --- /dev/null +++ b/types/lodash/ts3.1/findIndex.d.ts @@ -0,0 +1,2 @@ +import { findIndex } from "./index"; +export = findIndex; diff --git a/types/lodash/ts3.1/findKey.d.ts b/types/lodash/ts3.1/findKey.d.ts new file mode 100644 index 0000000000..90230b4370 --- /dev/null +++ b/types/lodash/ts3.1/findKey.d.ts @@ -0,0 +1,2 @@ +import { findKey } from "./index"; +export = findKey; diff --git a/types/lodash/ts3.1/findLast.d.ts b/types/lodash/ts3.1/findLast.d.ts new file mode 100644 index 0000000000..c4f24fc17a --- /dev/null +++ b/types/lodash/ts3.1/findLast.d.ts @@ -0,0 +1,2 @@ +import { findLast } from "./index"; +export = findLast; diff --git a/types/lodash/ts3.1/findLastIndex.d.ts b/types/lodash/ts3.1/findLastIndex.d.ts new file mode 100644 index 0000000000..21856e532b --- /dev/null +++ b/types/lodash/ts3.1/findLastIndex.d.ts @@ -0,0 +1,2 @@ +import { findLastIndex } from "./index"; +export = findLastIndex; diff --git a/types/lodash/ts3.1/findLastKey.d.ts b/types/lodash/ts3.1/findLastKey.d.ts new file mode 100644 index 0000000000..ed7ff798d7 --- /dev/null +++ b/types/lodash/ts3.1/findLastKey.d.ts @@ -0,0 +1,2 @@ +import { findLastKey } from "./index"; +export = findLastKey; diff --git a/types/lodash/ts3.1/first.d.ts b/types/lodash/ts3.1/first.d.ts new file mode 100644 index 0000000000..fd1cda7af0 --- /dev/null +++ b/types/lodash/ts3.1/first.d.ts @@ -0,0 +1,2 @@ +import { first } from "./index"; +export = first; diff --git a/types/lodash/ts3.1/flatMap.d.ts b/types/lodash/ts3.1/flatMap.d.ts new file mode 100644 index 0000000000..00570530ef --- /dev/null +++ b/types/lodash/ts3.1/flatMap.d.ts @@ -0,0 +1,2 @@ +import { flatMap } from "./index"; +export = flatMap; diff --git a/types/lodash/ts3.1/flatMapDeep.d.ts b/types/lodash/ts3.1/flatMapDeep.d.ts new file mode 100644 index 0000000000..c65639a1fa --- /dev/null +++ b/types/lodash/ts3.1/flatMapDeep.d.ts @@ -0,0 +1,2 @@ +import { flatMapDeep } from "./index"; +export = flatMapDeep; diff --git a/types/lodash/ts3.1/flatMapDepth.d.ts b/types/lodash/ts3.1/flatMapDepth.d.ts new file mode 100644 index 0000000000..7ec18534b0 --- /dev/null +++ b/types/lodash/ts3.1/flatMapDepth.d.ts @@ -0,0 +1,2 @@ +import { flatMapDepth } from "./index"; +export = flatMapDepth; diff --git a/types/lodash/ts3.1/flatten.d.ts b/types/lodash/ts3.1/flatten.d.ts new file mode 100644 index 0000000000..43ac0f444e --- /dev/null +++ b/types/lodash/ts3.1/flatten.d.ts @@ -0,0 +1,2 @@ +import { flatten } from "./index"; +export = flatten; diff --git a/types/lodash/ts3.1/flattenDeep.d.ts b/types/lodash/ts3.1/flattenDeep.d.ts new file mode 100644 index 0000000000..df08bfa55d --- /dev/null +++ b/types/lodash/ts3.1/flattenDeep.d.ts @@ -0,0 +1,2 @@ +import { flattenDeep } from "./index"; +export = flattenDeep; diff --git a/types/lodash/ts3.1/flattenDepth.d.ts b/types/lodash/ts3.1/flattenDepth.d.ts new file mode 100644 index 0000000000..f6be541f8d --- /dev/null +++ b/types/lodash/ts3.1/flattenDepth.d.ts @@ -0,0 +1,2 @@ +import { flattenDepth } from "./index"; +export = flattenDepth; diff --git a/types/lodash/ts3.1/flip.d.ts b/types/lodash/ts3.1/flip.d.ts new file mode 100644 index 0000000000..48c9924eca --- /dev/null +++ b/types/lodash/ts3.1/flip.d.ts @@ -0,0 +1,2 @@ +import { flip } from "./index"; +export = flip; diff --git a/types/lodash/ts3.1/floor.d.ts b/types/lodash/ts3.1/floor.d.ts new file mode 100644 index 0000000000..a101e5de0f --- /dev/null +++ b/types/lodash/ts3.1/floor.d.ts @@ -0,0 +1,2 @@ +import { floor } from "./index"; +export = floor; diff --git a/types/lodash/ts3.1/flow.d.ts b/types/lodash/ts3.1/flow.d.ts new file mode 100644 index 0000000000..37af0d4797 --- /dev/null +++ b/types/lodash/ts3.1/flow.d.ts @@ -0,0 +1,2 @@ +import { flow } from "./index"; +export = flow; diff --git a/types/lodash/ts3.1/flowRight.d.ts b/types/lodash/ts3.1/flowRight.d.ts new file mode 100644 index 0000000000..6c63f3edc1 --- /dev/null +++ b/types/lodash/ts3.1/flowRight.d.ts @@ -0,0 +1,2 @@ +import { flowRight } from "./index"; +export = flowRight; diff --git a/types/lodash/ts3.1/forEach.d.ts b/types/lodash/ts3.1/forEach.d.ts new file mode 100644 index 0000000000..8416aab76c --- /dev/null +++ b/types/lodash/ts3.1/forEach.d.ts @@ -0,0 +1,2 @@ +import { forEach } from "./index"; +export = forEach; diff --git a/types/lodash/ts3.1/forEachRight.d.ts b/types/lodash/ts3.1/forEachRight.d.ts new file mode 100644 index 0000000000..af65b5c1cf --- /dev/null +++ b/types/lodash/ts3.1/forEachRight.d.ts @@ -0,0 +1,2 @@ +import { forEachRight } from "./index"; +export = forEachRight; diff --git a/types/lodash/ts3.1/forIn.d.ts b/types/lodash/ts3.1/forIn.d.ts new file mode 100644 index 0000000000..77d6f4853f --- /dev/null +++ b/types/lodash/ts3.1/forIn.d.ts @@ -0,0 +1,2 @@ +import { forIn } from "./index"; +export = forIn; diff --git a/types/lodash/ts3.1/forInRight.d.ts b/types/lodash/ts3.1/forInRight.d.ts new file mode 100644 index 0000000000..d732969421 --- /dev/null +++ b/types/lodash/ts3.1/forInRight.d.ts @@ -0,0 +1,2 @@ +import { forInRight } from "./index"; +export = forInRight; diff --git a/types/lodash/ts3.1/forOwn.d.ts b/types/lodash/ts3.1/forOwn.d.ts new file mode 100644 index 0000000000..dfa930f278 --- /dev/null +++ b/types/lodash/ts3.1/forOwn.d.ts @@ -0,0 +1,2 @@ +import { forOwn } from "./index"; +export = forOwn; diff --git a/types/lodash/ts3.1/forOwnRight.d.ts b/types/lodash/ts3.1/forOwnRight.d.ts new file mode 100644 index 0000000000..fddde6a77e --- /dev/null +++ b/types/lodash/ts3.1/forOwnRight.d.ts @@ -0,0 +1,2 @@ +import { forOwnRight } from "./index"; +export = forOwnRight; diff --git a/types/lodash/ts3.1/fp.d.ts b/types/lodash/ts3.1/fp.d.ts new file mode 100644 index 0000000000..6a82ec5e76 --- /dev/null +++ b/types/lodash/ts3.1/fp.d.ts @@ -0,0 +1,4628 @@ +// AUTO-GENERATED: do not modify this file directly. +// If you need to make changes, modify generate-fp.ts (if necessary), then open a terminal in types/lodash/scripts, and do: +// npm install && npm run generate + +import lodash = require("./index"); + +export = _; + +declare const _: _.LoDashFp; +declare namespace _ { + interface LodashAdd { + (augend: number): LodashAdd1x1; + (augend: lodash.__, addend: number): LodashAdd1x2; + (augend: number, addend: number): number; + } + type LodashAdd1x1 = (addend: number) => number; + type LodashAdd1x2 = (augend: number) => number; + interface LodashAfter { + any>(func: TFunc): LodashAfter1x1; + (func: lodash.__, n: number): LodashAfter1x2; + any>(func: TFunc, n: number): TFunc; + } + type LodashAfter1x1 = (n: number) => TFunc; + type LodashAfter1x2 = any>(func: TFunc) => TFunc; + interface LodashEvery { + (predicate: lodash.ValueIterateeCustom): LodashEvery1x1; + (predicate: lodash.__, collection: lodash.List | null | undefined): LodashEvery1x2; + (predicate: lodash.ValueIterateeCustom, collection: lodash.List | null | undefined): boolean; + (predicate: lodash.__, collection: T | null | undefined): LodashEvery2x2; + (predicate: lodash.ValueIterateeCustom, collection: T | null | undefined): boolean; + } + type LodashEvery1x1 = (collection: lodash.List | object | null | undefined) => boolean; + type LodashEvery1x2 = (predicate: lodash.ValueIterateeCustom) => boolean; + type LodashEvery2x2 = (predicate: lodash.ValueIterateeCustom) => boolean; + type LodashOverEvery = (predicates: lodash.Many<(...args: T[]) => boolean>) => (...args: T[]) => boolean; + type LodashConstant = (value: T) => () => T; + interface LodashSome { + (predicate: lodash.ValueIterateeCustom): LodashSome1x1; + (predicate: lodash.__, collection: lodash.List | null | undefined): LodashSome1x2; + (predicate: lodash.ValueIterateeCustom, collection: lodash.List | null | undefined): boolean; + (predicate: lodash.__, collection: T | null | undefined): LodashSome2x2; + (predicate: lodash.ValueIterateeCustom, collection: T | null | undefined): boolean; + } + type LodashSome1x1 = (collection: lodash.List | object | null | undefined) => boolean; + type LodashSome1x2 = (predicate: lodash.ValueIterateeCustom) => boolean; + type LodashSome2x2 = (predicate: lodash.ValueIterateeCustom) => boolean; + type LodashOverSome = (predicates: lodash.Many<(...args: T[]) => boolean>) => (...args: T[]) => boolean; + type LodashApply = (func: (...args: any[]) => TResult) => (...args: any[]) => TResult; + interface LodashAry { + (n: number): LodashAry1x1; + (n: lodash.__, func: (...args: any[]) => any): LodashAry1x2; + (n: number, func: (...args: any[]) => any): (...args: any[]) => any; + } + type LodashAry1x1 = (func: (...args: any[]) => any) => (...args: any[]) => any; + type LodashAry1x2 = (n: number) => (...args: any[]) => any; + interface LodashAssign { + (object: TObject): LodashAssign1x1; + (object: lodash.__, source: TSource): LodashAssign1x2; + (object: TObject, source: TSource): TObject & TSource; + } + type LodashAssign1x1 = (source: TSource) => TObject & TSource; + type LodashAssign1x2 = (object: TObject) => TObject & TSource; + interface LodashAssignAll { + (object: [TObject, TSource]): TObject & TSource; + (object: [TObject, TSource1, TSource2]): TObject & TSource1 & TSource2; + (object: [TObject, TSource1, TSource2, TSource3]): TObject & TSource1 & TSource2 & TSource3; + (object: [TObject, TSource1, TSource2, TSource3, TSource4]): TObject & TSource1 & TSource2 & TSource3 & TSource4; + (object: [TObject]): TObject; + (object: ReadonlyArray): any; + } + interface LodashAssignAllWith { + (customizer: lodash.AssignCustomizer): LodashAssignAllWith1x1; + (customizer: lodash.__, args: ReadonlyArray): LodashAssignAllWith1x2; + (customizer: lodash.AssignCustomizer, args: ReadonlyArray): any; + } + type LodashAssignAllWith1x1 = (args: ReadonlyArray) => any; + type LodashAssignAllWith1x2 = (customizer: lodash.AssignCustomizer) => any; + interface LodashAssignIn { + (object: TObject): LodashAssignIn1x1; + (object: lodash.__, source: TSource): LodashAssignIn1x2; + (object: TObject, source: TSource): TObject & TSource; + } + type LodashAssignIn1x1 = (source: TSource) => TObject & TSource; + type LodashAssignIn1x2 = (object: TObject) => TObject & TSource; + interface LodashAssignInAll { + (object: [TObject, TSource]): TObject & TSource; + (object: [TObject, TSource1, TSource2]): TObject & TSource1 & TSource2; + (object: [TObject, TSource1, TSource2, TSource3]): TObject & TSource1 & TSource2 & TSource3; + (object: [TObject, TSource1, TSource2, TSource3, TSource4]): TObject & TSource1 & TSource2 & TSource3 & TSource4; + (object: [TObject]): TObject; + (object: ReadonlyArray): TResult; + } + interface LodashAssignInAllWith { + (customizer: lodash.AssignCustomizer): LodashAssignInAllWith1x1; + (customizer: lodash.__, args: ReadonlyArray): LodashAssignInAllWith1x2; + (customizer: lodash.AssignCustomizer, args: ReadonlyArray): any; + } + type LodashAssignInAllWith1x1 = (args: ReadonlyArray) => any; + type LodashAssignInAllWith1x2 = (customizer: lodash.AssignCustomizer) => any; + interface LodashAssignInWith { + (customizer: lodash.AssignCustomizer): LodashAssignInWith1x1; + (customizer: lodash.__, object: TObject): LodashAssignInWith1x2; + (customizer: lodash.AssignCustomizer, object: TObject): LodashAssignInWith1x3; + (customizer: lodash.__, object: lodash.__, source: TSource): LodashAssignInWith1x4; + (customizer: lodash.AssignCustomizer, object: lodash.__, source: TSource): LodashAssignInWith1x5; + (customizer: lodash.__, object: TObject, source: TSource): LodashAssignInWith1x6; + (customizer: lodash.AssignCustomizer, object: TObject, source: TSource): TObject & TSource; + } + interface LodashAssignInWith1x1 { + (object: TObject): LodashAssignInWith1x3; + (object: lodash.__, source: TSource): LodashAssignInWith1x5; + (object: TObject, source: TSource): TObject & TSource; + } + interface LodashAssignInWith1x2 { + (customizer: lodash.AssignCustomizer): LodashAssignInWith1x3; + (customizer: lodash.__, source: TSource): LodashAssignInWith1x6; + (customizer: lodash.AssignCustomizer, source: TSource): TObject & TSource; + } + type LodashAssignInWith1x3 = (source: TSource) => TObject & TSource; + interface LodashAssignInWith1x4 { + (customizer: lodash.AssignCustomizer): LodashAssignInWith1x5; + (customizer: lodash.__, object: TObject): LodashAssignInWith1x6; + (customizer: lodash.AssignCustomizer, object: TObject): TObject & TSource; + } + type LodashAssignInWith1x5 = (object: TObject) => TObject & TSource; + type LodashAssignInWith1x6 = (customizer: lodash.AssignCustomizer) => TObject & TSource; + interface LodashAssignWith { + (customizer: lodash.AssignCustomizer): LodashAssignWith1x1; + (customizer: lodash.__, object: TObject): LodashAssignWith1x2; + (customizer: lodash.AssignCustomizer, object: TObject): LodashAssignWith1x3; + (customizer: lodash.__, object: lodash.__, source: TSource): LodashAssignWith1x4; + (customizer: lodash.AssignCustomizer, object: lodash.__, source: TSource): LodashAssignWith1x5; + (customizer: lodash.__, object: TObject, source: TSource): LodashAssignWith1x6; + (customizer: lodash.AssignCustomizer, object: TObject, source: TSource): TObject & TSource; + } + interface LodashAssignWith1x1 { + (object: TObject): LodashAssignWith1x3; + (object: lodash.__, source: TSource): LodashAssignWith1x5; + (object: TObject, source: TSource): TObject & TSource; + } + interface LodashAssignWith1x2 { + (customizer: lodash.AssignCustomizer): LodashAssignWith1x3; + (customizer: lodash.__, source: TSource): LodashAssignWith1x6; + (customizer: lodash.AssignCustomizer, source: TSource): TObject & TSource; + } + type LodashAssignWith1x3 = (source: TSource) => TObject & TSource; + interface LodashAssignWith1x4 { + (customizer: lodash.AssignCustomizer): LodashAssignWith1x5; + (customizer: lodash.__, object: TObject): LodashAssignWith1x6; + (customizer: lodash.AssignCustomizer, object: TObject): TObject & TSource; + } + type LodashAssignWith1x5 = (object: TObject) => TObject & TSource; + type LodashAssignWith1x6 = (customizer: lodash.AssignCustomizer) => TObject & TSource; + interface LodashSet { + (path: lodash.PropertyPath): LodashSet1x1; + (path: lodash.__, value: any): LodashSet1x2; + (path: lodash.PropertyPath, value: any): LodashSet1x3; + (path: lodash.__, value: lodash.__, object: T): LodashSet1x4; + (path: lodash.PropertyPath, value: lodash.__, object: T): LodashSet1x5; + (path: lodash.__, value: any, object: T): LodashSet1x6; + (path: lodash.PropertyPath, value: any, object: T): T; + (path: lodash.__, value: lodash.__, object: object): LodashSet2x4; + (path: lodash.PropertyPath, value: lodash.__, object: object): LodashSet2x5; + (path: lodash.__, value: any, object: object): LodashSet2x6; + (path: lodash.PropertyPath, value: any, object: object): TResult; + } + interface LodashSet1x1 { + (value: any): LodashSet1x3; + (value: lodash.__, object: T): LodashSet1x5; + (value: any, object: T): T; + (value: lodash.__, object: object): LodashSet2x5; + (value: any, object: object): TResult; + } + interface LodashSet1x2 { + (path: lodash.PropertyPath): LodashSet1x3; + (path: lodash.__, object: T): LodashSet1x6; + (path: lodash.PropertyPath, object: T): T; + (path: lodash.__, object: object): LodashSet2x6; + (path: lodash.PropertyPath, object: object): TResult; + } + interface LodashSet1x3 { + (object: T): T; + (object: object): TResult; + } + interface LodashSet1x4 { + (path: lodash.PropertyPath): LodashSet1x5; + (path: lodash.__, value: any): LodashSet1x6; + (path: lodash.PropertyPath, value: any): T; + } + type LodashSet1x5 = (value: any) => T; + type LodashSet1x6 = (path: lodash.PropertyPath) => T; + interface LodashSet2x4 { + (path: lodash.PropertyPath): LodashSet2x5; + (path: lodash.__, value: any): LodashSet2x6; + (path: lodash.PropertyPath, value: any): TResult; + } + type LodashSet2x5 = (value: any) => TResult; + type LodashSet2x6 = (path: lodash.PropertyPath) => TResult; + interface LodashAt { + (props: lodash.PropertyPath): LodashAt1x1; + (props: lodash.__, object: lodash.Dictionary | lodash.NumericDictionary | null | undefined): LodashAt1x2; + (props: lodash.PropertyPath, object: lodash.Dictionary | lodash.NumericDictionary | null | undefined): T[]; + (props: lodash.Many): LodashAt2x1; + (props: lodash.__, object: T | null | undefined): LodashAt2x2; + (props: lodash.Many, object: T | null | undefined): Array; + } + type LodashAt1x1 = (object: lodash.Dictionary | lodash.NumericDictionary | null | undefined) => T[]; + type LodashAt1x2 = (props: lodash.PropertyPath) => T[]; + type LodashAt2x1 = (object: T | null | undefined) => Array; + type LodashAt2x2 = (props: lodash.Many) => Array; + type LodashAttempt = (func: (...args: any[]) => TResult) => TResult | Error; + interface LodashBefore { + any>(func: TFunc): LodashBefore1x1; + (func: lodash.__, n: number): LodashBefore1x2; + any>(func: TFunc, n: number): TFunc; + } + type LodashBefore1x1 = (n: number) => TFunc; + type LodashBefore1x2 = any>(func: TFunc) => TFunc; + interface LodashBind { + (func: (...args: any[]) => any): LodashBind1x1; + (func: lodash.__, thisArg: any): LodashBind1x2; + (func: (...args: any[]) => any, thisArg: any): (...args: any[]) => any; + placeholder: lodash.__; + } + type LodashBind1x1 = (thisArg: any) => (...args: any[]) => any; + type LodashBind1x2 = (func: (...args: any[]) => any) => (...args: any[]) => any; + interface LodashBindAll { + (methodNames: lodash.Many): LodashBindAll1x1; + (methodNames: lodash.__, object: T): LodashBindAll1x2; + (methodNames: lodash.Many, object: T): T; + } + type LodashBindAll1x1 = (object: T) => T; + type LodashBindAll1x2 = (methodNames: lodash.Many) => T; + interface LodashBindKey { + (object: object): LodashBindKey1x1; + (object: lodash.__, key: string): LodashBindKey1x2; + (object: object, key: string): (...args: any[]) => any; + placeholder: lodash.__; + } + type LodashBindKey1x1 = (key: string) => (...args: any[]) => any; + type LodashBindKey1x2 = (object: object) => (...args: any[]) => any; + type LodashCamelCase = (string: string) => string; + type LodashCapitalize = (string: string) => string; + type LodashCastArray = (value: lodash.Many) => T[]; + type LodashCeil = (n: number) => number; + interface LodashChunk { + (size: number): LodashChunk1x1; + (size: lodash.__, array: lodash.List | null | undefined): LodashChunk1x2; + (size: number, array: lodash.List | null | undefined): T[][]; + } + type LodashChunk1x1 = (array: lodash.List | null | undefined) => T[][]; + type LodashChunk1x2 = (size: number) => T[][]; + interface LodashClamp { + (lower: number): LodashClamp1x1; + (lower: lodash.__, upper: number): LodashClamp1x2; + (lower: number, upper: number): LodashClamp1x3; + (lower: lodash.__, upper: lodash.__, number: number): LodashClamp1x4; + (lower: number, upper: lodash.__, number: number): LodashClamp1x5; + (lower: lodash.__, upper: number, number: number): LodashClamp1x6; + (lower: number, upper: number, number: number): number; + } + interface LodashClamp1x1 { + (upper: number): LodashClamp1x3; + (upper: lodash.__, number: number): LodashClamp1x5; + (upper: number, number: number): number; + } + interface LodashClamp1x2 { + (lower: number): LodashClamp1x3; + (lower: lodash.__, number: number): LodashClamp1x6; + (lower: number, number: number): number; + } + type LodashClamp1x3 = (number: number) => number; + interface LodashClamp1x4 { + (lower: number): LodashClamp1x5; + (lower: lodash.__, upper: number): LodashClamp1x6; + (lower: number, upper: number): number; + } + type LodashClamp1x5 = (upper: number) => number; + type LodashClamp1x6 = (lower: number) => number; + type LodashClone = (value: T) => T; + type LodashCloneDeep = (value: T) => T; + interface LodashCloneDeepWith { + (customizer: lodash.CloneDeepWithCustomizer): LodashCloneDeepWith1x1; + (customizer: lodash.__, value: T): LodashCloneDeepWith1x2; + (customizer: lodash.CloneDeepWithCustomizer, value: T): any; + } + type LodashCloneDeepWith1x1 = (value: T) => any; + type LodashCloneDeepWith1x2 = (customizer: lodash.CloneDeepWithCustomizer) => any; + interface LodashCloneWith { + (customizer: lodash.CloneWithCustomizer): LodashCloneWith1x1; + (customizer: lodash.__, value: T): LodashCloneWith1x2; + (customizer: lodash.CloneWithCustomizer, value: T): TResult; + (customizer: lodash.CloneWithCustomizer): LodashCloneWith2x1; + (customizer: lodash.CloneWithCustomizer, value: T): TResult | T; + } + type LodashCloneWith1x1 = (value: T) => TResult; + interface LodashCloneWith1x2 { + (customizer: lodash.CloneWithCustomizer): TResult; + (customizer: lodash.CloneWithCustomizer): TResult | T; + } + type LodashCloneWith2x1 = (value: T) => TResult | T; + type LodashCompact = (array: lodash.List | null | undefined) => T[]; + type LodashNegate = (predicate: (...args: T) => any) => (...args: T) => boolean; + interface LodashFlowRight { + (f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R7; + (f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R6; + (f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R5; + (f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R4; + (f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R3; + (f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R2; + (...func: Array any>>): (...args: any[]) => any; + } + interface LodashConcat { + (array: lodash.Many): LodashConcat1x1; + (array: lodash.__, values: lodash.Many): LodashConcat1x2; + (array: lodash.Many, values: lodash.Many): T[]; + } + type LodashConcat1x1 = (values: lodash.Many) => T[]; + type LodashConcat1x2 = (array: lodash.Many) => T[]; + type LodashCond = (pairs: Array>) => (Target: T) => R; + interface LodashConformsTo { + (source: lodash.ConformsPredicateObject): LodashConformsTo1x1; + (source: lodash.__, object: T): LodashConformsTo1x2; + (source: lodash.ConformsPredicateObject, object: T): boolean; + } + type LodashConformsTo1x1 = (object: T) => boolean; + type LodashConformsTo1x2 = (source: lodash.ConformsPredicateObject) => boolean; + interface LodashContains { + (target: T): LodashContains1x1; + (target: lodash.__, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): LodashContains1x2; + (target: T, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): boolean; + } + type LodashContains1x1 = (collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined) => boolean; + type LodashContains1x2 = (target: T) => boolean; + interface LodashCountBy { + (iteratee: lodash.ValueIteratee): LodashCountBy1x1; + (iteratee: lodash.__, collection: lodash.List | null | undefined): LodashCountBy1x2; + (iteratee: lodash.ValueIteratee, collection: lodash.List | null | undefined): lodash.Dictionary; + (iteratee: lodash.__, collection: T | null | undefined): LodashCountBy2x2; + (iteratee: lodash.ValueIteratee, collection: T | null | undefined): lodash.Dictionary; + } + type LodashCountBy1x1 = (collection: lodash.List | object | null | undefined) => lodash.Dictionary; + type LodashCountBy1x2 = (iteratee: lodash.ValueIteratee) => lodash.Dictionary; + type LodashCountBy2x2 = (iteratee: lodash.ValueIteratee) => lodash.Dictionary; + type LodashCreate = (prototype: T) => T & U; + interface LodashCurry { + (func: (t1: T1) => R): lodash.CurriedFunction1; + (func: (t1: T1, t2: T2) => R): lodash.CurriedFunction2; + (func: (t1: T1, t2: T2, t3: T3) => R): lodash.CurriedFunction3; + (func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): lodash.CurriedFunction4; + (func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): lodash.CurriedFunction5; + (func: (...args: any[]) => any): (...args: any[]) => any; + placeholder: lodash.__; + } + interface LodashCurryN { + (arity: number): LodashCurryN1x1; + (arity: lodash.__, func: (t1: T1) => R): LodashCurryN1x2; + (arity: number, func: (t1: T1) => R): lodash.CurriedFunction1; + (arity: lodash.__, func: (t1: T1, t2: T2) => R): LodashCurryN2x2; + (arity: number, func: (t1: T1, t2: T2) => R): lodash.CurriedFunction2; + (arity: lodash.__, func: (t1: T1, t2: T2, t3: T3) => R): LodashCurryN3x2; + (arity: number, func: (t1: T1, t2: T2, t3: T3) => R): lodash.CurriedFunction3; + (arity: lodash.__, func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): LodashCurryN4x2; + (arity: number, func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): lodash.CurriedFunction4; + (arity: lodash.__, func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): LodashCurryN5x2; + (arity: number, func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): lodash.CurriedFunction5; + (arity: lodash.__, func: (...args: any[]) => any): LodashCurryN6x2; + (arity: number, func: (...args: any[]) => any): (...args: any[]) => any; + placeholder: lodash.__; + } + interface LodashCurryN1x1 { + (func: (t1: T1) => R): lodash.CurriedFunction1; + (func: (t1: T1, t2: T2) => R): lodash.CurriedFunction2; + (func: (t1: T1, t2: T2, t3: T3) => R): lodash.CurriedFunction3; + (func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): lodash.CurriedFunction4; + (func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): lodash.CurriedFunction5; + (func: (...args: any[]) => any): (...args: any[]) => any; + } + type LodashCurryN1x2 = (arity: number) => lodash.CurriedFunction1; + type LodashCurryN2x2 = (arity: number) => lodash.CurriedFunction2; + type LodashCurryN3x2 = (arity: number) => lodash.CurriedFunction3; + type LodashCurryN4x2 = (arity: number) => lodash.CurriedFunction4; + type LodashCurryN5x2 = (arity: number) => lodash.CurriedFunction5; + type LodashCurryN6x2 = (arity: number) => (...args: any[]) => any; + interface LodashCurryRight { + (func: (t1: T1) => R): lodash.RightCurriedFunction1; + (func: (t1: T1, t2: T2) => R): lodash.RightCurriedFunction2; + (func: (t1: T1, t2: T2, t3: T3) => R): lodash.RightCurriedFunction3; + (func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): lodash.RightCurriedFunction4; + (func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): lodash.RightCurriedFunction5; + (func: (...args: any[]) => any): (...args: any[]) => any; + placeholder: lodash.__; + } + interface LodashCurryRightN { + (arity: number): LodashCurryRightN1x1; + (arity: lodash.__, func: (t1: T1) => R): LodashCurryRightN1x2; + (arity: number, func: (t1: T1) => R): lodash.RightCurriedFunction1; + (arity: lodash.__, func: (t1: T1, t2: T2) => R): LodashCurryRightN2x2; + (arity: number, func: (t1: T1, t2: T2) => R): lodash.RightCurriedFunction2; + (arity: lodash.__, func: (t1: T1, t2: T2, t3: T3) => R): LodashCurryRightN3x2; + (arity: number, func: (t1: T1, t2: T2, t3: T3) => R): lodash.RightCurriedFunction3; + (arity: lodash.__, func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): LodashCurryRightN4x2; + (arity: number, func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): lodash.RightCurriedFunction4; + (arity: lodash.__, func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): LodashCurryRightN5x2; + (arity: number, func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): lodash.RightCurriedFunction5; + (arity: lodash.__, func: (...args: any[]) => any): LodashCurryRightN6x2; + (arity: number, func: (...args: any[]) => any): (...args: any[]) => any; + placeholder: lodash.__; + } + interface LodashCurryRightN1x1 { + (func: (t1: T1) => R): lodash.RightCurriedFunction1; + (func: (t1: T1, t2: T2) => R): lodash.RightCurriedFunction2; + (func: (t1: T1, t2: T2, t3: T3) => R): lodash.RightCurriedFunction3; + (func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): lodash.RightCurriedFunction4; + (func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): lodash.RightCurriedFunction5; + (func: (...args: any[]) => any): (...args: any[]) => any; + } + type LodashCurryRightN1x2 = (arity: number) => lodash.RightCurriedFunction1; + type LodashCurryRightN2x2 = (arity: number) => lodash.RightCurriedFunction2; + type LodashCurryRightN3x2 = (arity: number) => lodash.RightCurriedFunction3; + type LodashCurryRightN4x2 = (arity: number) => lodash.RightCurriedFunction4; + type LodashCurryRightN5x2 = (arity: number) => lodash.RightCurriedFunction5; + type LodashCurryRightN6x2 = (arity: number) => (...args: any[]) => any; + interface LodashDebounce { + (wait: number): LodashDebounce1x1; + any>(wait: lodash.__, func: T): LodashDebounce1x2; + any>(wait: number, func: T): T & lodash.Cancelable; + } + type LodashDebounce1x1 = any>(func: T) => T & lodash.Cancelable; + type LodashDebounce1x2 = (wait: number) => T & lodash.Cancelable; + type LodashDeburr = (string: string) => string; + interface LodashDefaults { + (source: TSource): LodashDefaults1x1; + (source: lodash.__, object: TObject): LodashDefaults1x2; + (source: TSource, object: TObject): TSource & TObject; + } + type LodashDefaults1x1 = (object: TObject) => TSource & TObject; + type LodashDefaults1x2 = (source: TSource) => TSource & TObject; + interface LodashDefaultsAll { + (object: [TObject, TSource]): TSource & TObject; + (object: [TObject, TSource1, TSource2]): TSource2 & TSource1 & TObject; + (object: [TObject, TSource1, TSource2, TSource3]): TSource3 & TSource2 & TSource1 & TObject; + (object: [TObject, TSource1, TSource2, TSource3, TSource4]): TSource4 & TSource3 & TSource2 & TSource1 & TObject; + (object: [TObject]): TObject; + (object: ReadonlyArray): any; + } + interface LodashDefaultsDeep { + (sources: any): LodashDefaultsDeep1x1; + (sources: lodash.__, object: any): LodashDefaultsDeep1x2; + (sources: any, object: any): any; + } + type LodashDefaultsDeep1x1 = (object: any) => any; + type LodashDefaultsDeep1x2 = (sources: any) => any; + type LodashDefaultsDeepAll = (object: ReadonlyArray) => any; + interface LodashDefaultTo { + (defaultValue: T): LodashDefaultTo1x1; + (defaultValue: lodash.__, value: T | null | undefined): LodashDefaultTo1x2; + (defaultValue: T, value: T | null | undefined): T; + (defaultValue: TDefault): LodashDefaultTo2x1; + (defaultValue: TDefault, value: T | null | undefined): T | TDefault; + } + type LodashDefaultTo1x1 = (value: T | null | undefined) => T; + interface LodashDefaultTo1x2 { + (defaultValue: T): T; + (defaultValue: TDefault): T | TDefault; + } + type LodashDefaultTo2x1 = (value: T | null | undefined) => T | TDefault; + type LodashDefer = (func: (...args: any[]) => any, ...args: any[]) => number; + interface LodashDelay { + (wait: number): LodashDelay1x1; + (wait: lodash.__, func: (...args: any[]) => any): LodashDelay1x2; + (wait: number, func: (...args: any[]) => any): number; + } + type LodashDelay1x1 = (func: (...args: any[]) => any) => number; + type LodashDelay1x2 = (wait: number) => number; + interface LodashDifference { + (array: lodash.List | null | undefined): LodashDifference1x1; + (array: lodash.__, values: lodash.List): LodashDifference1x2; + (array: lodash.List | null | undefined, values: lodash.List): T[]; + } + type LodashDifference1x1 = (values: lodash.List) => T[]; + type LodashDifference1x2 = (array: lodash.List | null | undefined) => T[]; + interface LodashDifferenceBy { + (iteratee: lodash.ValueIteratee): LodashDifferenceBy1x1; + (iteratee: lodash.__, array: lodash.List | null | undefined): LodashDifferenceBy1x2; + (iteratee: lodash.ValueIteratee, array: lodash.List | null | undefined): LodashDifferenceBy1x3; + (iteratee: lodash.__, array: lodash.__, values: lodash.List): LodashDifferenceBy1x4; + (iteratee: lodash.ValueIteratee, array: lodash.__, values: lodash.List): LodashDifferenceBy1x5; + (iteratee: lodash.__, array: lodash.List | null | undefined, values: lodash.List): LodashDifferenceBy1x6; + (iteratee: lodash.ValueIteratee, array: lodash.List | null | undefined, values: lodash.List): T1[]; + } + interface LodashDifferenceBy1x1 { + (array: lodash.List | null | undefined): LodashDifferenceBy1x3; + (array: lodash.__, values: lodash.List): LodashDifferenceBy1x5; + (array: lodash.List | null | undefined, values: lodash.List): T1[]; + } + interface LodashDifferenceBy1x2 { + (iteratee: lodash.ValueIteratee): LodashDifferenceBy1x3; + (iteratee: lodash.__, values: lodash.List): LodashDifferenceBy1x6; + (iteratee: lodash.ValueIteratee, values: lodash.List): T1[]; + } + type LodashDifferenceBy1x3 = (values: lodash.List) => T1[]; + interface LodashDifferenceBy1x4 { + (iteratee: lodash.ValueIteratee): LodashDifferenceBy1x5; + (iteratee: lodash.__, array: lodash.List | null | undefined): LodashDifferenceBy1x6; + (iteratee: lodash.ValueIteratee, array: lodash.List | null | undefined): T1[]; + } + type LodashDifferenceBy1x5 = (array: lodash.List | null | undefined) => T1[]; + type LodashDifferenceBy1x6 = (iteratee: lodash.ValueIteratee) => T1[]; + interface LodashDifferenceWith { + (comparator: lodash.Comparator2): LodashDifferenceWith1x1; + (comparator: lodash.__, array: lodash.List | null | undefined): LodashDifferenceWith1x2; + (comparator: lodash.Comparator2, array: lodash.List | null | undefined): LodashDifferenceWith1x3; + (comparator: lodash.__, array: lodash.__, values: lodash.List): LodashDifferenceWith1x4; + (comparator: lodash.Comparator2, array: lodash.__, values: lodash.List): LodashDifferenceWith1x5; + (comparator: lodash.__, array: lodash.List | null | undefined, values: lodash.List): LodashDifferenceWith1x6; + (comparator: lodash.Comparator2, array: lodash.List | null | undefined, values: lodash.List): T1[]; + } + interface LodashDifferenceWith1x1 { + (array: lodash.List | null | undefined): LodashDifferenceWith1x3; + (array: lodash.__, values: lodash.List): LodashDifferenceWith1x5; + (array: lodash.List | null | undefined, values: lodash.List): T1[]; + } + interface LodashDifferenceWith1x2 { + (comparator: lodash.Comparator2): LodashDifferenceWith1x3; + (comparator: lodash.__, values: lodash.List): LodashDifferenceWith1x6; + (comparator: lodash.Comparator2, values: lodash.List): T1[]; + } + type LodashDifferenceWith1x3 = (values: lodash.List) => T1[]; + interface LodashDifferenceWith1x4 { + (comparator: lodash.Comparator2): LodashDifferenceWith1x5; + (comparator: lodash.__, array: lodash.List | null | undefined): LodashDifferenceWith1x6; + (comparator: lodash.Comparator2, array: lodash.List | null | undefined): T1[]; + } + type LodashDifferenceWith1x5 = (array: lodash.List | null | undefined) => T1[]; + type LodashDifferenceWith1x6 = (comparator: lodash.Comparator2) => T1[]; + interface LodashUnset { + (path: lodash.PropertyPath): LodashUnset1x1; + (path: lodash.__, object: T): LodashUnset1x2; + (path: lodash.PropertyPath, object: T): T; + } + type LodashUnset1x1 = (object: T) => T; + type LodashUnset1x2 = (path: lodash.PropertyPath) => T; + interface LodashDivide { + (dividend: number): LodashDivide1x1; + (dividend: lodash.__, divisor: number): LodashDivide1x2; + (dividend: number, divisor: number): number; + } + type LodashDivide1x1 = (divisor: number) => number; + type LodashDivide1x2 = (dividend: number) => number; + interface LodashDrop { + (n: number): LodashDrop1x1; + (n: lodash.__, array: lodash.List | null | undefined): LodashDrop1x2; + (n: number, array: lodash.List | null | undefined): T[]; + } + type LodashDrop1x1 = (array: lodash.List | null | undefined) => T[]; + type LodashDrop1x2 = (n: number) => T[]; + interface LodashDropRight { + (n: number): LodashDropRight1x1; + (n: lodash.__, array: lodash.List | null | undefined): LodashDropRight1x2; + (n: number, array: lodash.List | null | undefined): T[]; + } + type LodashDropRight1x1 = (array: lodash.List | null | undefined) => T[]; + type LodashDropRight1x2 = (n: number) => T[]; + interface LodashDropRightWhile { + (predicate: lodash.ValueIteratee): LodashDropRightWhile1x1; + (predicate: lodash.__, array: lodash.List | null | undefined): LodashDropRightWhile1x2; + (predicate: lodash.ValueIteratee, array: lodash.List | null | undefined): T[]; + } + type LodashDropRightWhile1x1 = (array: lodash.List | null | undefined) => T[]; + type LodashDropRightWhile1x2 = (predicate: lodash.ValueIteratee) => T[]; + interface LodashDropWhile { + (predicate: lodash.ValueIteratee): LodashDropWhile1x1; + (predicate: lodash.__, array: lodash.List | null | undefined): LodashDropWhile1x2; + (predicate: lodash.ValueIteratee, array: lodash.List | null | undefined): T[]; + } + type LodashDropWhile1x1 = (array: lodash.List | null | undefined) => T[]; + type LodashDropWhile1x2 = (predicate: lodash.ValueIteratee) => T[]; + interface LodashForEach { + (iteratee: (value: T) => any): LodashForEach1x1; + (iteratee: lodash.__, collection: ReadonlyArray): LodashForEach1x2; + (iteratee: (value: T) => any, collection: ReadonlyArray): T[]; + (iteratee: lodash.__, collection: lodash.List): LodashForEach2x2; + (iteratee: (value: T) => any, collection: lodash.List): lodash.List; + (iteratee: lodash.__, collection: T): LodashForEach3x2; + (iteratee: (value: T[keyof T]) => any, collection: T): T; + (iteratee: lodash.__, collection: TArray & (T[] | null | undefined)): LodashForEach4x2; + (iteratee: (value: T) => any, collection: TArray & (T[] | null | undefined)): TArray; + | null | undefined>(iteratee: lodash.__, collection: TList & (lodash.List | null | undefined)): LodashForEach5x2; + | null | undefined>(iteratee: (value: T) => any, collection: TList & (lodash.List | null | undefined)): TList; + (iteratee: lodash.__, collection: T | null | undefined): LodashForEach6x2; + (iteratee: (value: T[keyof T]) => any, collection: T | null | undefined): T | null | undefined; + } + interface LodashForEach1x1 { + (collection: ReadonlyArray): T[]; + (collection: lodash.List): lodash.List; + (collection: T1): T1; + (collection: TArray & (T[] | null | undefined)): TArray; + | null | undefined>(collection: TList & (lodash.List | null | undefined)): TList; + (collection: T1 | null | undefined): T1 | null | undefined; + } + type LodashForEach1x2 = (iteratee: (value: T) => any) => T[]; + type LodashForEach2x2 = (iteratee: (value: T) => any) => lodash.List; + type LodashForEach3x2 = (iteratee: (value: T[keyof T]) => any) => T; + type LodashForEach4x2 = (iteratee: (value: T) => any) => TArray; + type LodashForEach5x2 = (iteratee: (value: T) => any) => TList; + type LodashForEach6x2 = (iteratee: (value: T[keyof T]) => any) => T | null | undefined; + interface LodashForEachRight { + (iteratee: (value: T) => any): LodashForEachRight1x1; + (iteratee: lodash.__, collection: ReadonlyArray): LodashForEachRight1x2; + (iteratee: (value: T) => any, collection: ReadonlyArray): T[]; + (iteratee: lodash.__, collection: lodash.List): LodashForEachRight2x2; + (iteratee: (value: T) => any, collection: lodash.List): lodash.List; + (iteratee: lodash.__, collection: T): LodashForEachRight3x2; + (iteratee: (value: T[keyof T]) => any, collection: T): T; + (iteratee: lodash.__, collection: TArray & (T[] | null | undefined)): LodashForEachRight4x2; + (iteratee: (value: T) => any, collection: TArray & (T[] | null | undefined)): TArray; + | null | undefined>(iteratee: lodash.__, collection: TList & (lodash.List | null | undefined)): LodashForEachRight5x2; + | null | undefined>(iteratee: (value: T) => any, collection: TList & (lodash.List | null | undefined)): TList; + (iteratee: lodash.__, collection: T | null | undefined): LodashForEachRight6x2; + (iteratee: (value: T[keyof T]) => any, collection: T | null | undefined): T | null | undefined; + } + interface LodashForEachRight1x1 { + (collection: ReadonlyArray): T[]; + (collection: lodash.List): lodash.List; + (collection: T1): T1; + (collection: TArray & (T[] | null | undefined)): TArray; + | null | undefined>(collection: TList & (lodash.List | null | undefined)): TList; + (collection: T1 | null | undefined): T1 | null | undefined; + } + type LodashForEachRight1x2 = (iteratee: (value: T) => any) => T[]; + type LodashForEachRight2x2 = (iteratee: (value: T) => any) => lodash.List; + type LodashForEachRight3x2 = (iteratee: (value: T[keyof T]) => any) => T; + type LodashForEachRight4x2 = (iteratee: (value: T) => any) => TArray; + type LodashForEachRight5x2 = (iteratee: (value: T) => any) => TList; + type LodashForEachRight6x2 = (iteratee: (value: T[keyof T]) => any) => T | null | undefined; + interface LodashEndsWith { + (target: string): LodashEndsWith1x1; + (target: lodash.__, string: string): LodashEndsWith1x2; + (target: string, string: string): boolean; + } + type LodashEndsWith1x1 = (string: string) => boolean; + type LodashEndsWith1x2 = (target: string) => boolean; + interface LodashToPairs { + (object: lodash.Dictionary | lodash.NumericDictionary): Array<[string, T]>; + (object: object): Array<[string, any]>; + } + interface LodashToPairsIn { + (object: lodash.Dictionary | lodash.NumericDictionary): Array<[string, T]>; + (object: object): Array<[string, any]>; + } + interface LodashEq { + (value: any): LodashEq1x1; + (value: lodash.__, other: any): LodashEq1x2; + (value: any, other: any): boolean; + } + type LodashEq1x1 = (other: any) => boolean; + type LodashEq1x2 = (value: any) => boolean; + interface LodashIsEqual { + (value: any): LodashIsEqual1x1; + (value: lodash.__, other: any): LodashIsEqual1x2; + (value: any, other: any): boolean; + } + type LodashIsEqual1x1 = (other: any) => boolean; + type LodashIsEqual1x2 = (value: any) => boolean; + type LodashEscape = (string: string) => string; + type LodashEscapeRegExp = (string: string) => string; + interface LodashExtend { + (object: TObject): LodashExtend1x1; + (object: lodash.__, source: TSource): LodashExtend1x2; + (object: TObject, source: TSource): TObject & TSource; + } + type LodashExtend1x1 = (source: TSource) => TObject & TSource; + type LodashExtend1x2 = (object: TObject) => TObject & TSource; + interface LodashExtendAll { + (object: [TObject, TSource]): TObject & TSource; + (object: [TObject, TSource1, TSource2]): TObject & TSource1 & TSource2; + (object: [TObject, TSource1, TSource2, TSource3]): TObject & TSource1 & TSource2 & TSource3; + (object: [TObject, TSource1, TSource2, TSource3, TSource4]): TObject & TSource1 & TSource2 & TSource3 & TSource4; + (object: [TObject]): TObject; + (object: ReadonlyArray): TResult; + } + interface LodashExtendAllWith { + (customizer: lodash.AssignCustomizer): LodashExtendAllWith1x1; + (customizer: lodash.__, args: ReadonlyArray): LodashExtendAllWith1x2; + (customizer: lodash.AssignCustomizer, args: ReadonlyArray): any; + } + type LodashExtendAllWith1x1 = (args: ReadonlyArray) => any; + type LodashExtendAllWith1x2 = (customizer: lodash.AssignCustomizer) => any; + interface LodashExtendWith { + (customizer: lodash.AssignCustomizer): LodashExtendWith1x1; + (customizer: lodash.__, object: TObject): LodashExtendWith1x2; + (customizer: lodash.AssignCustomizer, object: TObject): LodashExtendWith1x3; + (customizer: lodash.__, object: lodash.__, source: TSource): LodashExtendWith1x4; + (customizer: lodash.AssignCustomizer, object: lodash.__, source: TSource): LodashExtendWith1x5; + (customizer: lodash.__, object: TObject, source: TSource): LodashExtendWith1x6; + (customizer: lodash.AssignCustomizer, object: TObject, source: TSource): TObject & TSource; + } + interface LodashExtendWith1x1 { + (object: TObject): LodashExtendWith1x3; + (object: lodash.__, source: TSource): LodashExtendWith1x5; + (object: TObject, source: TSource): TObject & TSource; + } + interface LodashExtendWith1x2 { + (customizer: lodash.AssignCustomizer): LodashExtendWith1x3; + (customizer: lodash.__, source: TSource): LodashExtendWith1x6; + (customizer: lodash.AssignCustomizer, source: TSource): TObject & TSource; + } + type LodashExtendWith1x3 = (source: TSource) => TObject & TSource; + interface LodashExtendWith1x4 { + (customizer: lodash.AssignCustomizer): LodashExtendWith1x5; + (customizer: lodash.__, object: TObject): LodashExtendWith1x6; + (customizer: lodash.AssignCustomizer, object: TObject): TObject & TSource; + } + type LodashExtendWith1x5 = (object: TObject) => TObject & TSource; + type LodashExtendWith1x6 = (customizer: lodash.AssignCustomizer) => TObject & TSource; + type LodashStubFalse = () => false; + interface LodashFill { + (start: number): LodashFill1x1; + (start: lodash.__, end: number): LodashFill1x2; + (start: number, end: number): LodashFill1x3; + (start: lodash.__, end: lodash.__, value: T): LodashFill1x4; + (start: number, end: lodash.__, value: T): LodashFill1x5; + (start: lodash.__, end: number, value: T): LodashFill1x6; + (start: number, end: number, value: T): LodashFill1x7; + (start: lodash.__, end: lodash.__, value: lodash.__, array: U[] | null | undefined): LodashFill1x8; + (start: number, end: lodash.__, value: lodash.__, array: U[] | null | undefined): LodashFill1x9; + (start: lodash.__, end: number, value: lodash.__, array: U[] | null | undefined): LodashFill1x10; + (start: number, end: number, value: lodash.__, array: U[] | null | undefined): LodashFill1x11; + (start: lodash.__, end: lodash.__, value: T, array: U[] | null | undefined): LodashFill1x12; + (start: number, end: lodash.__, value: T, array: U[] | null | undefined): LodashFill1x13; + (start: lodash.__, end: number, value: T, array: U[] | null | undefined): LodashFill1x14; + (start: number, end: number, value: T, array: U[] | null | undefined): Array; + (start: lodash.__, end: lodash.__, value: lodash.__, array: lodash.List | null | undefined): LodashFill2x8; + (start: number, end: lodash.__, value: lodash.__, array: lodash.List | null | undefined): LodashFill2x9; + (start: lodash.__, end: number, value: lodash.__, array: lodash.List | null | undefined): LodashFill2x10; + (start: number, end: number, value: lodash.__, array: lodash.List | null | undefined): LodashFill2x11; + (start: lodash.__, end: lodash.__, value: T, array: lodash.List | null | undefined): LodashFill2x12; + (start: number, end: lodash.__, value: T, array: lodash.List | null | undefined): LodashFill2x13; + (start: lodash.__, end: number, value: T, array: lodash.List | null | undefined): LodashFill2x14; + (start: number, end: number, value: T, array: lodash.List | null | undefined): lodash.List; + } + interface LodashFill1x1 { + (end: number): LodashFill1x3; + (end: lodash.__, value: T): LodashFill1x5; + (end: number, value: T): LodashFill1x7; + (end: lodash.__, value: lodash.__, array: U[] | null | undefined): LodashFill1x9; + (end: number, value: lodash.__, array: U[] | null | undefined): LodashFill1x11; + (end: lodash.__, value: T, array: U[] | null | undefined): LodashFill1x13; + (end: number, value: T, array: U[] | null | undefined): Array; + (end: lodash.__, value: lodash.__, array: lodash.List | null | undefined): LodashFill2x9; + (end: number, value: lodash.__, array: lodash.List | null | undefined): LodashFill2x11; + (end: lodash.__, value: T, array: lodash.List | null | undefined): LodashFill2x13; + (end: number, value: T, array: lodash.List | null | undefined): lodash.List; + } + interface LodashFill1x2 { + (start: number): LodashFill1x3; + (start: lodash.__, value: T): LodashFill1x6; + (start: number, value: T): LodashFill1x7; + (start: lodash.__, value: lodash.__, array: U[] | null | undefined): LodashFill1x10; + (start: number, value: lodash.__, array: U[] | null | undefined): LodashFill1x11; + (start: lodash.__, value: T, array: U[] | null | undefined): LodashFill1x14; + (start: number, value: T, array: U[] | null | undefined): Array; + (start: lodash.__, value: lodash.__, array: lodash.List | null | undefined): LodashFill2x10; + (start: number, value: lodash.__, array: lodash.List | null | undefined): LodashFill2x11; + (start: lodash.__, value: T, array: lodash.List | null | undefined): LodashFill2x14; + (start: number, value: T, array: lodash.List | null | undefined): lodash.List; + } + interface LodashFill1x3 { + (value: T): LodashFill1x7; + (value: lodash.__, array: U[] | null | undefined): LodashFill1x11; + (value: T, array: U[] | null | undefined): Array; + (value: lodash.__, array: lodash.List | null | undefined): LodashFill2x11; + (value: T, array: lodash.List | null | undefined): lodash.List; + } + interface LodashFill1x4 { + (start: number): LodashFill1x5; + (start: lodash.__, end: number): LodashFill1x6; + (start: number, end: number): LodashFill1x7; + (start: lodash.__, end: lodash.__, array: U[] | null | undefined): LodashFill1x12; + (start: number, end: lodash.__, array: U[] | null | undefined): LodashFill1x13; + (start: lodash.__, end: number, array: U[] | null | undefined): LodashFill1x14; + (start: number, end: number, array: U[] | null | undefined): Array; + (start: lodash.__, end: lodash.__, array: lodash.List | null | undefined): LodashFill2x12; + (start: number, end: lodash.__, array: lodash.List | null | undefined): LodashFill2x13; + (start: lodash.__, end: number, array: lodash.List | null | undefined): LodashFill2x14; + (start: number, end: number, array: lodash.List | null | undefined): lodash.List; + } + interface LodashFill1x5 { + (end: number): LodashFill1x7; + (end: lodash.__, array: U[] | null | undefined): LodashFill1x13; + (end: number, array: U[] | null | undefined): Array; + (end: lodash.__, array: lodash.List | null | undefined): LodashFill2x13; + (end: number, array: lodash.List | null | undefined): lodash.List; + } + interface LodashFill1x6 { + (start: number): LodashFill1x7; + (start: lodash.__, array: U[] | null | undefined): LodashFill1x14; + (start: number, array: U[] | null | undefined): Array; + (start: lodash.__, array: lodash.List | null | undefined): LodashFill2x14; + (start: number, array: lodash.List | null | undefined): lodash.List; + } + interface LodashFill1x7 { + (array: U[] | null | undefined): Array; + (array: lodash.List | null | undefined): lodash.List; + } + interface LodashFill1x8 { + (start: number): LodashFill1x9; + (start: lodash.__, end: number): LodashFill1x10; + (start: number, end: number): LodashFill1x11; + (start: lodash.__, end: lodash.__, value: T): LodashFill1x12; + (start: number, end: lodash.__, value: T): LodashFill1x13; + (start: lodash.__, end: number, value: T): LodashFill1x14; + (start: number, end: number, value: T): Array; + } + interface LodashFill1x9 { + (end: number): LodashFill1x11; + (end: lodash.__, value: T): LodashFill1x13; + (end: number, value: T): Array; + } + interface LodashFill1x10 { + (start: number): LodashFill1x11; + (start: lodash.__, value: T): LodashFill1x14; + (start: number, value: T): Array; + } + type LodashFill1x11 = (value: T) => Array; + interface LodashFill1x12 { + (start: number): LodashFill1x13; + (start: lodash.__, end: number): LodashFill1x14; + (start: number, end: number): Array; + } + type LodashFill1x13 = (end: number) => Array; + type LodashFill1x14 = (start: number) => Array; + interface LodashFill2x8 { + (start: number): LodashFill2x9; + (start: lodash.__, end: number): LodashFill2x10; + (start: number, end: number): LodashFill2x11; + (start: lodash.__, end: lodash.__, value: T): LodashFill2x12; + (start: number, end: lodash.__, value: T): LodashFill2x13; + (start: lodash.__, end: number, value: T): LodashFill2x14; + (start: number, end: number, value: T): lodash.List; + } + interface LodashFill2x9 { + (end: number): LodashFill2x11; + (end: lodash.__, value: T): LodashFill2x13; + (end: number, value: T): lodash.List; + } + interface LodashFill2x10 { + (start: number): LodashFill2x11; + (start: lodash.__, value: T): LodashFill2x14; + (start: number, value: T): lodash.List; + } + type LodashFill2x11 = (value: T) => lodash.List; + interface LodashFill2x12 { + (start: number): LodashFill2x13; + (start: lodash.__, end: number): LodashFill2x14; + (start: number, end: number): lodash.List; + } + type LodashFill2x13 = (end: number) => lodash.List; + type LodashFill2x14 = (start: number) => lodash.List; + interface LodashFilter { + (predicate: lodash.ValueIteratorTypeGuard): LodashFilter1x1; + (predicate: lodash.__, collection: lodash.List | null | undefined): LodashFilter1x2; + (predicate: lodash.ValueIteratorTypeGuard, collection: lodash.List | null | undefined): S[]; + (predicate: lodash.ValueIterateeCustom): LodashFilter2x1; + (predicate: lodash.ValueIterateeCustom, collection: lodash.List | null | undefined): T[]; + (predicate: lodash.ValueIteratorTypeGuard): LodashFilter3x1; + (predicate: lodash.__, collection: T | null | undefined): LodashFilter3x2; + (predicate: lodash.ValueIteratorTypeGuard, collection: T | null | undefined): S[]; + (predicate: lodash.ValueIterateeCustom, collection: T | null | undefined): Array; + } + type LodashFilter1x1 = (collection: lodash.List | null | undefined) => S[]; + interface LodashFilter1x2 { + (predicate: lodash.ValueIteratorTypeGuard): S[]; + (predicate: lodash.ValueIterateeCustom): T[]; + } + type LodashFilter2x1 = (collection: lodash.List | object | null | undefined) => T[]; + type LodashFilter3x1 = (collection: T | null | undefined) => S[]; + interface LodashFilter3x2 { + (predicate: lodash.ValueIteratorTypeGuard): S[]; + (predicate: lodash.ValueIterateeCustom): Array; + } + interface LodashFind { + (predicate: lodash.ValueIteratorTypeGuard): LodashFind1x1; + (predicate: lodash.__, collection: lodash.List | null | undefined): LodashFind1x2; + (predicate: lodash.ValueIteratorTypeGuard, collection: lodash.List | null | undefined): S|undefined; + (predicate: lodash.ValueIterateeCustom): LodashFind2x1; + (predicate: lodash.ValueIterateeCustom, collection: lodash.List | null | undefined): T|undefined; + (predicate: lodash.ValueIteratorTypeGuard): LodashFind3x1; + (predicate: lodash.__, collection: T | null | undefined): LodashFind3x2; + (predicate: lodash.ValueIteratorTypeGuard, collection: T | null | undefined): S|undefined; + (predicate: lodash.ValueIterateeCustom, collection: T | null | undefined): T[keyof T]|undefined; + } + type LodashFind1x1 = (collection: lodash.List | null | undefined) => S|undefined; + interface LodashFind1x2 { + (predicate: lodash.ValueIteratorTypeGuard): S|undefined; + (predicate: lodash.ValueIterateeCustom): T|undefined; + } + type LodashFind2x1 = (collection: lodash.List | object | null | undefined) => T|undefined; + type LodashFind3x1 = (collection: T | null | undefined) => S|undefined; + interface LodashFind3x2 { + (predicate: lodash.ValueIteratorTypeGuard): S|undefined; + (predicate: lodash.ValueIterateeCustom): T[keyof T]|undefined; + } + interface LodashFindFrom { + (predicate: lodash.ValueIteratorTypeGuard): LodashFindFrom1x1; + (predicate: lodash.__, fromIndex: number): LodashFindFrom1x2; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: number): LodashFindFrom1x3; + (predicate: lodash.__, fromIndex: lodash.__, collection: lodash.List | null | undefined): LodashFindFrom1x4; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: lodash.__, collection: lodash.List | null | undefined): LodashFindFrom1x5; + (predicate: lodash.__, fromIndex: number, collection: lodash.List | null | undefined): LodashFindFrom1x6; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: number, collection: lodash.List | null | undefined): S|undefined; + (predicate: lodash.ValueIterateeCustom): LodashFindFrom2x1; + (predicate: lodash.ValueIterateeCustom, fromIndex: number): LodashFindFrom2x3; + (predicate: lodash.ValueIterateeCustom, fromIndex: lodash.__, collection: lodash.List | null | undefined): LodashFindFrom2x5; + (predicate: lodash.ValueIterateeCustom, fromIndex: number, collection: lodash.List | null | undefined): T|undefined; + (predicate: lodash.ValueIteratorTypeGuard): LodashFindFrom3x1; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: number): LodashFindFrom3x3; + (predicate: lodash.__, fromIndex: lodash.__, collection: T | null | undefined): LodashFindFrom3x4; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: lodash.__, collection: T | null | undefined): LodashFindFrom3x5; + (predicate: lodash.__, fromIndex: number, collection: T | null | undefined): LodashFindFrom3x6; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: number, collection: T | null | undefined): S|undefined; + (predicate: lodash.ValueIterateeCustom, fromIndex: lodash.__, collection: T | null | undefined): LodashFindFrom4x5; + (predicate: lodash.ValueIterateeCustom, fromIndex: number, collection: T | null | undefined): T[keyof T]|undefined; + } + interface LodashFindFrom1x1 { + (fromIndex: number): LodashFindFrom1x3; + (fromIndex: lodash.__, collection: lodash.List | null | undefined): LodashFindFrom1x5; + (fromIndex: number, collection: lodash.List | null | undefined): S|undefined; + } + interface LodashFindFrom1x2 { + (predicate: lodash.ValueIteratorTypeGuard): LodashFindFrom1x3; + (predicate: lodash.__, collection: lodash.List | null | undefined): LodashFindFrom1x6; + (predicate: lodash.ValueIteratorTypeGuard, collection: lodash.List | null | undefined): S|undefined; + (predicate: lodash.ValueIterateeCustom): LodashFindFrom2x3; + (predicate: lodash.ValueIterateeCustom, collection: lodash.List | null | undefined): T|undefined; + (predicate: lodash.ValueIteratorTypeGuard): LodashFindFrom3x3; + (predicate: lodash.__, collection: T | null | undefined): LodashFindFrom3x6; + (predicate: lodash.ValueIteratorTypeGuard, collection: T | null | undefined): S|undefined; + (predicate: lodash.ValueIterateeCustom, collection: T | null | undefined): T[keyof T]|undefined; + } + type LodashFindFrom1x3 = (collection: lodash.List | null | undefined) => S|undefined; + interface LodashFindFrom1x4 { + (predicate: lodash.ValueIteratorTypeGuard): LodashFindFrom1x5; + (predicate: lodash.__, fromIndex: number): LodashFindFrom1x6; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: number): S|undefined; + (predicate: lodash.ValueIterateeCustom): LodashFindFrom2x5; + (predicate: lodash.ValueIterateeCustom, fromIndex: number): T|undefined; + } + type LodashFindFrom1x5 = (fromIndex: number) => S|undefined; + interface LodashFindFrom1x6 { + (predicate: lodash.ValueIteratorTypeGuard): S|undefined; + (predicate: lodash.ValueIterateeCustom): T|undefined; + } + interface LodashFindFrom2x1 { + (fromIndex: number): LodashFindFrom2x3; + (fromIndex: lodash.__, collection: lodash.List | null | undefined): LodashFindFrom2x5; + (fromIndex: number, collection: lodash.List | object | null | undefined): T|undefined; + (fromIndex: lodash.__, collection: T1 | null | undefined): LodashFindFrom4x5; + } + interface LodashFindFrom2x3 { + (collection: lodash.List | null | undefined): T|undefined; + (collection: object | null | undefined): object|undefined; + } + type LodashFindFrom2x5 = (fromIndex: number) => T|undefined; + interface LodashFindFrom3x1 { + (fromIndex: number): LodashFindFrom3x3; + (fromIndex: lodash.__, collection: T | null | undefined): LodashFindFrom3x5; + (fromIndex: number, collection: T | null | undefined): S|undefined; + } + type LodashFindFrom3x3 = (collection: T | null | undefined) => S|undefined; + interface LodashFindFrom3x4 { + (predicate: lodash.ValueIteratorTypeGuard): LodashFindFrom3x5; + (predicate: lodash.__, fromIndex: number): LodashFindFrom3x6; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: number): S|undefined; + (predicate: lodash.ValueIterateeCustom): LodashFindFrom4x5; + (predicate: lodash.ValueIterateeCustom, fromIndex: number): T[keyof T]|undefined; + } + type LodashFindFrom3x5 = (fromIndex: number) => S|undefined; + interface LodashFindFrom3x6 { + (predicate: lodash.ValueIteratorTypeGuard): S|undefined; + (predicate: lodash.ValueIterateeCustom): T[keyof T]|undefined; + } + type LodashFindFrom4x5 = (fromIndex: number) => T[keyof T]|undefined; + interface LodashFindIndex { + (predicate: lodash.ValueIterateeCustom): LodashFindIndex1x1; + (predicate: lodash.__, array: lodash.List | null | undefined): LodashFindIndex1x2; + (predicate: lodash.ValueIterateeCustom, array: lodash.List | null | undefined): number; + } + type LodashFindIndex1x1 = (array: lodash.List | null | undefined) => number; + type LodashFindIndex1x2 = (predicate: lodash.ValueIterateeCustom) => number; + interface LodashFindIndexFrom { + (predicate: lodash.ValueIterateeCustom): LodashFindIndexFrom1x1; + (predicate: lodash.__, fromIndex: number): LodashFindIndexFrom1x2; + (predicate: lodash.ValueIterateeCustom, fromIndex: number): LodashFindIndexFrom1x3; + (predicate: lodash.__, fromIndex: lodash.__, array: lodash.List | null | undefined): LodashFindIndexFrom1x4; + (predicate: lodash.ValueIterateeCustom, fromIndex: lodash.__, array: lodash.List | null | undefined): LodashFindIndexFrom1x5; + (predicate: lodash.__, fromIndex: number, array: lodash.List | null | undefined): LodashFindIndexFrom1x6; + (predicate: lodash.ValueIterateeCustom, fromIndex: number, array: lodash.List | null | undefined): number; + } + interface LodashFindIndexFrom1x1 { + (fromIndex: number): LodashFindIndexFrom1x3; + (fromIndex: lodash.__, array: lodash.List | null | undefined): LodashFindIndexFrom1x5; + (fromIndex: number, array: lodash.List | null | undefined): number; + } + interface LodashFindIndexFrom1x2 { + (predicate: lodash.ValueIterateeCustom): LodashFindIndexFrom1x3; + (predicate: lodash.__, array: lodash.List | null | undefined): LodashFindIndexFrom1x6; + (predicate: lodash.ValueIterateeCustom, array: lodash.List | null | undefined): number; + } + type LodashFindIndexFrom1x3 = (array: lodash.List | null | undefined) => number; + interface LodashFindIndexFrom1x4 { + (predicate: lodash.ValueIterateeCustom): LodashFindIndexFrom1x5; + (predicate: lodash.__, fromIndex: number): LodashFindIndexFrom1x6; + (predicate: lodash.ValueIterateeCustom, fromIndex: number): number; + } + type LodashFindIndexFrom1x5 = (fromIndex: number) => number; + type LodashFindIndexFrom1x6 = (predicate: lodash.ValueIterateeCustom) => number; + interface LodashFindKey { + (predicate: lodash.ValueIteratee): LodashFindKey1x1; + (predicate: lodash.__, object: T | null | undefined): LodashFindKey1x2; + (predicate: lodash.ValueIteratee, object: T | null | undefined): string | undefined; + } + type LodashFindKey1x1 = (object: object | null | undefined) => string | undefined; + type LodashFindKey1x2 = (predicate: lodash.ValueIteratee) => string | undefined; + interface LodashFindLast { + (predicate: lodash.ValueIteratorTypeGuard): LodashFindLast1x1; + (predicate: lodash.__, collection: lodash.List | null | undefined): LodashFindLast1x2; + (predicate: lodash.ValueIteratorTypeGuard, collection: lodash.List | null | undefined): S|undefined; + (predicate: lodash.ValueIterateeCustom): LodashFindLast2x1; + (predicate: lodash.ValueIterateeCustom, collection: lodash.List | null | undefined): T|undefined; + (predicate: lodash.ValueIteratorTypeGuard): LodashFindLast3x1; + (predicate: lodash.__, collection: T | null | undefined): LodashFindLast3x2; + (predicate: lodash.ValueIteratorTypeGuard, collection: T | null | undefined): S|undefined; + (predicate: lodash.ValueIterateeCustom, collection: T | null | undefined): T[keyof T]|undefined; + } + type LodashFindLast1x1 = (collection: lodash.List | null | undefined) => S|undefined; + interface LodashFindLast1x2 { + (predicate: lodash.ValueIteratorTypeGuard): S|undefined; + (predicate: lodash.ValueIterateeCustom): T|undefined; + } + type LodashFindLast2x1 = (collection: lodash.List | object | null | undefined) => T|undefined; + type LodashFindLast3x1 = (collection: T | null | undefined) => S|undefined; + interface LodashFindLast3x2 { + (predicate: lodash.ValueIteratorTypeGuard): S|undefined; + (predicate: lodash.ValueIterateeCustom): T[keyof T]|undefined; + } + interface LodashFindLastFrom { + (predicate: lodash.ValueIteratorTypeGuard): LodashFindLastFrom1x1; + (predicate: lodash.__, fromIndex: number): LodashFindLastFrom1x2; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: number): LodashFindLastFrom1x3; + (predicate: lodash.__, fromIndex: lodash.__, collection: lodash.List | null | undefined): LodashFindLastFrom1x4; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: lodash.__, collection: lodash.List | null | undefined): LodashFindLastFrom1x5; + (predicate: lodash.__, fromIndex: number, collection: lodash.List | null | undefined): LodashFindLastFrom1x6; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: number, collection: lodash.List | null | undefined): S|undefined; + (predicate: lodash.ValueIterateeCustom): LodashFindLastFrom2x1; + (predicate: lodash.ValueIterateeCustom, fromIndex: number): LodashFindLastFrom2x3; + (predicate: lodash.ValueIterateeCustom, fromIndex: lodash.__, collection: lodash.List | null | undefined): LodashFindLastFrom2x5; + (predicate: lodash.ValueIterateeCustom, fromIndex: number, collection: lodash.List | null | undefined): T|undefined; + (predicate: lodash.ValueIteratorTypeGuard): LodashFindLastFrom3x1; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: number): LodashFindLastFrom3x3; + (predicate: lodash.__, fromIndex: lodash.__, collection: T | null | undefined): LodashFindLastFrom3x4; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: lodash.__, collection: T | null | undefined): LodashFindLastFrom3x5; + (predicate: lodash.__, fromIndex: number, collection: T | null | undefined): LodashFindLastFrom3x6; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: number, collection: T | null | undefined): S|undefined; + (predicate: lodash.ValueIterateeCustom, fromIndex: lodash.__, collection: T | null | undefined): LodashFindLastFrom4x5; + (predicate: lodash.ValueIterateeCustom, fromIndex: number, collection: T | null | undefined): T[keyof T]|undefined; + } + interface LodashFindLastFrom1x1 { + (fromIndex: number): LodashFindLastFrom1x3; + (fromIndex: lodash.__, collection: lodash.List | null | undefined): LodashFindLastFrom1x5; + (fromIndex: number, collection: lodash.List | null | undefined): S|undefined; + } + interface LodashFindLastFrom1x2 { + (predicate: lodash.ValueIteratorTypeGuard): LodashFindLastFrom1x3; + (predicate: lodash.__, collection: lodash.List | null | undefined): LodashFindLastFrom1x6; + (predicate: lodash.ValueIteratorTypeGuard, collection: lodash.List | null | undefined): S|undefined; + (predicate: lodash.ValueIterateeCustom): LodashFindLastFrom2x3; + (predicate: lodash.ValueIterateeCustom, collection: lodash.List | null | undefined): T|undefined; + (predicate: lodash.ValueIteratorTypeGuard): LodashFindLastFrom3x3; + (predicate: lodash.__, collection: T | null | undefined): LodashFindLastFrom3x6; + (predicate: lodash.ValueIteratorTypeGuard, collection: T | null | undefined): S|undefined; + (predicate: lodash.ValueIterateeCustom, collection: T | null | undefined): T[keyof T]|undefined; + } + type LodashFindLastFrom1x3 = (collection: lodash.List | null | undefined) => S|undefined; + interface LodashFindLastFrom1x4 { + (predicate: lodash.ValueIteratorTypeGuard): LodashFindLastFrom1x5; + (predicate: lodash.__, fromIndex: number): LodashFindLastFrom1x6; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: number): S|undefined; + (predicate: lodash.ValueIterateeCustom): LodashFindLastFrom2x5; + (predicate: lodash.ValueIterateeCustom, fromIndex: number): T|undefined; + } + type LodashFindLastFrom1x5 = (fromIndex: number) => S|undefined; + interface LodashFindLastFrom1x6 { + (predicate: lodash.ValueIteratorTypeGuard): S|undefined; + (predicate: lodash.ValueIterateeCustom): T|undefined; + } + interface LodashFindLastFrom2x1 { + (fromIndex: number): LodashFindLastFrom2x3; + (fromIndex: lodash.__, collection: lodash.List | null | undefined): LodashFindLastFrom2x5; + (fromIndex: number, collection: lodash.List | object | null | undefined): T|undefined; + (fromIndex: lodash.__, collection: T1 | null | undefined): LodashFindLastFrom4x5; + } + interface LodashFindLastFrom2x3 { + (collection: lodash.List | null | undefined): T|undefined; + (collection: object | null | undefined): object|undefined; + } + type LodashFindLastFrom2x5 = (fromIndex: number) => T|undefined; + interface LodashFindLastFrom3x1 { + (fromIndex: number): LodashFindLastFrom3x3; + (fromIndex: lodash.__, collection: T | null | undefined): LodashFindLastFrom3x5; + (fromIndex: number, collection: T | null | undefined): S|undefined; + } + type LodashFindLastFrom3x3 = (collection: T | null | undefined) => S|undefined; + interface LodashFindLastFrom3x4 { + (predicate: lodash.ValueIteratorTypeGuard): LodashFindLastFrom3x5; + (predicate: lodash.__, fromIndex: number): LodashFindLastFrom3x6; + (predicate: lodash.ValueIteratorTypeGuard, fromIndex: number): S|undefined; + (predicate: lodash.ValueIterateeCustom): LodashFindLastFrom4x5; + (predicate: lodash.ValueIterateeCustom, fromIndex: number): T[keyof T]|undefined; + } + type LodashFindLastFrom3x5 = (fromIndex: number) => S|undefined; + interface LodashFindLastFrom3x6 { + (predicate: lodash.ValueIteratorTypeGuard): S|undefined; + (predicate: lodash.ValueIterateeCustom): T[keyof T]|undefined; + } + type LodashFindLastFrom4x5 = (fromIndex: number) => T[keyof T]|undefined; + interface LodashFindLastIndex { + (predicate: lodash.ValueIterateeCustom): LodashFindLastIndex1x1; + (predicate: lodash.__, array: lodash.List | null | undefined): LodashFindLastIndex1x2; + (predicate: lodash.ValueIterateeCustom, array: lodash.List | null | undefined): number; + } + type LodashFindLastIndex1x1 = (array: lodash.List | null | undefined) => number; + type LodashFindLastIndex1x2 = (predicate: lodash.ValueIterateeCustom) => number; + interface LodashFindLastIndexFrom { + (predicate: lodash.ValueIterateeCustom): LodashFindLastIndexFrom1x1; + (predicate: lodash.__, fromIndex: number): LodashFindLastIndexFrom1x2; + (predicate: lodash.ValueIterateeCustom, fromIndex: number): LodashFindLastIndexFrom1x3; + (predicate: lodash.__, fromIndex: lodash.__, array: lodash.List | null | undefined): LodashFindLastIndexFrom1x4; + (predicate: lodash.ValueIterateeCustom, fromIndex: lodash.__, array: lodash.List | null | undefined): LodashFindLastIndexFrom1x5; + (predicate: lodash.__, fromIndex: number, array: lodash.List | null | undefined): LodashFindLastIndexFrom1x6; + (predicate: lodash.ValueIterateeCustom, fromIndex: number, array: lodash.List | null | undefined): number; + } + interface LodashFindLastIndexFrom1x1 { + (fromIndex: number): LodashFindLastIndexFrom1x3; + (fromIndex: lodash.__, array: lodash.List | null | undefined): LodashFindLastIndexFrom1x5; + (fromIndex: number, array: lodash.List | null | undefined): number; + } + interface LodashFindLastIndexFrom1x2 { + (predicate: lodash.ValueIterateeCustom): LodashFindLastIndexFrom1x3; + (predicate: lodash.__, array: lodash.List | null | undefined): LodashFindLastIndexFrom1x6; + (predicate: lodash.ValueIterateeCustom, array: lodash.List | null | undefined): number; + } + type LodashFindLastIndexFrom1x3 = (array: lodash.List | null | undefined) => number; + interface LodashFindLastIndexFrom1x4 { + (predicate: lodash.ValueIterateeCustom): LodashFindLastIndexFrom1x5; + (predicate: lodash.__, fromIndex: number): LodashFindLastIndexFrom1x6; + (predicate: lodash.ValueIterateeCustom, fromIndex: number): number; + } + type LodashFindLastIndexFrom1x5 = (fromIndex: number) => number; + type LodashFindLastIndexFrom1x6 = (predicate: lodash.ValueIterateeCustom) => number; + interface LodashFindLastKey { + (predicate: lodash.ValueIteratee): LodashFindLastKey1x1; + (predicate: lodash.__, object: T | null | undefined): LodashFindLastKey1x2; + (predicate: lodash.ValueIteratee, object: T | null | undefined): string | undefined; + } + type LodashFindLastKey1x1 = (object: object | null | undefined) => string | undefined; + type LodashFindLastKey1x2 = (predicate: lodash.ValueIteratee) => string | undefined; + type LodashHead = (array: lodash.List | null | undefined) => T | undefined; + interface LodashFlatMap { + (iteratee: (value: T) => lodash.Many): LodashFlatMap1x1; + (iteratee: lodash.__, collection: lodash.List | null | undefined): LodashFlatMap1x2; + (iteratee: (value: T) => lodash.Many, collection: lodash.List | null | undefined): TResult[]; + (iteratee: (value: T[keyof T]) => lodash.Many): LodashFlatMap2x1; + (iteratee: lodash.__, collection: T | null | undefined): LodashFlatMap2x2; + (iteratee: (value: T[keyof T]) => lodash.Many, collection: T | null | undefined): TResult[]; + (iteratee: string): LodashFlatMap3x1; + (iteratee: lodash.__, collection: object | null | undefined): LodashFlatMap3x2; + (iteratee: string, collection: object | null | undefined): any[]; + (iteratee: object): LodashFlatMap4x1; + (iteratee: object, collection: object | null | undefined): boolean[]; + } + type LodashFlatMap1x1 = (collection: lodash.List | null | undefined) => TResult[]; + type LodashFlatMap1x2 = (iteratee: (value: T) => lodash.Many) => TResult[]; + type LodashFlatMap2x1 = (collection: T | null | undefined) => TResult[]; + type LodashFlatMap2x2 = (iteratee: (value: T[keyof T]) => lodash.Many) => TResult[]; + type LodashFlatMap3x1 = (collection: object | null | undefined) => any[]; + interface LodashFlatMap3x2 { + (iteratee: string): any[]; + (iteratee: object): boolean[]; + } + type LodashFlatMap4x1 = (collection: object | null | undefined) => boolean[]; + interface LodashFlatMapDeep { + (iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues | TResult): LodashFlatMapDeep1x1; + (iteratee: lodash.__, collection: lodash.List | null | undefined): LodashFlatMapDeep1x2; + (iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues | TResult, collection: lodash.List | null | undefined): TResult[]; + (iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues | TResult): LodashFlatMapDeep2x1; + (iteratee: lodash.__, collection: T | null | undefined): LodashFlatMapDeep2x2; + (iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues | TResult, collection: T | null | undefined): TResult[]; + (iteratee: string): LodashFlatMapDeep3x1; + (iteratee: lodash.__, collection: object | null | undefined): LodashFlatMapDeep3x2; + (iteratee: string, collection: object | null | undefined): any[]; + (iteratee: object): LodashFlatMapDeep4x1; + (iteratee: object, collection: object | null | undefined): boolean[]; + } + type LodashFlatMapDeep1x1 = (collection: lodash.List | null | undefined) => TResult[]; + type LodashFlatMapDeep1x2 = (iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues | TResult) => TResult[]; + type LodashFlatMapDeep2x1 = (collection: T | null | undefined) => TResult[]; + type LodashFlatMapDeep2x2 = (iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues | TResult) => TResult[]; + type LodashFlatMapDeep3x1 = (collection: object | null | undefined) => any[]; + interface LodashFlatMapDeep3x2 { + (iteratee: string): any[]; + (iteratee: object): boolean[]; + } + type LodashFlatMapDeep4x1 = (collection: object | null | undefined) => boolean[]; + interface LodashFlatMapDepth { + (iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues | TResult): LodashFlatMapDepth1x1; + (iteratee: lodash.__, depth: number): LodashFlatMapDepth1x2; + (iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues | TResult, depth: number): LodashFlatMapDepth1x3; + (iteratee: lodash.__, depth: lodash.__, collection: lodash.List | null | undefined): LodashFlatMapDepth1x4; + (iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues | TResult, depth: lodash.__, collection: lodash.List | null | undefined): LodashFlatMapDepth1x5; + (iteratee: lodash.__, depth: number, collection: lodash.List | null | undefined): LodashFlatMapDepth1x6; + (iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues | TResult, depth: number, collection: lodash.List | null | undefined): TResult[]; + (iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues | TResult): LodashFlatMapDepth2x1; + (iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues | TResult, depth: number): LodashFlatMapDepth2x3; + (iteratee: lodash.__, depth: lodash.__, collection: T | null | undefined): LodashFlatMapDepth2x4; + (iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues | TResult, depth: lodash.__, collection: T | null | undefined): LodashFlatMapDepth2x5; + (iteratee: lodash.__, depth: number, collection: T | null | undefined): LodashFlatMapDepth2x6; + (iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues | TResult, depth: number, collection: T | null | undefined): TResult[]; + (iteratee: string): LodashFlatMapDepth3x1; + (iteratee: string, depth: number): LodashFlatMapDepth3x3; + (iteratee: lodash.__, depth: lodash.__, collection: object | null | undefined): LodashFlatMapDepth3x4; + (iteratee: string, depth: lodash.__, collection: object | null | undefined): LodashFlatMapDepth3x5; + (iteratee: lodash.__, depth: number, collection: object | null | undefined): LodashFlatMapDepth3x6; + (iteratee: string, depth: number, collection: object | null | undefined): any[]; + (iteratee: object): LodashFlatMapDepth4x1; + (iteratee: object, depth: number): LodashFlatMapDepth4x3; + (iteratee: object, depth: lodash.__, collection: object | null | undefined): LodashFlatMapDepth4x5; + (iteratee: object, depth: number, collection: object | null | undefined): boolean[]; + } + interface LodashFlatMapDepth1x1 { + (depth: number): LodashFlatMapDepth1x3; + (depth: lodash.__, collection: lodash.List | null | undefined): LodashFlatMapDepth1x5; + (depth: number, collection: lodash.List | null | undefined): TResult[]; + } + interface LodashFlatMapDepth1x2 { + (iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues | TResult): LodashFlatMapDepth1x3; + (iteratee: lodash.__, collection: lodash.List | null | undefined): LodashFlatMapDepth1x6; + (iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues | TResult, collection: lodash.List | null | undefined): TResult[]; + (iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues | TResult): LodashFlatMapDepth2x3; + (iteratee: lodash.__, collection: T | null | undefined): LodashFlatMapDepth2x6; + (iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues | TResult, collection: T | null | undefined): TResult[]; + (iteratee: string): LodashFlatMapDepth3x3; + (iteratee: lodash.__, collection: object | null | undefined): LodashFlatMapDepth3x6; + (iteratee: string, collection: object | null | undefined): any[]; + (iteratee: object): LodashFlatMapDepth4x3; + (iteratee: object, collection: object | null | undefined): boolean[]; + } + type LodashFlatMapDepth1x3 = (collection: lodash.List | null | undefined) => TResult[]; + interface LodashFlatMapDepth1x4 { + (iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues | TResult): LodashFlatMapDepth1x5; + (iteratee: lodash.__, depth: number): LodashFlatMapDepth1x6; + (iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues | TResult, depth: number): TResult[]; + } + type LodashFlatMapDepth1x5 = (depth: number) => TResult[]; + type LodashFlatMapDepth1x6 = (iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues | TResult) => TResult[]; + interface LodashFlatMapDepth2x1 { + (depth: number): LodashFlatMapDepth2x3; + (depth: lodash.__, collection: T | null | undefined): LodashFlatMapDepth2x5; + (depth: number, collection: T | null | undefined): TResult[]; + } + type LodashFlatMapDepth2x3 = (collection: T | null | undefined) => TResult[]; + interface LodashFlatMapDepth2x4 { + (iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues | TResult): LodashFlatMapDepth2x5; + (iteratee: lodash.__, depth: number): LodashFlatMapDepth2x6; + (iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues | TResult, depth: number): TResult[]; + } + type LodashFlatMapDepth2x5 = (depth: number) => TResult[]; + type LodashFlatMapDepth2x6 = (iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues | TResult) => TResult[]; + interface LodashFlatMapDepth3x1 { + (depth: number): LodashFlatMapDepth3x3; + (depth: lodash.__, collection: object | null | undefined): LodashFlatMapDepth3x5; + (depth: number, collection: object | null | undefined): any[]; + } + type LodashFlatMapDepth3x3 = (collection: object | null | undefined) => any[]; + interface LodashFlatMapDepth3x4 { + (iteratee: string): LodashFlatMapDepth3x5; + (iteratee: lodash.__, depth: number): LodashFlatMapDepth3x6; + (iteratee: string, depth: number): any[]; + (iteratee: object): LodashFlatMapDepth4x5; + (iteratee: object, depth: number): boolean[]; + } + type LodashFlatMapDepth3x5 = (depth: number) => any[]; + interface LodashFlatMapDepth3x6 { + (iteratee: string): any[]; + (iteratee: object): boolean[]; + } + interface LodashFlatMapDepth4x1 { + (depth: number): LodashFlatMapDepth4x3; + (depth: lodash.__, collection: object | null | undefined): LodashFlatMapDepth4x5; + (depth: number, collection: object | null | undefined): boolean[]; + } + type LodashFlatMapDepth4x3 = (collection: object | null | undefined) => boolean[]; + type LodashFlatMapDepth4x5 = (depth: number) => boolean[]; + type LodashFlatten = (array: lodash.List> | null | undefined) => T[]; + type LodashFlattenDeep = (array: lodash.ListOfRecursiveArraysOrValues | null | undefined) => T[]; + interface LodashFlattenDepth { + (depth: number): LodashFlattenDepth1x1; + (depth: lodash.__, array: lodash.ListOfRecursiveArraysOrValues | null | undefined): LodashFlattenDepth1x2; + (depth: number, array: lodash.ListOfRecursiveArraysOrValues | null | undefined): T[]; + } + type LodashFlattenDepth1x1 = (array: lodash.ListOfRecursiveArraysOrValues | null | undefined) => T[]; + type LodashFlattenDepth1x2 = (depth: number) => T[]; + type LodashFlip = any>(func: T) => T; + type LodashFloor = (n: number) => number; + interface LodashFlow { + (f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (...args: A) => R7; + (f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array any>>): (...args: A) => any; + (f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (...args: A) => R6; + (f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5; + (f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4; + (f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3; + (f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2; + (...func: Array any>>): (...args: any[]) => any; + } + interface LodashForIn { + (iteratee: (value: T) => any): LodashForIn1x1; + (iteratee: lodash.__, object: T): LodashForIn1x2; + (iteratee: (value: T[keyof T]) => any, object: T): T; + (iteratee: lodash.__, object: T | null | undefined): LodashForIn2x2; + (iteratee: (value: T[keyof T]) => any, object: T | null | undefined): T | null | undefined; + } + interface LodashForIn1x1 { + (object: T1): T1; + (object: T1 | null | undefined): T1 | null | undefined; + } + type LodashForIn1x2 = (iteratee: (value: T[keyof T]) => any) => T; + type LodashForIn2x2 = (iteratee: (value: T[keyof T]) => any) => T | null | undefined; + interface LodashForInRight { + (iteratee: (value: T) => any): LodashForInRight1x1; + (iteratee: lodash.__, object: T): LodashForInRight1x2; + (iteratee: (value: T[keyof T]) => any, object: T): T; + (iteratee: lodash.__, object: T | null | undefined): LodashForInRight2x2; + (iteratee: (value: T[keyof T]) => any, object: T | null | undefined): T | null | undefined; + } + interface LodashForInRight1x1 { + (object: T1): T1; + (object: T1 | null | undefined): T1 | null | undefined; + } + type LodashForInRight1x2 = (iteratee: (value: T[keyof T]) => any) => T; + type LodashForInRight2x2 = (iteratee: (value: T[keyof T]) => any) => T | null | undefined; + interface LodashForOwn { + (iteratee: (value: T) => any): LodashForOwn1x1; + (iteratee: lodash.__, object: T): LodashForOwn1x2; + (iteratee: (value: T[keyof T]) => any, object: T): T; + (iteratee: lodash.__, object: T | null | undefined): LodashForOwn2x2; + (iteratee: (value: T[keyof T]) => any, object: T | null | undefined): T | null | undefined; + } + interface LodashForOwn1x1 { + (object: T1): T1; + (object: T1 | null | undefined): T1 | null | undefined; + } + type LodashForOwn1x2 = (iteratee: (value: T[keyof T]) => any) => T; + type LodashForOwn2x2 = (iteratee: (value: T[keyof T]) => any) => T | null | undefined; + interface LodashForOwnRight { + (iteratee: (value: T) => any): LodashForOwnRight1x1; + (iteratee: lodash.__, object: T): LodashForOwnRight1x2; + (iteratee: (value: T[keyof T]) => any, object: T): T; + (iteratee: lodash.__, object: T | null | undefined): LodashForOwnRight2x2; + (iteratee: (value: T[keyof T]) => any, object: T | null | undefined): T | null | undefined; + } + interface LodashForOwnRight1x1 { + (object: T1): T1; + (object: T1 | null | undefined): T1 | null | undefined; + } + type LodashForOwnRight1x2 = (iteratee: (value: T[keyof T]) => any) => T; + type LodashForOwnRight2x2 = (iteratee: (value: T[keyof T]) => any) => T | null | undefined; + interface LodashFromPairs { + (pairs: lodash.List<[lodash.PropertyName, T]> | null | undefined): lodash.Dictionary; + (pairs: lodash.List | null | undefined): lodash.Dictionary; + } + type LodashFunctions = (object: any) => string[]; + type LodashFunctionsIn = (object: any) => string[]; + interface LodashGet { + (path: TKey | [TKey]): LodashGet1x1; + (path: lodash.__, object: TObject): LodashGet1x2; + (path: TKey | [TKey], object: TObject): TObject[TKey]; + (path: lodash.__, object: TObject | null | undefined): LodashGet2x2; + (path: TKey | [TKey], object: TObject | null | undefined): TObject[TKey] | undefined; + (path: number): LodashGet3x1; + (path: lodash.__, object: lodash.NumericDictionary): LodashGet3x2; + (path: number, object: lodash.NumericDictionary): T; + (path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashGet4x2; + (path: number, object: lodash.NumericDictionary | null | undefined): T | undefined; + (path: lodash.PropertyPath): LodashGet5x1; + (path: lodash.__, object: null | undefined): LodashGet5x2; + (path: lodash.PropertyPath, object: null | undefined): undefined; + (path: lodash.__, object: any): LodashGet6x2; + (path: lodash.PropertyPath, object: any): any; + } + interface LodashGet1x1 { + (object: TObject): TObject[TKey]; + (object: TObject | null | undefined): TObject[TKey] | undefined; + } + type LodashGet1x2 = (path: TKey | [TKey]) => TObject[TKey]; + type LodashGet2x2 = (path: TKey | [TKey]) => TObject[TKey] | undefined; + interface LodashGet3x1 { + (object: lodash.NumericDictionary): T; + (object: lodash.NumericDictionary | null | undefined): T | undefined; + } + type LodashGet3x2 = (path: number) => T; + type LodashGet4x2 = (path: number) => T | undefined; + interface LodashGet5x1 { + (object: null | undefined): undefined; + (object: any): any; + } + type LodashGet5x2 = (path: lodash.PropertyPath) => undefined; + type LodashGet6x2 = (path: lodash.PropertyPath) => any; + interface LodashGetOr { + (defaultValue: TDefault): LodashGetOr1x1; + (defaultValue: lodash.__, path: TKey | [TKey]): LodashGetOr1x2; + (defaultValue: TDefault, path: TKey | [TKey]): LodashGetOr1x3; + (defaultValue: lodash.__, path: lodash.__, object: TObject | null | undefined): LodashGetOr1x4; + (defaultValue: TDefault, path: lodash.__, object: TObject | null | undefined): LodashGetOr1x5; + (defaultValue: lodash.__, path: TKey | [TKey], object: TObject | null | undefined): LodashGetOr1x6; + (defaultValue: TDefault, path: TKey | [TKey], object: TObject | null | undefined): Exclude | TDefault; + (defaultValue: lodash.__, path: number): LodashGetOr2x2; + (defaultValue: TDefault, path: number): LodashGetOr2x3; + (defaultValue: lodash.__, path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashGetOr2x4; + (defaultValue: TDefault, path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashGetOr2x5; + (defaultValue: lodash.__, path: number, object: lodash.NumericDictionary | null | undefined): LodashGetOr2x6; + (defaultValue: TDefault, path: number, object: lodash.NumericDictionary | null | undefined): T | TDefault; + (defaultValue: lodash.__, path: lodash.PropertyPath): LodashGetOr3x2; + (defaultValue: TDefault, path: lodash.PropertyPath): LodashGetOr3x3; + (defaultValue: lodash.__, path: lodash.__, object: null | undefined): LodashGetOr3x4; + (defaultValue: TDefault, path: lodash.__, object: null | undefined): LodashGetOr3x5; + (defaultValue: lodash.__, path: lodash.PropertyPath, object: null | undefined): LodashGetOr3x6; + (defaultValue: TDefault, path: lodash.PropertyPath, object: null | undefined): TDefault; + (defaultValue: any): LodashGetOr4x1; + (defaultValue: any, path: lodash.PropertyPath): LodashGetOr4x3; + (defaultValue: lodash.__, path: lodash.__, object: any): LodashGetOr4x4; + (defaultValue: any, path: lodash.__, object: any): LodashGetOr4x5; + (defaultValue: lodash.__, path: lodash.PropertyPath, object: any): LodashGetOr4x6; + (defaultValue: any, path: lodash.PropertyPath, object: any): any; + } + interface LodashGetOr1x1 { + (path: TKey | [TKey]): LodashGetOr1x3; + (path: lodash.__, object: TObject | null | undefined): LodashGetOr1x5; + (path: TKey | [TKey], object: TObject | null | undefined): Exclude | TDefault; + (path: number): LodashGetOr2x3; + (path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashGetOr2x5; + (path: number, object: lodash.NumericDictionary | null | undefined): T | TDefault; + (path: lodash.PropertyPath): LodashGetOr3x3; + (path: lodash.__, object: null | undefined): LodashGetOr3x5; + (path: lodash.PropertyPath, object: null | undefined): TDefault; + } + interface LodashGetOr1x2 { + (defaultValue: TDefault): LodashGetOr1x3; + (defaultValue: lodash.__, object: TObject | null | undefined): LodashGetOr1x6; + (defaultValue: TDefault, object: TObject | null | undefined): Exclude | TDefault; + } + type LodashGetOr1x3 = (object: TObject | null | undefined) => Exclude | TDefault; + interface LodashGetOr1x4 { + (defaultValue: TDefault): LodashGetOr1x5; + (defaultValue: lodash.__, path: TKey | [TKey]): LodashGetOr1x6; + (defaultValue: TDefault, path: TKey | [TKey]): Exclude | TDefault; + } + type LodashGetOr1x5 = (path: TKey | [TKey]) => Exclude | TDefault; + type LodashGetOr1x6 = (defaultValue: TDefault) => Exclude | TDefault; + interface LodashGetOr2x2 { + (defaultValue: TDefault): LodashGetOr2x3; + (defaultValue: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashGetOr2x6; + (defaultValue: TDefault, object: lodash.NumericDictionary | null | undefined): T | TDefault; + } + type LodashGetOr2x3 = (object: lodash.NumericDictionary | null | undefined) => T | TDefault; + interface LodashGetOr2x4 { + (defaultValue: TDefault): LodashGetOr2x5; + (defaultValue: lodash.__, path: number): LodashGetOr2x6; + (defaultValue: TDefault, path: number): T | TDefault; + } + type LodashGetOr2x5 = (path: number) => T | TDefault; + type LodashGetOr2x6 = (defaultValue: TDefault) => T | TDefault; + interface LodashGetOr3x2 { + (defaultValue: TDefault): LodashGetOr3x3; + (defaultValue: lodash.__, object: null | undefined): LodashGetOr3x6; + (defaultValue: TDefault, object: null | undefined): TDefault; + (defaultValue: any): LodashGetOr4x3; + (defaultValue: lodash.__, object: any): LodashGetOr4x6; + (defaultValue: any, object: any): any; + } + type LodashGetOr3x3 = (object: null | undefined) => TDefault; + interface LodashGetOr3x4 { + (defaultValue: TDefault): LodashGetOr3x5; + (defaultValue: lodash.__, path: lodash.PropertyPath): LodashGetOr3x6; + (defaultValue: TDefault, path: lodash.PropertyPath): TDefault; + } + type LodashGetOr3x5 = (path: lodash.PropertyPath) => TDefault; + type LodashGetOr3x6 = (defaultValue: TDefault) => TDefault; + interface LodashGetOr4x1 { + (path: lodash.PropertyPath): LodashGetOr4x3; + (path: lodash.__, object: any): LodashGetOr4x5; + (path: lodash.PropertyPath, object: any): any; + } + type LodashGetOr4x3 = (object: any) => any; + interface LodashGetOr4x4 { + (defaultValue: any): LodashGetOr4x5; + (defaultValue: lodash.__, path: lodash.PropertyPath): LodashGetOr4x6; + (defaultValue: any, path: lodash.PropertyPath): any; + } + type LodashGetOr4x5 = (path: lodash.PropertyPath) => any; + type LodashGetOr4x6 = (defaultValue: any) => any; + interface LodashGroupBy { + (iteratee: lodash.ValueIteratee): LodashGroupBy1x1; + (iteratee: lodash.__, collection: lodash.List | null | undefined): LodashGroupBy1x2; + (iteratee: lodash.ValueIteratee, collection: lodash.List | null | undefined): lodash.Dictionary; + (iteratee: lodash.__, collection: T | null | undefined): LodashGroupBy2x2; + (iteratee: lodash.ValueIteratee, collection: T | null | undefined): lodash.Dictionary>; + } + type LodashGroupBy1x1 = (collection: lodash.List | object | null | undefined) => lodash.Dictionary; + type LodashGroupBy1x2 = (iteratee: lodash.ValueIteratee) => lodash.Dictionary; + type LodashGroupBy2x2 = (iteratee: lodash.ValueIteratee) => lodash.Dictionary>; + interface LodashGt { + (value: any): LodashGt1x1; + (value: lodash.__, other: any): LodashGt1x2; + (value: any, other: any): boolean; + } + type LodashGt1x1 = (other: any) => boolean; + type LodashGt1x2 = (value: any) => boolean; + interface LodashGte { + (value: any): LodashGte1x1; + (value: lodash.__, other: any): LodashGte1x2; + (value: any, other: any): boolean; + } + type LodashGte1x1 = (other: any) => boolean; + type LodashGte1x2 = (value: any) => boolean; + interface LodashHas { + (path: lodash.PropertyPath): LodashHas1x1; + (path: lodash.__, object: T): LodashHas1x2; + (path: lodash.PropertyPath, object: T): boolean; + } + type LodashHas1x1 = (object: T) => boolean; + type LodashHas1x2 = (path: lodash.PropertyPath) => boolean; + interface LodashHasIn { + (path: lodash.PropertyPath): LodashHasIn1x1; + (path: lodash.__, object: T): LodashHasIn1x2; + (path: lodash.PropertyPath, object: T): boolean; + } + type LodashHasIn1x1 = (object: T) => boolean; + type LodashHasIn1x2 = (path: lodash.PropertyPath) => boolean; + interface LodashIdentity { + (value: T): T; + (): undefined; + } + interface LodashIncludes { + (target: T): LodashIncludes1x1; + (target: lodash.__, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): LodashIncludes1x2; + (target: T, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): boolean; + } + type LodashIncludes1x1 = (collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined) => boolean; + type LodashIncludes1x2 = (target: T) => boolean; + interface LodashIncludesFrom { + (target: T): LodashIncludesFrom1x1; + (target: lodash.__, fromIndex: number): LodashIncludesFrom1x2; + (target: T, fromIndex: number): LodashIncludesFrom1x3; + (target: lodash.__, fromIndex: lodash.__, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): LodashIncludesFrom1x4; + (target: T, fromIndex: lodash.__, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): LodashIncludesFrom1x5; + (target: lodash.__, fromIndex: number, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): LodashIncludesFrom1x6; + (target: T, fromIndex: number, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): boolean; + } + interface LodashIncludesFrom1x1 { + (fromIndex: number): LodashIncludesFrom1x3; + (fromIndex: lodash.__, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): LodashIncludesFrom1x5; + (fromIndex: number, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): boolean; + } + interface LodashIncludesFrom1x2 { + (target: T): LodashIncludesFrom1x3; + (target: lodash.__, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): LodashIncludesFrom1x6; + (target: T, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): boolean; + } + type LodashIncludesFrom1x3 = (collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined) => boolean; + interface LodashIncludesFrom1x4 { + (target: T): LodashIncludesFrom1x5; + (target: lodash.__, fromIndex: number): LodashIncludesFrom1x6; + (target: T, fromIndex: number): boolean; + } + type LodashIncludesFrom1x5 = (fromIndex: number) => boolean; + type LodashIncludesFrom1x6 = (target: T) => boolean; + interface LodashKeyBy { + (iteratee: lodash.ValueIterateeCustom): LodashKeyBy1x1; + (iteratee: lodash.__, collection: lodash.List | null | undefined): LodashKeyBy1x2; + (iteratee: lodash.ValueIterateeCustom, collection: lodash.List | null | undefined): lodash.Dictionary; + (iteratee: lodash.__, collection: T | null | undefined): LodashKeyBy2x2; + (iteratee: lodash.ValueIterateeCustom, collection: T | null | undefined): lodash.Dictionary; + } + type LodashKeyBy1x1 = (collection: lodash.List | object | null | undefined) => lodash.Dictionary; + type LodashKeyBy1x2 = (iteratee: lodash.ValueIterateeCustom) => lodash.Dictionary; + type LodashKeyBy2x2 = (iteratee: lodash.ValueIterateeCustom) => lodash.Dictionary; + interface LodashIndexOf { + (value: T): LodashIndexOf1x1; + (value: lodash.__, array: lodash.List | null | undefined): LodashIndexOf1x2; + (value: T, array: lodash.List | null | undefined): number; + } + type LodashIndexOf1x1 = (array: lodash.List | null | undefined) => number; + type LodashIndexOf1x2 = (value: T) => number; + interface LodashIndexOfFrom { + (value: T): LodashIndexOfFrom1x1; + (value: lodash.__, fromIndex: number): LodashIndexOfFrom1x2; + (value: T, fromIndex: number): LodashIndexOfFrom1x3; + (value: lodash.__, fromIndex: lodash.__, array: lodash.List | null | undefined): LodashIndexOfFrom1x4; + (value: T, fromIndex: lodash.__, array: lodash.List | null | undefined): LodashIndexOfFrom1x5; + (value: lodash.__, fromIndex: number, array: lodash.List | null | undefined): LodashIndexOfFrom1x6; + (value: T, fromIndex: number, array: lodash.List | null | undefined): number; + } + interface LodashIndexOfFrom1x1 { + (fromIndex: number): LodashIndexOfFrom1x3; + (fromIndex: lodash.__, array: lodash.List | null | undefined): LodashIndexOfFrom1x5; + (fromIndex: number, array: lodash.List | null | undefined): number; + } + interface LodashIndexOfFrom1x2 { + (value: T): LodashIndexOfFrom1x3; + (value: lodash.__, array: lodash.List | null | undefined): LodashIndexOfFrom1x6; + (value: T, array: lodash.List | null | undefined): number; + } + type LodashIndexOfFrom1x3 = (array: lodash.List | null | undefined) => number; + interface LodashIndexOfFrom1x4 { + (value: T): LodashIndexOfFrom1x5; + (value: lodash.__, fromIndex: number): LodashIndexOfFrom1x6; + (value: T, fromIndex: number): number; + } + type LodashIndexOfFrom1x5 = (fromIndex: number) => number; + type LodashIndexOfFrom1x6 = (value: T) => number; + type LodashInitial = (array: lodash.List | null | undefined) => T[]; + interface LodashInRange { + (start: number): LodashInRange1x1; + (start: lodash.__, end: number): LodashInRange1x2; + (start: number, end: number): LodashInRange1x3; + (start: lodash.__, end: lodash.__, n: number): LodashInRange1x4; + (start: number, end: lodash.__, n: number): LodashInRange1x5; + (start: lodash.__, end: number, n: number): LodashInRange1x6; + (start: number, end: number, n: number): boolean; + } + interface LodashInRange1x1 { + (end: number): LodashInRange1x3; + (end: lodash.__, n: number): LodashInRange1x5; + (end: number, n: number): boolean; + } + interface LodashInRange1x2 { + (start: number): LodashInRange1x3; + (start: lodash.__, n: number): LodashInRange1x6; + (start: number, n: number): boolean; + } + type LodashInRange1x3 = (n: number) => boolean; + interface LodashInRange1x4 { + (start: number): LodashInRange1x5; + (start: lodash.__, end: number): LodashInRange1x6; + (start: number, end: number): boolean; + } + type LodashInRange1x5 = (end: number) => boolean; + type LodashInRange1x6 = (start: number) => boolean; + interface LodashIntersection { + (arrays2: lodash.List): LodashIntersection1x1; + (arrays2: lodash.__, arrays: lodash.List): LodashIntersection1x2; + (arrays2: lodash.List, arrays: lodash.List): T[]; + } + type LodashIntersection1x1 = (arrays: lodash.List) => T[]; + type LodashIntersection1x2 = (arrays2: lodash.List) => T[]; + interface LodashIntersectionBy { + (iteratee: lodash.ValueIteratee): LodashIntersectionBy1x1; + (iteratee: lodash.__, array: lodash.List | null): LodashIntersectionBy1x2; + (iteratee: lodash.ValueIteratee, array: lodash.List | null): LodashIntersectionBy1x3; + (iteratee: lodash.__, array: lodash.__, values: lodash.List): LodashIntersectionBy1x4; + (iteratee: lodash.ValueIteratee, array: lodash.__, values: lodash.List): LodashIntersectionBy1x5; + (iteratee: lodash.__, array: lodash.List | null, values: lodash.List): LodashIntersectionBy1x6; + (iteratee: lodash.ValueIteratee, array: lodash.List | null, values: lodash.List): T1[]; + } + interface LodashIntersectionBy1x1 { + (array: lodash.List | null): LodashIntersectionBy1x3; + (array: lodash.__, values: lodash.List): LodashIntersectionBy1x5; + (array: lodash.List | null, values: lodash.List): T1[]; + } + interface LodashIntersectionBy1x2 { + (iteratee: lodash.ValueIteratee): LodashIntersectionBy1x3; + (iteratee: lodash.__, values: lodash.List): LodashIntersectionBy1x6; + (iteratee: lodash.ValueIteratee, values: lodash.List): T1[]; + } + type LodashIntersectionBy1x3 = (values: lodash.List) => T1[]; + interface LodashIntersectionBy1x4 { + (iteratee: lodash.ValueIteratee): LodashIntersectionBy1x5; + (iteratee: lodash.__, array: lodash.List | null): LodashIntersectionBy1x6; + (iteratee: lodash.ValueIteratee, array: lodash.List | null): T1[]; + } + type LodashIntersectionBy1x5 = (array: lodash.List | null) => T1[]; + type LodashIntersectionBy1x6 = (iteratee: lodash.ValueIteratee) => T1[]; + interface LodashIntersectionWith { + (comparator: lodash.Comparator2): LodashIntersectionWith1x1; + (comparator: lodash.__, array: lodash.List | null | undefined): LodashIntersectionWith1x2; + (comparator: lodash.Comparator2, array: lodash.List | null | undefined): LodashIntersectionWith1x3; + (comparator: lodash.__, array: lodash.__, values: lodash.List): LodashIntersectionWith1x4; + (comparator: lodash.Comparator2, array: lodash.__, values: lodash.List): LodashIntersectionWith1x5; + (comparator: lodash.__, array: lodash.List | null | undefined, values: lodash.List): LodashIntersectionWith1x6; + (comparator: lodash.Comparator2, array: lodash.List | null | undefined, values: lodash.List): T1[]; + } + interface LodashIntersectionWith1x1 { + (array: lodash.List | null | undefined): LodashIntersectionWith1x3; + (array: lodash.__, values: lodash.List): LodashIntersectionWith1x5; + (array: lodash.List | null | undefined, values: lodash.List): T1[]; + } + interface LodashIntersectionWith1x2 { + (comparator: lodash.Comparator2): LodashIntersectionWith1x3; + (comparator: lodash.__, values: lodash.List): LodashIntersectionWith1x6; + (comparator: lodash.Comparator2, values: lodash.List): T1[]; + } + type LodashIntersectionWith1x3 = (values: lodash.List) => T1[]; + interface LodashIntersectionWith1x4 { + (comparator: lodash.Comparator2): LodashIntersectionWith1x5; + (comparator: lodash.__, array: lodash.List | null | undefined): LodashIntersectionWith1x6; + (comparator: lodash.Comparator2, array: lodash.List | null | undefined): T1[]; + } + type LodashIntersectionWith1x5 = (array: lodash.List | null | undefined) => T1[]; + type LodashIntersectionWith1x6 = (comparator: lodash.Comparator2) => T1[]; + type LodashInvert = (object: object) => lodash.Dictionary; + interface LodashInvertBy { + (interatee: lodash.ValueIteratee): LodashInvertBy1x1; + (interatee: lodash.__, object: lodash.Dictionary | lodash.NumericDictionary | null | undefined): LodashInvertBy1x2; + (interatee: lodash.ValueIteratee, object: lodash.Dictionary | lodash.NumericDictionary | null | undefined): lodash.Dictionary; + (interatee: lodash.__, object: T | null | undefined): LodashInvertBy2x2; + (interatee: lodash.ValueIteratee, object: T | null | undefined): lodash.Dictionary; + } + type LodashInvertBy1x1 = (object: lodash.Dictionary | lodash.NumericDictionary | object | null | undefined) => lodash.Dictionary; + type LodashInvertBy1x2 = (interatee: lodash.ValueIteratee) => lodash.Dictionary; + type LodashInvertBy2x2 = (interatee: lodash.ValueIteratee) => lodash.Dictionary; + interface LodashInvoke { + (path: lodash.PropertyPath): LodashInvoke1x1; + (path: lodash.__, object: any): LodashInvoke1x2; + (path: lodash.PropertyPath, object: any): any; + } + type LodashInvoke1x1 = (object: any) => any; + type LodashInvoke1x2 = (path: lodash.PropertyPath) => any; + interface LodashInvokeArgs { + (path: lodash.PropertyPath): LodashInvokeArgs1x1; + (path: lodash.__, args: ReadonlyArray): LodashInvokeArgs1x2; + (path: lodash.PropertyPath, args: ReadonlyArray): LodashInvokeArgs1x3; + (path: lodash.__, args: lodash.__, object: any): LodashInvokeArgs1x4; + (path: lodash.PropertyPath, args: lodash.__, object: any): LodashInvokeArgs1x5; + (path: lodash.__, args: ReadonlyArray, object: any): LodashInvokeArgs1x6; + (path: lodash.PropertyPath, args: ReadonlyArray, object: any): any; + } + interface LodashInvokeArgs1x1 { + (args: ReadonlyArray): LodashInvokeArgs1x3; + (args: lodash.__, object: any): LodashInvokeArgs1x5; + (args: ReadonlyArray, object: any): any; + } + interface LodashInvokeArgs1x2 { + (path: lodash.PropertyPath): LodashInvokeArgs1x3; + (path: lodash.__, object: any): LodashInvokeArgs1x6; + (path: lodash.PropertyPath, object: any): any; + } + type LodashInvokeArgs1x3 = (object: any) => any; + interface LodashInvokeArgs1x4 { + (path: lodash.PropertyPath): LodashInvokeArgs1x5; + (path: lodash.__, args: ReadonlyArray): LodashInvokeArgs1x6; + (path: lodash.PropertyPath, args: ReadonlyArray): any; + } + type LodashInvokeArgs1x5 = (args: ReadonlyArray) => any; + type LodashInvokeArgs1x6 = (path: lodash.PropertyPath) => any; + interface LodashInvokeArgsMap { + (methodName: string): LodashInvokeArgsMap1x1; + (methodNameOrMethod: lodash.__, args: ReadonlyArray): LodashInvokeArgsMap1x2; + (methodName: string, args: ReadonlyArray): LodashInvokeArgsMap1x3; + (methodNameOrMethod: lodash.__, args: lodash.__, collection: object | null | undefined): LodashInvokeArgsMap1x4; + (methodName: string, args: lodash.__, collection: object | null | undefined): LodashInvokeArgsMap1x5; + (methodNameOrMethod: lodash.__, args: ReadonlyArray, collection: object | null | undefined): LodashInvokeArgsMap1x6; + (methodName: string, args: ReadonlyArray, collection: object | null | undefined): any[]; + (method: (...args: any[]) => TResult): LodashInvokeArgsMap2x1; + (method: (...args: any[]) => TResult, args: ReadonlyArray): LodashInvokeArgsMap2x3; + (method: (...args: any[]) => TResult, args: lodash.__, collection: object | null | undefined): LodashInvokeArgsMap2x5; + (method: (...args: any[]) => TResult, args: ReadonlyArray, collection: object | null | undefined): TResult[]; + } + interface LodashInvokeArgsMap1x1 { + (args: ReadonlyArray): LodashInvokeArgsMap1x3; + (args: lodash.__, collection: object | null | undefined): LodashInvokeArgsMap1x5; + (args: ReadonlyArray, collection: object | null | undefined): any[]; + } + interface LodashInvokeArgsMap1x2 { + (methodName: string): LodashInvokeArgsMap1x3; + (methodNameOrMethod: lodash.__, collection: object | null | undefined): LodashInvokeArgsMap1x6; + (methodName: string, collection: object | null | undefined): any[]; + (method: (...args: any[]) => TResult): LodashInvokeArgsMap2x3; + (method: (...args: any[]) => TResult, collection: object | null | undefined): TResult[]; + } + type LodashInvokeArgsMap1x3 = (collection: object | null | undefined) => any[]; + interface LodashInvokeArgsMap1x4 { + (methodName: string): LodashInvokeArgsMap1x5; + (methodNameOrMethod: lodash.__, args: ReadonlyArray): LodashInvokeArgsMap1x6; + (methodName: string, args: ReadonlyArray): any[]; + (method: (...args: any[]) => TResult): LodashInvokeArgsMap2x5; + (method: (...args: any[]) => TResult, args: ReadonlyArray): TResult[]; + } + type LodashInvokeArgsMap1x5 = (args: ReadonlyArray) => any[]; + interface LodashInvokeArgsMap1x6 { + (methodName: string): any[]; + (method: (...args: any[]) => TResult): TResult[]; + } + interface LodashInvokeArgsMap2x1 { + (args: ReadonlyArray): LodashInvokeArgsMap2x3; + (args: lodash.__, collection: object | null | undefined): LodashInvokeArgsMap2x5; + (args: ReadonlyArray, collection: object | null | undefined): TResult[]; + } + type LodashInvokeArgsMap2x3 = (collection: object | null | undefined) => TResult[]; + type LodashInvokeArgsMap2x5 = (args: ReadonlyArray) => TResult[]; + interface LodashInvokeMap { + (methodName: string): LodashInvokeMap1x1; + (methodNameOrMethod: lodash.__, collection: object | null | undefined): LodashInvokeMap1x2; + (methodName: string, collection: object | null | undefined): any[]; + (method: (...args: any[]) => TResult): LodashInvokeMap2x1; + (method: (...args: any[]) => TResult, collection: object | null | undefined): TResult[]; + } + type LodashInvokeMap1x1 = (collection: object | null | undefined) => any[]; + interface LodashInvokeMap1x2 { + (methodName: string): any[]; + (method: (...args: any[]) => TResult): TResult[]; + } + type LodashInvokeMap2x1 = (collection: object | null | undefined) => TResult[]; + type LodashIsArguments = (value: any) => value is IArguments; + type LodashIsArray = (value: any) => value is any[]; + type LodashIsArrayBuffer = (value: any) => value is ArrayBuffer; + interface LodashIsArrayLike { + (t: T): boolean; + (value: ((...args: any[]) => any) | null | undefined): value is never; + (value: any): value is { length: number }; + } + interface LodashIsArrayLikeObject { + (value: T): boolean; + // tslint:disable-next-line:ban-types (type guard doesn't seem to work correctly without the lodash.Function type) + (value: ((...args: any[]) => any) | lodash.FunctionBase | string | boolean | number | null | undefined): value is never; + (value: any): value is object & { length: number }; + } + type LodashIsBoolean = (value: any) => value is boolean; + type LodashIsBuffer = (value: any) => boolean; + type LodashIsDate = (value: any) => value is Date; + type LodashIsElement = (value: any) => boolean; + type LodashIsEmpty = (value: any) => boolean; + interface LodashIsEqualWith { + (customizer: lodash.IsEqualCustomizer): LodashIsEqualWith1x1; + (customizer: lodash.__, value: any): LodashIsEqualWith1x2; + (customizer: lodash.IsEqualCustomizer, value: any): LodashIsEqualWith1x3; + (customizer: lodash.__, value: lodash.__, other: any): LodashIsEqualWith1x4; + (customizer: lodash.IsEqualCustomizer, value: lodash.__, other: any): LodashIsEqualWith1x5; + (customizer: lodash.__, value: any, other: any): LodashIsEqualWith1x6; + (customizer: lodash.IsEqualCustomizer, value: any, other: any): boolean; + } + interface LodashIsEqualWith1x1 { + (value: any): LodashIsEqualWith1x3; + (value: lodash.__, other: any): LodashIsEqualWith1x5; + (value: any, other: any): boolean; + } + interface LodashIsEqualWith1x2 { + (customizer: lodash.IsEqualCustomizer): LodashIsEqualWith1x3; + (customizer: lodash.__, other: any): LodashIsEqualWith1x6; + (customizer: lodash.IsEqualCustomizer, other: any): boolean; + } + type LodashIsEqualWith1x3 = (other: any) => boolean; + interface LodashIsEqualWith1x4 { + (customizer: lodash.IsEqualCustomizer): LodashIsEqualWith1x5; + (customizer: lodash.__, value: any): LodashIsEqualWith1x6; + (customizer: lodash.IsEqualCustomizer, value: any): boolean; + } + type LodashIsEqualWith1x5 = (value: any) => boolean; + type LodashIsEqualWith1x6 = (customizer: lodash.IsEqualCustomizer) => boolean; + type LodashIsError = (value: any) => value is Error; + type LodashIsFinite = (value: any) => boolean; + type LodashIsFunction = (value: any) => value is (...args: any[]) => any; + type LodashIsInteger = (value: any) => boolean; + type LodashIsLength = (value: any) => boolean; + type LodashIsMap = (value: any) => value is Map; + interface LodashIsMatch { + (source: object): LodashIsMatch1x1; + (source: lodash.__, object: object): LodashIsMatch1x2; + (source: object, object: object): boolean; + } + type LodashIsMatch1x1 = (object: object) => boolean; + type LodashIsMatch1x2 = (source: object) => boolean; + interface LodashIsMatchWith { + (customizer: lodash.isMatchWithCustomizer): LodashIsMatchWith1x1; + (customizer: lodash.__, source: object): LodashIsMatchWith1x2; + (customizer: lodash.isMatchWithCustomizer, source: object): LodashIsMatchWith1x3; + (customizer: lodash.__, source: lodash.__, object: object): LodashIsMatchWith1x4; + (customizer: lodash.isMatchWithCustomizer, source: lodash.__, object: object): LodashIsMatchWith1x5; + (customizer: lodash.__, source: object, object: object): LodashIsMatchWith1x6; + (customizer: lodash.isMatchWithCustomizer, source: object, object: object): boolean; + } + interface LodashIsMatchWith1x1 { + (source: object): LodashIsMatchWith1x3; + (source: lodash.__, object: object): LodashIsMatchWith1x5; + (source: object, object: object): boolean; + } + interface LodashIsMatchWith1x2 { + (customizer: lodash.isMatchWithCustomizer): LodashIsMatchWith1x3; + (customizer: lodash.__, object: object): LodashIsMatchWith1x6; + (customizer: lodash.isMatchWithCustomizer, object: object): boolean; + } + type LodashIsMatchWith1x3 = (object: object) => boolean; + interface LodashIsMatchWith1x4 { + (customizer: lodash.isMatchWithCustomizer): LodashIsMatchWith1x5; + (customizer: lodash.__, source: object): LodashIsMatchWith1x6; + (customizer: lodash.isMatchWithCustomizer, source: object): boolean; + } + type LodashIsMatchWith1x5 = (source: object) => boolean; + type LodashIsMatchWith1x6 = (customizer: lodash.isMatchWithCustomizer) => boolean; + type LodashIsNaN = (value: any) => boolean; + type LodashIsNative = (value: any) => value is (...args: any[]) => any; + type LodashIsNil = (value: any) => value is null | undefined; + type LodashIsNull = (value: any) => value is null; + type LodashIsNumber = (value: any) => value is number; + type LodashIsObject = (value: any) => value is object; + type LodashIsObjectLike = (value: any) => boolean; + type LodashIsPlainObject = (value: any) => boolean; + type LodashIsRegExp = (value: any) => value is RegExp; + type LodashIsSafeInteger = (value: any) => boolean; + type LodashIsSet = (value: any) => value is Set; + type LodashIsString = (value: any) => value is string; + type LodashIsSymbol = (value: any) => boolean; + type LodashIsTypedArray = (value: any) => boolean; + type LodashIsUndefined = (value: any) => value is undefined; + type LodashIsWeakMap = (value: any) => value is WeakMap; + type LodashIsWeakSet = (value: any) => value is WeakSet; + interface LodashIteratee { + any>(func: TFunction): TFunction; + (func: string | object): (...args: any[]) => any; + } + interface LodashJoin { + (separator: string): LodashJoin1x1; + (separator: lodash.__, array: lodash.List | null | undefined): LodashJoin1x2; + (separator: string, array: lodash.List | null | undefined): string; + } + type LodashJoin1x1 = (array: lodash.List | null | undefined) => string; + type LodashJoin1x2 = (separator: string) => string; + type LodashOver = (iteratees: lodash.Many<(...args: any[]) => TResult>) => (...args: any[]) => TResult[]; + type LodashKebabCase = (string: string) => string; + type LodashKeys = (object: any) => string[]; + type LodashKeysIn = (object: any) => string[]; + type LodashLast = (array: lodash.List | null | undefined) => T | undefined; + interface LodashLastIndexOf { + (value: T): LodashLastIndexOf1x1; + (value: lodash.__, array: lodash.List | null | undefined): LodashLastIndexOf1x2; + (value: T, array: lodash.List | null | undefined): number; + } + type LodashLastIndexOf1x1 = (array: lodash.List | null | undefined) => number; + type LodashLastIndexOf1x2 = (value: T) => number; + interface LodashLastIndexOfFrom { + (value: T): LodashLastIndexOfFrom1x1; + (value: lodash.__, fromIndex: true|number): LodashLastIndexOfFrom1x2; + (value: T, fromIndex: true|number): LodashLastIndexOfFrom1x3; + (value: lodash.__, fromIndex: lodash.__, array: lodash.List | null | undefined): LodashLastIndexOfFrom1x4; + (value: T, fromIndex: lodash.__, array: lodash.List | null | undefined): LodashLastIndexOfFrom1x5; + (value: lodash.__, fromIndex: true|number, array: lodash.List | null | undefined): LodashLastIndexOfFrom1x6; + (value: T, fromIndex: true|number, array: lodash.List | null | undefined): number; + } + interface LodashLastIndexOfFrom1x1 { + (fromIndex: true|number): LodashLastIndexOfFrom1x3; + (fromIndex: lodash.__, array: lodash.List | null | undefined): LodashLastIndexOfFrom1x5; + (fromIndex: true|number, array: lodash.List | null | undefined): number; + } + interface LodashLastIndexOfFrom1x2 { + (value: T): LodashLastIndexOfFrom1x3; + (value: lodash.__, array: lodash.List | null | undefined): LodashLastIndexOfFrom1x6; + (value: T, array: lodash.List | null | undefined): number; + } + type LodashLastIndexOfFrom1x3 = (array: lodash.List | null | undefined) => number; + interface LodashLastIndexOfFrom1x4 { + (value: T): LodashLastIndexOfFrom1x5; + (value: lodash.__, fromIndex: true|number): LodashLastIndexOfFrom1x6; + (value: T, fromIndex: true|number): number; + } + type LodashLastIndexOfFrom1x5 = (fromIndex: true|number) => number; + type LodashLastIndexOfFrom1x6 = (value: T) => number; + type LodashLowerCase = (string: string) => string; + type LodashLowerFirst = (string: string) => string; + interface LodashLt { + (value: any): LodashLt1x1; + (value: lodash.__, other: any): LodashLt1x2; + (value: any, other: any): boolean; + } + type LodashLt1x1 = (other: any) => boolean; + type LodashLt1x2 = (value: any) => boolean; + interface LodashLte { + (value: any): LodashLte1x1; + (value: lodash.__, other: any): LodashLte1x2; + (value: any, other: any): boolean; + } + type LodashLte1x1 = (other: any) => boolean; + type LodashLte1x2 = (value: any) => boolean; + interface LodashMap { + (iteratee: (value: T) => TResult): LodashMap1x1; + (iteratee: lodash.__, collection: T[] | null | undefined): LodashMap1x2; + (iteratee: (value: T) => TResult, collection: T[] | lodash.List | null | undefined): TResult[]; + (iteratee: lodash.__, collection: lodash.List | null | undefined): LodashMap2x2; + (iteratee: (value: T[keyof T]) => TResult): LodashMap3x1; + (iteratee: lodash.__, collection: T | null | undefined): LodashMap3x2; + (iteratee: (value: T[keyof T]) => TResult, collection: T | null | undefined): TResult[]; + (iteratee: K): LodashMap4x1; + (iteratee: lodash.__, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): LodashMap4x2; + (iteratee: K, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): Array; + (iteratee: string): LodashMap5x1; + (iteratee: string, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): any[]; + (iteratee: object): LodashMap6x1; + (iteratee: object, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): boolean[]; + } + type LodashMap1x1 = (collection: T[] | lodash.List | null | undefined) => TResult[]; + type LodashMap1x2 = (iteratee: (value: T) => TResult) => TResult[]; + type LodashMap2x2 = (iteratee: (value: T) => TResult) => TResult[]; + type LodashMap3x1 = (collection: T | null | undefined) => TResult[]; + type LodashMap3x2 = (iteratee: (value: T[keyof T]) => TResult) => TResult[]; + type LodashMap4x1 = (collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined) => Array; + interface LodashMap4x2 { + (iteratee: K): Array; + (iteratee: string): any[]; + (iteratee: object): boolean[]; + } + type LodashMap5x1 = (collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined) => any[]; + type LodashMap6x1 = (collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined) => boolean[]; + interface LodashMapKeys { + (iteratee: lodash.ValueIteratee): LodashMapKeys1x1; + (iteratee: lodash.__, object: lodash.List | null | undefined): LodashMapKeys1x2; + (iteratee: lodash.ValueIteratee, object: lodash.List | null | undefined): lodash.Dictionary; + (iteratee: lodash.ValueIteratee): LodashMapKeys2x1; + (iteratee: lodash.__, object: T | null | undefined): LodashMapKeys2x2; + (iteratee: lodash.ValueIteratee, object: T | null | undefined): lodash.Dictionary; + } + type LodashMapKeys1x1 = (object: lodash.List | null | undefined) => lodash.Dictionary; + type LodashMapKeys1x2 = (iteratee: lodash.ValueIteratee) => lodash.Dictionary; + type LodashMapKeys2x1 = (object: T | null | undefined) => lodash.Dictionary; + type LodashMapKeys2x2 = (iteratee: lodash.ValueIteratee) => lodash.Dictionary; + interface LodashMapValues { + (callback: (value: T) => TResult): LodashMapValues1x1; + (callbackOrIterateeOrIterateeOrIteratee: lodash.__, obj: lodash.Dictionary | lodash.NumericDictionary | null | undefined): LodashMapValues1x2; + (callback: (value: T) => TResult, obj: lodash.Dictionary | lodash.NumericDictionary | null | undefined): lodash.Dictionary; + (callback: (value: T[keyof T]) => TResult): LodashMapValues2x1; + (callbackOrIterateeOrIteratee: lodash.__, obj: T | null | undefined): LodashMapValues2x2; + (callback: (value: T[keyof T]) => TResult, obj: T | null | undefined): { [P in keyof T]: TResult }; + (iteratee: object): LodashMapValues3x1; + (iteratee: object, obj: lodash.Dictionary | lodash.NumericDictionary | null | undefined): lodash.Dictionary; + (iteratee: object, obj: T | null | undefined): { [P in keyof T]: boolean }; + (iteratee: TKey): LodashMapValues5x1; + (iteratee: TKey, obj: lodash.Dictionary | lodash.NumericDictionary | null | undefined): lodash.Dictionary; + (iteratee: string): LodashMapValues6x1; + (iteratee: string, obj: lodash.Dictionary | lodash.NumericDictionary | null | undefined): lodash.Dictionary; + (iteratee: string, obj: T | null | undefined): { [P in keyof T]: any }; + } + type LodashMapValues1x1 = (obj: lodash.Dictionary | lodash.NumericDictionary | null | undefined) => lodash.Dictionary; + interface LodashMapValues1x2 { + (callback: (value: T) => TResult): lodash.Dictionary; + (iteratee: object): lodash.Dictionary; + (iteratee: TKey): lodash.Dictionary; + (iteratee: string): lodash.Dictionary; + } + type LodashMapValues2x1 = (obj: T | null | undefined) => { [P in keyof T]: TResult }; + interface LodashMapValues2x2 { + (callback: (value: T[keyof T]) => TResult): { [P in keyof T]: TResult }; + (iteratee: object): { [P in keyof T]: boolean }; + (iteratee: string): { [P in keyof T]: any }; + } + interface LodashMapValues3x1 { + (obj: lodash.Dictionary | lodash.NumericDictionary | null | undefined): lodash.Dictionary; + (obj: T | null | undefined): { [P in keyof T]: boolean }; + } + type LodashMapValues5x1 = (obj: lodash.Dictionary | lodash.NumericDictionary | null | undefined) => lodash.Dictionary; + interface LodashMapValues6x1 { + (obj: lodash.Dictionary | lodash.NumericDictionary | null | undefined): lodash.Dictionary; + (obj: T | null | undefined): { [P in keyof T]: any }; + } + interface LodashMatchesProperty { + (path: lodash.PropertyPath): LodashMatchesProperty1x1; + (path: lodash.__, srcValue: T): LodashMatchesProperty1x2; + (path: lodash.PropertyPath, srcValue: T): (value: any) => boolean; + } + type LodashMatchesProperty1x1 = (srcValue: T) => (value: any) => boolean; + type LodashMatchesProperty1x2 = (path: lodash.PropertyPath) => (value: any) => boolean; + type LodashMax = (collection: lodash.List | null | undefined) => T | undefined; + interface LodashMaxBy { + (iteratee: lodash.ValueIteratee): LodashMaxBy1x1; + (iteratee: lodash.__, collection: lodash.List | null | undefined): LodashMaxBy1x2; + (iteratee: lodash.ValueIteratee, collection: lodash.List | null | undefined): T | undefined; + } + type LodashMaxBy1x1 = (collection: lodash.List | null | undefined) => T | undefined; + type LodashMaxBy1x2 = (iteratee: lodash.ValueIteratee) => T | undefined; + type LodashMean = (collection: lodash.List | null | undefined) => number; + interface LodashMeanBy { + (iteratee: lodash.ValueIteratee): LodashMeanBy1x1; + (iteratee: lodash.__, collection: lodash.List | null | undefined): LodashMeanBy1x2; + (iteratee: lodash.ValueIteratee, collection: lodash.List | null | undefined): number; + } + type LodashMeanBy1x1 = (collection: lodash.List | null | undefined) => number; + type LodashMeanBy1x2 = (iteratee: lodash.ValueIteratee) => number; + type LodashMemoize = any>(func: T) => T & lodash.MemoizedFunction; + interface LodashMerge { + (object: TObject): LodashMerge1x1; + (object: lodash.__, source: TSource): LodashMerge1x2; + (object: TObject, source: TSource): TObject & TSource; + } + type LodashMerge1x1 = (source: TSource) => TObject & TSource; + type LodashMerge1x2 = (object: TObject) => TObject & TSource; + interface LodashMergeAll { + (object: [TObject, TSource]): TObject & TSource; + (object: [TObject, TSource1, TSource2]): TObject & TSource1 & TSource2; + (object: [TObject, TSource1, TSource2, TSource3]): TObject & TSource1 & TSource2 & TSource3; + (object: [TObject, TSource1, TSource2, TSource3, TSource4]): TObject & TSource1 & TSource2 & TSource3 & TSource4; + (object: ReadonlyArray): any; + } + interface LodashMergeAllWith { + (customizer: lodash.MergeWithCustomizer): LodashMergeAllWith1x1; + (customizer: lodash.__, args: ReadonlyArray): LodashMergeAllWith1x2; + (customizer: lodash.MergeWithCustomizer, args: ReadonlyArray): any; + } + type LodashMergeAllWith1x1 = (args: ReadonlyArray) => any; + type LodashMergeAllWith1x2 = (customizer: lodash.MergeWithCustomizer) => any; + interface LodashMergeWith { + (customizer: lodash.MergeWithCustomizer): LodashMergeWith1x1; + (customizer: lodash.__, object: TObject): LodashMergeWith1x2; + (customizer: lodash.MergeWithCustomizer, object: TObject): LodashMergeWith1x3; + (customizer: lodash.__, object: lodash.__, source: TSource): LodashMergeWith1x4; + (customizer: lodash.MergeWithCustomizer, object: lodash.__, source: TSource): LodashMergeWith1x5; + (customizer: lodash.__, object: TObject, source: TSource): LodashMergeWith1x6; + (customizer: lodash.MergeWithCustomizer, object: TObject, source: TSource): TObject & TSource; + } + interface LodashMergeWith1x1 { + (object: TObject): LodashMergeWith1x3; + (object: lodash.__, source: TSource): LodashMergeWith1x5; + (object: TObject, source: TSource): TObject & TSource; + } + interface LodashMergeWith1x2 { + (customizer: lodash.MergeWithCustomizer): LodashMergeWith1x3; + (customizer: lodash.__, source: TSource): LodashMergeWith1x6; + (customizer: lodash.MergeWithCustomizer, source: TSource): TObject & TSource; + } + type LodashMergeWith1x3 = (source: TSource) => TObject & TSource; + interface LodashMergeWith1x4 { + (customizer: lodash.MergeWithCustomizer): LodashMergeWith1x5; + (customizer: lodash.__, object: TObject): LodashMergeWith1x6; + (customizer: lodash.MergeWithCustomizer, object: TObject): TObject & TSource; + } + type LodashMergeWith1x5 = (object: TObject) => TObject & TSource; + type LodashMergeWith1x6 = (customizer: lodash.MergeWithCustomizer) => TObject & TSource; + type LodashMethod = (path: lodash.PropertyPath) => (object: any) => any; + type LodashMethodOf = (object: object) => (path: lodash.PropertyPath) => any; + type LodashMin = (collection: lodash.List | null | undefined) => T | undefined; + interface LodashMinBy { + (iteratee: lodash.ValueIteratee): LodashMinBy1x1; + (iteratee: lodash.__, collection: lodash.List | null | undefined): LodashMinBy1x2; + (iteratee: lodash.ValueIteratee, collection: lodash.List | null | undefined): T | undefined; + } + type LodashMinBy1x1 = (collection: lodash.List | null | undefined) => T | undefined; + type LodashMinBy1x2 = (iteratee: lodash.ValueIteratee) => T | undefined; + interface LodashMultiply { + (multiplier: number): LodashMultiply1x1; + (multiplier: lodash.__, multiplicand: number): LodashMultiply1x2; + (multiplier: number, multiplicand: number): number; + } + type LodashMultiply1x1 = (multiplicand: number) => number; + type LodashMultiply1x2 = (multiplier: number) => number; + type LodashNoConflict = () => typeof _; + type LodashNoop = (...args: any[]) => void; + type LodashNow = () => number; + interface LodashNth { + (n: number): LodashNth1x1; + (n: lodash.__, array: lodash.List | null | undefined): LodashNth1x2; + (n: number, array: lodash.List | null | undefined): T | undefined; + } + type LodashNth1x1 = (array: lodash.List | null | undefined) => T | undefined; + type LodashNth1x2 = (n: number) => T | undefined; + type LodashNthArg = (n: number) => (...args: any[]) => any; + interface LodashOmit { + (paths: lodash.Many): LodashOmit1x1; + (paths: lodash.__, object: T | null | undefined): LodashOmit1x2; + (paths: lodash.Many, object: T | null | undefined): lodash.Omit; + (paths: lodash.Many): LodashOmit2x1; + (paths: lodash.Many, object: T | null | undefined): lodash.PartialObject; + } + type LodashOmit1x1 = (object: T | null | undefined) => lodash.Omit; + interface LodashOmit1x2 { + (paths: lodash.Many): lodash.Omit; + (paths: lodash.Many): lodash.PartialObject; + } + type LodashOmit2x1 = (object: T | null | undefined) => lodash.PartialObject; + interface LodashOmitBy { + (predicate: lodash.ValueKeyIteratee): LodashOmitBy1x1; + (predicate: lodash.__, object: lodash.Dictionary | null | undefined): LodashOmitBy1x2; + (predicate: lodash.ValueKeyIteratee, object: lodash.Dictionary | null | undefined): lodash.Dictionary; + (predicate: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashOmitBy2x2; + (predicate: lodash.ValueKeyIteratee, object: lodash.NumericDictionary | null | undefined): lodash.NumericDictionary; + (predicate: lodash.__, object: T | null | undefined): LodashOmitBy3x2; + (predicate: lodash.ValueKeyIteratee, object: T | null | undefined): lodash.PartialObject; + } + interface LodashOmitBy1x1 { + (object: lodash.Dictionary | null | undefined): lodash.Dictionary; + (object: lodash.NumericDictionary | null | undefined): lodash.NumericDictionary; + (object: T1 | null | undefined): lodash.PartialObject; + } + type LodashOmitBy1x2 = (predicate: lodash.ValueKeyIteratee) => lodash.Dictionary; + type LodashOmitBy2x2 = (predicate: lodash.ValueKeyIteratee) => lodash.NumericDictionary; + type LodashOmitBy3x2 = (predicate: lodash.ValueKeyIteratee) => lodash.PartialObject; + type LodashOnce = any>(func: T) => T; + interface LodashOrderBy { + (iteratees: lodash.Many<(value: T) => lodash.NotVoid>): LodashOrderBy1x1; + (iteratees: lodash.__, orders: lodash.Many): LodashOrderBy1x2; + (iteratees: lodash.Many<(value: T) => lodash.NotVoid>, orders: lodash.Many): LodashOrderBy1x3; + (iteratees: lodash.__, orders: lodash.__, collection: lodash.List | null | undefined): LodashOrderBy1x4; + (iteratees: lodash.Many<(value: T) => lodash.NotVoid>, orders: lodash.__, collection: lodash.List | null | undefined): LodashOrderBy1x5; + (iteratees: lodash.__, orders: lodash.Many, collection: lodash.List | null | undefined): LodashOrderBy1x6; + (iteratees: lodash.Many<(value: T) => lodash.NotVoid> | lodash.Many>, orders: lodash.Many, collection: lodash.List | null | undefined): T[]; + (iteratees: lodash.Many>): LodashOrderBy2x1; + (iteratees: lodash.Many>, orders: lodash.Many): LodashOrderBy2x3; + (iteratees: lodash.Many>, orders: lodash.__, collection: lodash.List | null | undefined): LodashOrderBy2x5; + (iteratees: lodash.__, orders: lodash.__, collection: T | null | undefined): LodashOrderBy3x4; + (iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid>, orders: lodash.__, collection: T | null | undefined): LodashOrderBy3x5; + (iteratees: lodash.__, orders: lodash.Many, collection: T | null | undefined): LodashOrderBy3x6; + (iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid> | lodash.Many>, orders: lodash.Many, collection: T | null | undefined): Array; + (iteratees: lodash.Many>, orders: lodash.__, collection: T | null | undefined): LodashOrderBy4x5; + } + interface LodashOrderBy1x1 { + (orders: lodash.Many): LodashOrderBy1x3; + (orders: lodash.__, collection: lodash.List | null | undefined): LodashOrderBy1x5; + (orders: lodash.Many, collection: lodash.List | object | null | undefined): T[]; + (orders: lodash.__, collection: T1 | null | undefined): LodashOrderBy3x5; + } + interface LodashOrderBy1x2 { + (iteratees: lodash.Many<(value: T) => lodash.NotVoid>): LodashOrderBy1x3; + (iteratees: lodash.__, collection: lodash.List | null | undefined): LodashOrderBy1x6; + (iteratees: lodash.Many<(value: T) => lodash.NotVoid> | lodash.Many>, collection: lodash.List | null | undefined): T[]; + (iteratees: lodash.Many>): LodashOrderBy2x3; + (iteratees: lodash.__, collection: T | null | undefined): LodashOrderBy3x6; + (iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid> | lodash.Many>, collection: T | null | undefined): Array; + } + interface LodashOrderBy1x3 { + (collection: lodash.List | null | undefined): T[]; + (collection: object | null | undefined): object[]; + } + interface LodashOrderBy1x4 { + (iteratees: lodash.Many<(value: T) => lodash.NotVoid>): LodashOrderBy1x5; + (iteratees: lodash.__, orders: lodash.Many): LodashOrderBy1x6; + (iteratees: lodash.Many<(value: T) => lodash.NotVoid> | lodash.Many>, orders: lodash.Many): T[]; + (iteratees: lodash.Many>): LodashOrderBy2x5; + } + type LodashOrderBy1x5 = (orders: lodash.Many) => T[]; + type LodashOrderBy1x6 = (iteratees: lodash.Many<(value: T) => lodash.NotVoid> | lodash.Many>) => T[]; + interface LodashOrderBy2x1 { + (orders: lodash.Many): LodashOrderBy2x3; + (orders: lodash.__, collection: lodash.List | null | undefined): LodashOrderBy2x5; + (orders: lodash.Many, collection: lodash.List | object | null | undefined): T[]; + (orders: lodash.__, collection: T1 | null | undefined): LodashOrderBy4x5; + } + interface LodashOrderBy2x3 { + (collection: lodash.List | null | undefined): T[]; + (collection: object | null | undefined): object[]; + } + type LodashOrderBy2x5 = (orders: lodash.Many) => T[]; + interface LodashOrderBy3x4 { + (iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid>): LodashOrderBy3x5; + (iteratees: lodash.__, orders: lodash.Many): LodashOrderBy3x6; + (iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid> | lodash.Many>, orders: lodash.Many): Array; + (iteratees: lodash.Many>): LodashOrderBy4x5; + } + type LodashOrderBy3x5 = (orders: lodash.Many) => Array; + type LodashOrderBy3x6 = (iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid> | lodash.Many>) => Array; + type LodashOrderBy4x5 = (orders: lodash.Many) => Array; + interface LodashOverArgs { + (func: (...args: any[]) => any): LodashOverArgs1x1; + (func: lodash.__, transforms: lodash.Many<(...args: any[]) => any>): LodashOverArgs1x2; + (func: (...args: any[]) => any, transforms: lodash.Many<(...args: any[]) => any>): (...args: any[]) => any; + } + type LodashOverArgs1x1 = (transforms: lodash.Many<(...args: any[]) => any>) => (...args: any[]) => any; + type LodashOverArgs1x2 = (func: (...args: any[]) => any) => (...args: any[]) => any; + interface LodashPad { + (length: number): LodashPad1x1; + (length: lodash.__, string: string): LodashPad1x2; + (length: number, string: string): string; + } + type LodashPad1x1 = (string: string) => string; + type LodashPad1x2 = (length: number) => string; + interface LodashPadChars { + (chars: string): LodashPadChars1x1; + (chars: lodash.__, length: number): LodashPadChars1x2; + (chars: string, length: number): LodashPadChars1x3; + (chars: lodash.__, length: lodash.__, string: string): LodashPadChars1x4; + (chars: string, length: lodash.__, string: string): LodashPadChars1x5; + (chars: lodash.__, length: number, string: string): LodashPadChars1x6; + (chars: string, length: number, string: string): string; + } + interface LodashPadChars1x1 { + (length: number): LodashPadChars1x3; + (length: lodash.__, string: string): LodashPadChars1x5; + (length: number, string: string): string; + } + interface LodashPadChars1x2 { + (chars: string): LodashPadChars1x3; + (chars: lodash.__, string: string): LodashPadChars1x6; + (chars: string, string: string): string; + } + type LodashPadChars1x3 = (string: string) => string; + interface LodashPadChars1x4 { + (chars: string): LodashPadChars1x5; + (chars: lodash.__, length: number): LodashPadChars1x6; + (chars: string, length: number): string; + } + type LodashPadChars1x5 = (length: number) => string; + type LodashPadChars1x6 = (chars: string) => string; + interface LodashPadCharsEnd { + (chars: string): LodashPadCharsEnd1x1; + (chars: lodash.__, length: number): LodashPadCharsEnd1x2; + (chars: string, length: number): LodashPadCharsEnd1x3; + (chars: lodash.__, length: lodash.__, string: string): LodashPadCharsEnd1x4; + (chars: string, length: lodash.__, string: string): LodashPadCharsEnd1x5; + (chars: lodash.__, length: number, string: string): LodashPadCharsEnd1x6; + (chars: string, length: number, string: string): string; + } + interface LodashPadCharsEnd1x1 { + (length: number): LodashPadCharsEnd1x3; + (length: lodash.__, string: string): LodashPadCharsEnd1x5; + (length: number, string: string): string; + } + interface LodashPadCharsEnd1x2 { + (chars: string): LodashPadCharsEnd1x3; + (chars: lodash.__, string: string): LodashPadCharsEnd1x6; + (chars: string, string: string): string; + } + type LodashPadCharsEnd1x3 = (string: string) => string; + interface LodashPadCharsEnd1x4 { + (chars: string): LodashPadCharsEnd1x5; + (chars: lodash.__, length: number): LodashPadCharsEnd1x6; + (chars: string, length: number): string; + } + type LodashPadCharsEnd1x5 = (length: number) => string; + type LodashPadCharsEnd1x6 = (chars: string) => string; + interface LodashPadCharsStart { + (chars: string): LodashPadCharsStart1x1; + (chars: lodash.__, length: number): LodashPadCharsStart1x2; + (chars: string, length: number): LodashPadCharsStart1x3; + (chars: lodash.__, length: lodash.__, string: string): LodashPadCharsStart1x4; + (chars: string, length: lodash.__, string: string): LodashPadCharsStart1x5; + (chars: lodash.__, length: number, string: string): LodashPadCharsStart1x6; + (chars: string, length: number, string: string): string; + } + interface LodashPadCharsStart1x1 { + (length: number): LodashPadCharsStart1x3; + (length: lodash.__, string: string): LodashPadCharsStart1x5; + (length: number, string: string): string; + } + interface LodashPadCharsStart1x2 { + (chars: string): LodashPadCharsStart1x3; + (chars: lodash.__, string: string): LodashPadCharsStart1x6; + (chars: string, string: string): string; + } + type LodashPadCharsStart1x3 = (string: string) => string; + interface LodashPadCharsStart1x4 { + (chars: string): LodashPadCharsStart1x5; + (chars: lodash.__, length: number): LodashPadCharsStart1x6; + (chars: string, length: number): string; + } + type LodashPadCharsStart1x5 = (length: number) => string; + type LodashPadCharsStart1x6 = (chars: string) => string; + interface LodashPadEnd { + (length: number): LodashPadEnd1x1; + (length: lodash.__, string: string): LodashPadEnd1x2; + (length: number, string: string): string; + } + type LodashPadEnd1x1 = (string: string) => string; + type LodashPadEnd1x2 = (length: number) => string; + interface LodashPadStart { + (length: number): LodashPadStart1x1; + (length: lodash.__, string: string): LodashPadStart1x2; + (length: number, string: string): string; + } + type LodashPadStart1x1 = (string: string) => string; + type LodashPadStart1x2 = (length: number) => string; + interface LodashParseInt { + (radix: number): LodashParseInt1x1; + (radix: lodash.__, string: string): LodashParseInt1x2; + (radix: number, string: string): number; + } + type LodashParseInt1x1 = (string: string) => number; + type LodashParseInt1x2 = (radix: number) => number; + interface LodashPartial { + (func: lodash.Function2): LodashPartial1x1; + (func: lodash.__, plc1: [lodash.__, T2]): LodashPartial1x2; + (func: lodash.Function2, plc1: [lodash.__, T2]): lodash.Function1; + (func: lodash.Function3): LodashPartial2x1; + (func: lodash.Function3, plc1: [lodash.__, T2]): lodash.Function2; + (func: lodash.__, plc1: [lodash.__, lodash.__, T3]): LodashPartial3x2; + (func: lodash.Function3, plc1: [lodash.__, lodash.__, T3]): lodash.Function2; + (func: lodash.__, arg1: [T1, lodash.__, T3]): LodashPartial4x2; + (func: lodash.Function3, arg1: [T1, lodash.__, T3]): lodash.Function1; + (func: lodash.__, plc1: [lodash.__, T2, T3]): LodashPartial5x2; + (func: lodash.Function3, plc1: [lodash.__, T2, T3]): lodash.Function1; + (func: lodash.Function4): LodashPartial6x1; + (func: lodash.Function4, plc1: [lodash.__, T2]): lodash.Function3; + (func: lodash.Function4, plc1: [lodash.__, lodash.__, T3]): lodash.Function3; + (func: lodash.Function4, arg1: [T1, lodash.__, T3]): lodash.Function2; + (func: lodash.Function4, plc1: [lodash.__, T2, T3]): lodash.Function2; + (func: lodash.__, arg1OrT1: [T1, T2, T3]): LodashPartial10x2; + (func: lodash.Function4, arg1: [T1, T2, T3]): lodash.Function1; + (func: lodash.__, plc1: [lodash.__, lodash.__, lodash.__, T4]): LodashPartial11x2; + (func: lodash.Function4, plc1: [lodash.__, lodash.__, lodash.__, T4]): lodash.Function3; + (func: lodash.__, arg1: [T1, lodash.__, lodash.__, T4]): LodashPartial12x2; + (func: lodash.Function4, arg1: [T1, lodash.__, lodash.__, T4]): lodash.Function2; + (func: lodash.__, plc1: [lodash.__, T2, lodash.__, T4]): LodashPartial13x2; + (func: lodash.Function4, plc1: [lodash.__, T2, lodash.__, T4]): lodash.Function2; + (func: lodash.__, arg1: [T1, T2, lodash.__, T4]): LodashPartial14x2; + (func: lodash.Function4, arg1: [T1, T2, lodash.__, T4]): lodash.Function1; + (func: lodash.__, plc1: [lodash.__, lodash.__, T3, T4]): LodashPartial15x2; + (func: lodash.Function4, plc1: [lodash.__, lodash.__, T3, T4]): lodash.Function2; + (func: lodash.__, arg1: [T1, lodash.__, T3, T4]): LodashPartial16x2; + (func: lodash.Function4, arg1: [T1, lodash.__, T3, T4]): lodash.Function1; + (func: lodash.__, plc1: [lodash.__, T2, T3, T4]): LodashPartial17x2; + (func: lodash.Function4, plc1: [lodash.__, T2, T3, T4]): lodash.Function1; + (func: (t1: T1, ...ts: TS) => R): LodashPartial18x1; + (func: lodash.__, arg1: [T1]): LodashPartial18x2; + (func: (t1: T1, ...ts: TS) => R, arg1: [T1]): (...ts: TS) => R; + (func: (t1: T1, t2: T2, ...ts: TS) => R): LodashPartial19x1; + (func: lodash.__, t1: [T1, T2]): LodashPartial19x2; + (func: (t1: T1, t2: T2, ...ts: TS) => R, t1: [T1, T2]): (...ts: TS) => R; + (func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R): LodashPartial20x1; + (func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: [T1, T2, T3]): (...ts: TS) => R; + (func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R): LodashPartial21x1; + (func: lodash.__, t1: [T1, T2, T3, T4]): LodashPartial21x2; + (func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: [T1, T2, T3, T4]): (...ts: TS) => R; + placeholder: lodash.__; + } + type LodashPartial1x1 = (plc1: [lodash.__, T2]) => lodash.Function1; + interface LodashPartial1x2 { + (func: lodash.Function2): lodash.Function1; + (func: lodash.Function3): lodash.Function2; + (func: lodash.Function4): lodash.Function3; + } + interface LodashPartial2x1 { + (plc1: [lodash.__, T2]): lodash.Function2; + (plc1: [lodash.__, lodash.__, T3]): lodash.Function2; + (arg1: [T1, lodash.__, T3]): lodash.Function1; + (plc1: [lodash.__, T2, T3]): lodash.Function1; + } + interface LodashPartial3x2 { + (func: lodash.Function3): lodash.Function2; + (func: lodash.Function4): lodash.Function3; + } + interface LodashPartial4x2 { + (func: lodash.Function3): lodash.Function1; + (func: lodash.Function4): lodash.Function2; + } + interface LodashPartial5x2 { + (func: lodash.Function3): lodash.Function1; + (func: lodash.Function4): lodash.Function2; + } + interface LodashPartial6x1 { + (plc1: [lodash.__, T2]): lodash.Function3; + (plc1: [lodash.__, lodash.__, T3]): lodash.Function3; + (arg1: [T1, lodash.__, T3]): lodash.Function2; + (plc1: [lodash.__, T2, T3]): lodash.Function2; + (arg1: [T1, T2, T3]): lodash.Function1; + (plc1: [lodash.__, lodash.__, lodash.__, T4]): lodash.Function3; + (arg1: [T1, lodash.__, lodash.__, T4]): lodash.Function2; + (plc1: [lodash.__, T2, lodash.__, T4]): lodash.Function2; + (arg1: [T1, T2, lodash.__, T4]): lodash.Function1; + (plc1: [lodash.__, lodash.__, T3, T4]): lodash.Function2; + (arg1: [T1, lodash.__, T3, T4]): lodash.Function1; + (plc1: [lodash.__, T2, T3, T4]): lodash.Function1; + } + interface LodashPartial10x2 { + (func: lodash.Function4): lodash.Function1; + (func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R): (...ts: TS) => R; + } + type LodashPartial11x2 = (func: lodash.Function4) => lodash.Function3; + type LodashPartial12x2 = (func: lodash.Function4) => lodash.Function2; + type LodashPartial13x2 = (func: lodash.Function4) => lodash.Function2; + type LodashPartial14x2 = (func: lodash.Function4) => lodash.Function1; + type LodashPartial15x2 = (func: lodash.Function4) => lodash.Function2; + type LodashPartial16x2 = (func: lodash.Function4) => lodash.Function1; + type LodashPartial17x2 = (func: lodash.Function4) => lodash.Function1; + type LodashPartial18x1 = (arg1: [T1]) => (...ts: TS) => R; + type LodashPartial18x2 = (func: (t1: T1, ...ts: TS) => R) => (...ts: TS) => R; + type LodashPartial19x1 = (t1: [T1, T2]) => (...ts: TS) => R; + type LodashPartial19x2 = (func: (t1: T1, t2: T2, ...ts: TS) => R) => (...ts: TS) => R; + type LodashPartial20x1 = (t1: [T1, T2, T3]) => (...ts: TS) => R; + type LodashPartial21x1 = (t1: [T1, T2, T3, T4]) => (...ts: TS) => R; + type LodashPartial21x2 = (func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R) => (...ts: TS) => R; + interface LodashPartialRight { + (func: lodash.Function1): LodashPartialRight1x1; + (func: lodash.__, arg1: [T1]): LodashPartialRight1x2; + (func: lodash.Function1, arg1: [T1]): lodash.Function0; + (func: lodash.Function2): LodashPartialRight2x1; + (func: lodash.__, arg1: [T1, lodash.__]): LodashPartialRight2x2; + (func: lodash.Function2, arg1: [T1, lodash.__]): lodash.Function1; + (func: lodash.__, arg2: [T2]): LodashPartialRight3x2; + (func: lodash.Function2, arg2: [T2]): lodash.Function1; + (func: lodash.__, arg1: [T1, T2]): LodashPartialRight4x2; + (func: lodash.Function2, arg1: [T1, T2]): lodash.Function0; + (func: lodash.Function3): LodashPartialRight5x1; + (func: lodash.__, arg1: [T1, lodash.__, lodash.__]): LodashPartialRight5x2; + (func: lodash.Function3, arg1: [T1, lodash.__, lodash.__]): lodash.Function2; + (func: lodash.__, arg2: [T2, lodash.__]): LodashPartialRight6x2; + (func: lodash.Function3, arg2: [T2, lodash.__]): lodash.Function2; + (func: lodash.__, arg1: [T1, T2, lodash.__]): LodashPartialRight7x2; + (func: lodash.Function3, arg1: [T1, T2, lodash.__]): lodash.Function1; + (func: lodash.__, arg3: [T3]): LodashPartialRight8x2; + (func: lodash.Function3, arg3: [T3]): lodash.Function2; + (func: lodash.__, arg1: [T1, lodash.__, T3]): LodashPartialRight9x2; + (func: lodash.Function3, arg1: [T1, lodash.__, T3]): lodash.Function1; + (func: lodash.__, arg2: [T2, T3]): LodashPartialRight10x2; + (func: lodash.Function3, arg2: [T2, T3]): lodash.Function1; + (func: lodash.__, arg1: [T1, T2, T3]): LodashPartialRight11x2; + (func: lodash.Function3, arg1: [T1, T2, T3]): lodash.Function0; + (func: lodash.Function4): LodashPartialRight12x1; + (func: lodash.__, arg1: [T1, lodash.__, lodash.__, lodash.__]): LodashPartialRight12x2; + (func: lodash.Function4, arg1: [T1, lodash.__, lodash.__, lodash.__]): lodash.Function3; + (func: lodash.__, arg2: [T2, lodash.__, lodash.__]): LodashPartialRight13x2; + (func: lodash.Function4, arg2: [T2, lodash.__, lodash.__]): lodash.Function3; + (func: lodash.__, arg1: [T1, T2, lodash.__, lodash.__]): LodashPartialRight14x2; + (func: lodash.Function4, arg1: [T1, T2, lodash.__, lodash.__]): lodash.Function2; + (func: lodash.__, arg3: [T3, lodash.__]): LodashPartialRight15x2; + (func: lodash.Function4, arg3: [T3, lodash.__]): lodash.Function3; + (func: lodash.__, arg1: [T1, lodash.__, T3, lodash.__]): LodashPartialRight16x2; + (func: lodash.Function4, arg1: [T1, lodash.__, T3, lodash.__]): lodash.Function2; + (func: lodash.__, arg2: [T2, T3, lodash.__]): LodashPartialRight17x2; + (func: lodash.Function4, arg2: [T2, T3, lodash.__]): lodash.Function2; + (func: lodash.__, arg1: [T1, T2, T3, lodash.__]): LodashPartialRight18x2; + (func: lodash.Function4, arg1: [T1, T2, T3, lodash.__]): lodash.Function1; + (func: lodash.__, arg4: [T4]): LodashPartialRight19x2; + (func: lodash.Function4, arg4: [T4]): lodash.Function3; + (func: lodash.__, arg1: [T1, lodash.__, lodash.__, T4]): LodashPartialRight20x2; + (func: lodash.Function4, arg1: [T1, lodash.__, lodash.__, T4]): lodash.Function2; + (func: lodash.__, arg2: [T2, lodash.__, T4]): LodashPartialRight21x2; + (func: lodash.Function4, arg2: [T2, lodash.__, T4]): lodash.Function2; + (func: lodash.__, arg1: [T1, T2, lodash.__, T4]): LodashPartialRight22x2; + (func: lodash.Function4, arg1: [T1, T2, lodash.__, T4]): lodash.Function1; + (func: lodash.__, arg3: [T3, T4]): LodashPartialRight23x2; + (func: lodash.Function4, arg3: [T3, T4]): lodash.Function2; + (func: lodash.__, arg1: [T1, lodash.__, T3, T4]): LodashPartialRight24x2; + (func: lodash.Function4, arg1: [T1, lodash.__, T3, T4]): lodash.Function1; + (func: lodash.__, arg2: [T2, T3, T4]): LodashPartialRight25x2; + (func: lodash.Function4, arg2: [T2, T3, T4]): lodash.Function1; + (func: lodash.__, arg1: [T1, T2, T3, T4]): LodashPartialRight26x2; + (func: lodash.Function4, arg1: [T1, T2, T3, T4]): lodash.Function0; + (func: (...args: any[]) => any): LodashPartialRight27x1; + (func: lodash.__, args: ReadonlyArray): LodashPartialRight27x2; + (func: (...args: any[]) => any, args: ReadonlyArray): (...args: any[]) => any; + placeholder: lodash.__; + } + type LodashPartialRight1x1 = (arg1: [T1]) => lodash.Function0; + type LodashPartialRight1x2 = (func: lodash.Function1) => lodash.Function0; + interface LodashPartialRight2x1 { + (arg1: [T1, lodash.__]): lodash.Function1; + (arg2: [T2]): lodash.Function1; + (arg1: [T1, T2]): lodash.Function0; + } + type LodashPartialRight2x2 = (func: lodash.Function2) => lodash.Function1; + type LodashPartialRight3x2 = (func: lodash.Function2) => lodash.Function1; + type LodashPartialRight4x2 = (func: lodash.Function2) => lodash.Function0; + interface LodashPartialRight5x1 { + (arg1: [T1, lodash.__, lodash.__]): lodash.Function2; + (arg2: [T2, lodash.__]): lodash.Function2; + (arg1: [T1, T2, lodash.__]): lodash.Function1; + (arg3: [T3]): lodash.Function2; + (arg1: [T1, lodash.__, T3]): lodash.Function1; + (arg2: [T2, T3]): lodash.Function1; + (arg1: [T1, T2, T3]): lodash.Function0; + } + type LodashPartialRight5x2 = (func: lodash.Function3) => lodash.Function2; + type LodashPartialRight6x2 = (func: lodash.Function3) => lodash.Function2; + type LodashPartialRight7x2 = (func: lodash.Function3) => lodash.Function1; + type LodashPartialRight8x2 = (func: lodash.Function3) => lodash.Function2; + type LodashPartialRight9x2 = (func: lodash.Function3) => lodash.Function1; + type LodashPartialRight10x2 = (func: lodash.Function3) => lodash.Function1; + type LodashPartialRight11x2 = (func: lodash.Function3) => lodash.Function0; + interface LodashPartialRight12x1 { + (arg1: [T1, lodash.__, lodash.__, lodash.__]): lodash.Function3; + (arg2: [T2, lodash.__, lodash.__]): lodash.Function3; + (arg1: [T1, T2, lodash.__, lodash.__]): lodash.Function2; + (arg3: [T3, lodash.__]): lodash.Function3; + (arg1: [T1, lodash.__, T3, lodash.__]): lodash.Function2; + (arg2: [T2, T3, lodash.__]): lodash.Function2; + (arg1: [T1, T2, T3, lodash.__]): lodash.Function1; + (arg4: [T4]): lodash.Function3; + (arg1: [T1, lodash.__, lodash.__, T4]): lodash.Function2; + (arg2: [T2, lodash.__, T4]): lodash.Function2; + (arg1: [T1, T2, lodash.__, T4]): lodash.Function1; + (arg3: [T3, T4]): lodash.Function2; + (arg1: [T1, lodash.__, T3, T4]): lodash.Function1; + (arg2: [T2, T3, T4]): lodash.Function1; + (arg1: [T1, T2, T3, T4]): lodash.Function0; + } + type LodashPartialRight12x2 = (func: lodash.Function4) => lodash.Function3; + type LodashPartialRight13x2 = (func: lodash.Function4) => lodash.Function3; + type LodashPartialRight14x2 = (func: lodash.Function4) => lodash.Function2; + type LodashPartialRight15x2 = (func: lodash.Function4) => lodash.Function3; + type LodashPartialRight16x2 = (func: lodash.Function4) => lodash.Function2; + type LodashPartialRight17x2 = (func: lodash.Function4) => lodash.Function2; + type LodashPartialRight18x2 = (func: lodash.Function4) => lodash.Function1; + type LodashPartialRight19x2 = (func: lodash.Function4) => lodash.Function3; + type LodashPartialRight20x2 = (func: lodash.Function4) => lodash.Function2; + type LodashPartialRight21x2 = (func: lodash.Function4) => lodash.Function2; + type LodashPartialRight22x2 = (func: lodash.Function4) => lodash.Function1; + type LodashPartialRight23x2 = (func: lodash.Function4) => lodash.Function2; + type LodashPartialRight24x2 = (func: lodash.Function4) => lodash.Function1; + type LodashPartialRight25x2 = (func: lodash.Function4) => lodash.Function1; + type LodashPartialRight26x2 = (func: lodash.Function4) => lodash.Function0; + type LodashPartialRight27x1 = (args: ReadonlyArray) => (...args: any[]) => any; + type LodashPartialRight27x2 = (func: (...args: any[]) => any) => (...args: any[]) => any; + interface LodashPartition { + (callback: lodash.ValueIteratee): LodashPartition1x1; + (callback: lodash.__, collection: lodash.List | null | undefined): LodashPartition1x2; + (callback: lodash.ValueIteratee, collection: lodash.List | null | undefined): [T[], T[]]; + (callback: lodash.__, collection: T | null | undefined): LodashPartition2x2; + (callback: lodash.ValueIteratee, collection: T | null | undefined): [Array, Array]; + } + type LodashPartition1x1 = (collection: lodash.List | object | null | undefined) => [T[], T[]]; + type LodashPartition1x2 = (callback: lodash.ValueIteratee) => [T[], T[]]; + type LodashPartition2x2 = (callback: lodash.ValueIteratee) => [Array, Array]; + interface LodashPath { + (path: TKey | [TKey]): LodashPath1x1; + (path: lodash.__, object: TObject): LodashPath1x2; + (path: TKey | [TKey], object: TObject): TObject[TKey]; + (path: lodash.__, object: TObject | null | undefined): LodashPath2x2; + (path: TKey | [TKey], object: TObject | null | undefined): TObject[TKey] | undefined; + (path: number): LodashPath3x1; + (path: lodash.__, object: lodash.NumericDictionary): LodashPath3x2; + (path: number, object: lodash.NumericDictionary): T; + (path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashPath4x2; + (path: number, object: lodash.NumericDictionary | null | undefined): T | undefined; + (path: lodash.PropertyPath): LodashPath5x1; + (path: lodash.__, object: null | undefined): LodashPath5x2; + (path: lodash.PropertyPath, object: null | undefined): undefined; + (path: lodash.__, object: any): LodashPath6x2; + (path: lodash.PropertyPath, object: any): any; + } + interface LodashPath1x1 { + (object: TObject): TObject[TKey]; + (object: TObject | null | undefined): TObject[TKey] | undefined; + } + type LodashPath1x2 = (path: TKey | [TKey]) => TObject[TKey]; + type LodashPath2x2 = (path: TKey | [TKey]) => TObject[TKey] | undefined; + interface LodashPath3x1 { + (object: lodash.NumericDictionary): T; + (object: lodash.NumericDictionary | null | undefined): T | undefined; + } + type LodashPath3x2 = (path: number) => T; + type LodashPath4x2 = (path: number) => T | undefined; + interface LodashPath5x1 { + (object: null | undefined): undefined; + (object: any): any; + } + type LodashPath5x2 = (path: lodash.PropertyPath) => undefined; + type LodashPath6x2 = (path: lodash.PropertyPath) => any; + interface LodashPathOr { + (defaultValue: TDefault): LodashPathOr1x1; + (defaultValue: lodash.__, path: TKey | [TKey]): LodashPathOr1x2; + (defaultValue: TDefault, path: TKey | [TKey]): LodashPathOr1x3; + (defaultValue: lodash.__, path: lodash.__, object: TObject | null | undefined): LodashPathOr1x4; + (defaultValue: TDefault, path: lodash.__, object: TObject | null | undefined): LodashPathOr1x5; + (defaultValue: lodash.__, path: TKey | [TKey], object: TObject | null | undefined): LodashPathOr1x6; + (defaultValue: TDefault, path: TKey | [TKey], object: TObject | null | undefined): Exclude | TDefault; + (defaultValue: lodash.__, path: number): LodashPathOr2x2; + (defaultValue: TDefault, path: number): LodashPathOr2x3; + (defaultValue: lodash.__, path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashPathOr2x4; + (defaultValue: TDefault, path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashPathOr2x5; + (defaultValue: lodash.__, path: number, object: lodash.NumericDictionary | null | undefined): LodashPathOr2x6; + (defaultValue: TDefault, path: number, object: lodash.NumericDictionary | null | undefined): T | TDefault; + (defaultValue: lodash.__, path: lodash.PropertyPath): LodashPathOr3x2; + (defaultValue: TDefault, path: lodash.PropertyPath): LodashPathOr3x3; + (defaultValue: lodash.__, path: lodash.__, object: null | undefined): LodashPathOr3x4; + (defaultValue: TDefault, path: lodash.__, object: null | undefined): LodashPathOr3x5; + (defaultValue: lodash.__, path: lodash.PropertyPath, object: null | undefined): LodashPathOr3x6; + (defaultValue: TDefault, path: lodash.PropertyPath, object: null | undefined): TDefault; + (defaultValue: any): LodashPathOr4x1; + (defaultValue: any, path: lodash.PropertyPath): LodashPathOr4x3; + (defaultValue: lodash.__, path: lodash.__, object: any): LodashPathOr4x4; + (defaultValue: any, path: lodash.__, object: any): LodashPathOr4x5; + (defaultValue: lodash.__, path: lodash.PropertyPath, object: any): LodashPathOr4x6; + (defaultValue: any, path: lodash.PropertyPath, object: any): any; + } + interface LodashPathOr1x1 { + (path: TKey | [TKey]): LodashPathOr1x3; + (path: lodash.__, object: TObject | null | undefined): LodashPathOr1x5; + (path: TKey | [TKey], object: TObject | null | undefined): Exclude | TDefault; + (path: number): LodashPathOr2x3; + (path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashPathOr2x5; + (path: number, object: lodash.NumericDictionary | null | undefined): T | TDefault; + (path: lodash.PropertyPath): LodashPathOr3x3; + (path: lodash.__, object: null | undefined): LodashPathOr3x5; + (path: lodash.PropertyPath, object: null | undefined): TDefault; + } + interface LodashPathOr1x2 { + (defaultValue: TDefault): LodashPathOr1x3; + (defaultValue: lodash.__, object: TObject | null | undefined): LodashPathOr1x6; + (defaultValue: TDefault, object: TObject | null | undefined): Exclude | TDefault; + } + type LodashPathOr1x3 = (object: TObject | null | undefined) => Exclude | TDefault; + interface LodashPathOr1x4 { + (defaultValue: TDefault): LodashPathOr1x5; + (defaultValue: lodash.__, path: TKey | [TKey]): LodashPathOr1x6; + (defaultValue: TDefault, path: TKey | [TKey]): Exclude | TDefault; + } + type LodashPathOr1x5 = (path: TKey | [TKey]) => Exclude | TDefault; + type LodashPathOr1x6 = (defaultValue: TDefault) => Exclude | TDefault; + interface LodashPathOr2x2 { + (defaultValue: TDefault): LodashPathOr2x3; + (defaultValue: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashPathOr2x6; + (defaultValue: TDefault, object: lodash.NumericDictionary | null | undefined): T | TDefault; + } + type LodashPathOr2x3 = (object: lodash.NumericDictionary | null | undefined) => T | TDefault; + interface LodashPathOr2x4 { + (defaultValue: TDefault): LodashPathOr2x5; + (defaultValue: lodash.__, path: number): LodashPathOr2x6; + (defaultValue: TDefault, path: number): T | TDefault; + } + type LodashPathOr2x5 = (path: number) => T | TDefault; + type LodashPathOr2x6 = (defaultValue: TDefault) => T | TDefault; + interface LodashPathOr3x2 { + (defaultValue: TDefault): LodashPathOr3x3; + (defaultValue: lodash.__, object: null | undefined): LodashPathOr3x6; + (defaultValue: TDefault, object: null | undefined): TDefault; + (defaultValue: any): LodashPathOr4x3; + (defaultValue: lodash.__, object: any): LodashPathOr4x6; + (defaultValue: any, object: any): any; + } + type LodashPathOr3x3 = (object: null | undefined) => TDefault; + interface LodashPathOr3x4 { + (defaultValue: TDefault): LodashPathOr3x5; + (defaultValue: lodash.__, path: lodash.PropertyPath): LodashPathOr3x6; + (defaultValue: TDefault, path: lodash.PropertyPath): TDefault; + } + type LodashPathOr3x5 = (path: lodash.PropertyPath) => TDefault; + type LodashPathOr3x6 = (defaultValue: TDefault) => TDefault; + interface LodashPathOr4x1 { + (path: lodash.PropertyPath): LodashPathOr4x3; + (path: lodash.__, object: any): LodashPathOr4x5; + (path: lodash.PropertyPath, object: any): any; + } + type LodashPathOr4x3 = (object: any) => any; + interface LodashPathOr4x4 { + (defaultValue: any): LodashPathOr4x5; + (defaultValue: lodash.__, path: lodash.PropertyPath): LodashPathOr4x6; + (defaultValue: any, path: lodash.PropertyPath): any; + } + type LodashPathOr4x5 = (path: lodash.PropertyPath) => any; + type LodashPathOr4x6 = (defaultValue: any) => any; + interface LodashPick { + (props: lodash.Many): LodashPick1x1; + (props: lodash.__, object: T): LodashPick1x2; + (props: lodash.Many, object: T): Pick; + (props: lodash.PropertyPath): LodashPick2x1; + (props: lodash.__, object: T | null | undefined): LodashPick2x2; + (props: lodash.PropertyPath, object: T | null | undefined): lodash.PartialDeep; + } + type LodashPick1x1 = (object: T) => Pick; + type LodashPick1x2 = (props: lodash.Many) => Pick; + type LodashPick2x1 = (object: T | null | undefined) => lodash.PartialDeep; + type LodashPick2x2 = (props: lodash.PropertyPath) => lodash.PartialDeep; + interface LodashPickBy { + (predicate: lodash.ValueKeyIterateeTypeGuard): LodashPickBy1x1; + (predicate: lodash.__, object: lodash.Dictionary | null | undefined): LodashPickBy1x2; + (predicate: lodash.ValueKeyIterateeTypeGuard, object: lodash.Dictionary | null | undefined): lodash.Dictionary; + (predicate: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashPickBy2x2; + (predicate: lodash.ValueKeyIterateeTypeGuard, object: lodash.NumericDictionary | null | undefined): lodash.NumericDictionary; + (predicate: lodash.ValueKeyIteratee): LodashPickBy3x1; + (predicate: lodash.ValueKeyIteratee, object: lodash.Dictionary | null | undefined): lodash.Dictionary; + (predicate: lodash.ValueKeyIteratee, object: lodash.NumericDictionary | null | undefined): lodash.NumericDictionary; + (predicate: lodash.__, object: T | null | undefined): LodashPickBy5x2; + (predicate: lodash.ValueKeyIteratee, object: T | null | undefined): lodash.PartialObject; + } + interface LodashPickBy1x1 { + (object: lodash.Dictionary | null | undefined): lodash.Dictionary; + (object: lodash.NumericDictionary | null | undefined): lodash.NumericDictionary; + } + interface LodashPickBy1x2 { + (predicate: lodash.ValueKeyIterateeTypeGuard): lodash.Dictionary; + (predicate: lodash.ValueKeyIteratee): lodash.Dictionary; + } + interface LodashPickBy2x2 { + (predicate: lodash.ValueKeyIterateeTypeGuard): lodash.NumericDictionary; + (predicate: lodash.ValueKeyIteratee): lodash.NumericDictionary; + } + interface LodashPickBy3x1 { + (object: lodash.Dictionary | null | undefined): lodash.Dictionary; + (object: lodash.NumericDictionary | null | undefined): lodash.NumericDictionary; + (object: T1 | null | undefined): lodash.PartialObject; + } + type LodashPickBy5x2 = (predicate: lodash.ValueKeyIteratee) => lodash.PartialObject; + interface LodashProp { + (path: TKey | [TKey]): LodashProp1x1; + (path: lodash.__, object: TObject): LodashProp1x2; + (path: TKey | [TKey], object: TObject): TObject[TKey]; + (path: lodash.__, object: TObject | null | undefined): LodashProp2x2; + (path: TKey | [TKey], object: TObject | null | undefined): TObject[TKey] | undefined; + (path: number): LodashProp3x1; + (path: lodash.__, object: lodash.NumericDictionary): LodashProp3x2; + (path: number, object: lodash.NumericDictionary): T; + (path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashProp4x2; + (path: number, object: lodash.NumericDictionary | null | undefined): T | undefined; + (path: lodash.PropertyPath): LodashProp5x1; + (path: lodash.__, object: null | undefined): LodashProp5x2; + (path: lodash.PropertyPath, object: null | undefined): undefined; + (path: lodash.__, object: any): LodashProp6x2; + (path: lodash.PropertyPath, object: any): any; + } + interface LodashProp1x1 { + (object: TObject): TObject[TKey]; + (object: TObject | null | undefined): TObject[TKey] | undefined; + } + type LodashProp1x2 = (path: TKey | [TKey]) => TObject[TKey]; + type LodashProp2x2 = (path: TKey | [TKey]) => TObject[TKey] | undefined; + interface LodashProp3x1 { + (object: lodash.NumericDictionary): T; + (object: lodash.NumericDictionary | null | undefined): T | undefined; + } + type LodashProp3x2 = (path: number) => T; + type LodashProp4x2 = (path: number) => T | undefined; + interface LodashProp5x1 { + (object: null | undefined): undefined; + (object: any): any; + } + type LodashProp5x2 = (path: lodash.PropertyPath) => undefined; + type LodashProp6x2 = (path: lodash.PropertyPath) => any; + interface LodashProperty { + (path: TKey | [TKey]): LodashProperty1x1; + (path: lodash.__, object: TObject): LodashProperty1x2; + (path: TKey | [TKey], object: TObject): TObject[TKey]; + (path: lodash.__, object: TObject | null | undefined): LodashProperty2x2; + (path: TKey | [TKey], object: TObject | null | undefined): TObject[TKey] | undefined; + (path: number): LodashProperty3x1; + (path: lodash.__, object: lodash.NumericDictionary): LodashProperty3x2; + (path: number, object: lodash.NumericDictionary): T; + (path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashProperty4x2; + (path: number, object: lodash.NumericDictionary | null | undefined): T | undefined; + (path: lodash.PropertyPath): LodashProperty5x1; + (path: lodash.__, object: null | undefined): LodashProperty5x2; + (path: lodash.PropertyPath, object: null | undefined): undefined; + (path: lodash.__, object: any): LodashProperty6x2; + (path: lodash.PropertyPath, object: any): any; + } + interface LodashProperty1x1 { + (object: TObject): TObject[TKey]; + (object: TObject | null | undefined): TObject[TKey] | undefined; + } + type LodashProperty1x2 = (path: TKey | [TKey]) => TObject[TKey]; + type LodashProperty2x2 = (path: TKey | [TKey]) => TObject[TKey] | undefined; + interface LodashProperty3x1 { + (object: lodash.NumericDictionary): T; + (object: lodash.NumericDictionary | null | undefined): T | undefined; + } + type LodashProperty3x2 = (path: number) => T; + type LodashProperty4x2 = (path: number) => T | undefined; + interface LodashProperty5x1 { + (object: null | undefined): undefined; + (object: any): any; + } + type LodashProperty5x2 = (path: lodash.PropertyPath) => undefined; + type LodashProperty6x2 = (path: lodash.PropertyPath) => any; + interface LodashPropertyOf { + (path: TKey | [TKey]): LodashPropertyOf1x1; + (path: lodash.__, object: TObject): LodashPropertyOf1x2; + (path: TKey | [TKey], object: TObject): TObject[TKey]; + (path: lodash.__, object: TObject | null | undefined): LodashPropertyOf2x2; + (path: TKey | [TKey], object: TObject | null | undefined): TObject[TKey] | undefined; + (path: number): LodashPropertyOf3x1; + (path: lodash.__, object: lodash.NumericDictionary): LodashPropertyOf3x2; + (path: number, object: lodash.NumericDictionary): T; + (path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashPropertyOf4x2; + (path: number, object: lodash.NumericDictionary | null | undefined): T | undefined; + (path: lodash.PropertyPath): LodashPropertyOf5x1; + (path: lodash.__, object: null | undefined): LodashPropertyOf5x2; + (path: lodash.PropertyPath, object: null | undefined): undefined; + (path: lodash.__, object: any): LodashPropertyOf6x2; + (path: lodash.PropertyPath, object: any): any; + } + interface LodashPropertyOf1x1 { + (object: TObject): TObject[TKey]; + (object: TObject | null | undefined): TObject[TKey] | undefined; + } + type LodashPropertyOf1x2 = (path: TKey | [TKey]) => TObject[TKey]; + type LodashPropertyOf2x2 = (path: TKey | [TKey]) => TObject[TKey] | undefined; + interface LodashPropertyOf3x1 { + (object: lodash.NumericDictionary): T; + (object: lodash.NumericDictionary | null | undefined): T | undefined; + } + type LodashPropertyOf3x2 = (path: number) => T; + type LodashPropertyOf4x2 = (path: number) => T | undefined; + interface LodashPropertyOf5x1 { + (object: null | undefined): undefined; + (object: any): any; + } + type LodashPropertyOf5x2 = (path: lodash.PropertyPath) => undefined; + type LodashPropertyOf6x2 = (path: lodash.PropertyPath) => any; + interface LodashPropOr { + (defaultValue: TDefault): LodashPropOr1x1; + (defaultValue: lodash.__, path: TKey | [TKey]): LodashPropOr1x2; + (defaultValue: TDefault, path: TKey | [TKey]): LodashPropOr1x3; + (defaultValue: lodash.__, path: lodash.__, object: TObject | null | undefined): LodashPropOr1x4; + (defaultValue: TDefault, path: lodash.__, object: TObject | null | undefined): LodashPropOr1x5; + (defaultValue: lodash.__, path: TKey | [TKey], object: TObject | null | undefined): LodashPropOr1x6; + (defaultValue: TDefault, path: TKey | [TKey], object: TObject | null | undefined): Exclude | TDefault; + (defaultValue: lodash.__, path: number): LodashPropOr2x2; + (defaultValue: TDefault, path: number): LodashPropOr2x3; + (defaultValue: lodash.__, path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashPropOr2x4; + (defaultValue: TDefault, path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashPropOr2x5; + (defaultValue: lodash.__, path: number, object: lodash.NumericDictionary | null | undefined): LodashPropOr2x6; + (defaultValue: TDefault, path: number, object: lodash.NumericDictionary | null | undefined): T | TDefault; + (defaultValue: lodash.__, path: lodash.PropertyPath): LodashPropOr3x2; + (defaultValue: TDefault, path: lodash.PropertyPath): LodashPropOr3x3; + (defaultValue: lodash.__, path: lodash.__, object: null | undefined): LodashPropOr3x4; + (defaultValue: TDefault, path: lodash.__, object: null | undefined): LodashPropOr3x5; + (defaultValue: lodash.__, path: lodash.PropertyPath, object: null | undefined): LodashPropOr3x6; + (defaultValue: TDefault, path: lodash.PropertyPath, object: null | undefined): TDefault; + (defaultValue: any): LodashPropOr4x1; + (defaultValue: any, path: lodash.PropertyPath): LodashPropOr4x3; + (defaultValue: lodash.__, path: lodash.__, object: any): LodashPropOr4x4; + (defaultValue: any, path: lodash.__, object: any): LodashPropOr4x5; + (defaultValue: lodash.__, path: lodash.PropertyPath, object: any): LodashPropOr4x6; + (defaultValue: any, path: lodash.PropertyPath, object: any): any; + } + interface LodashPropOr1x1 { + (path: TKey | [TKey]): LodashPropOr1x3; + (path: lodash.__, object: TObject | null | undefined): LodashPropOr1x5; + (path: TKey | [TKey], object: TObject | null | undefined): Exclude | TDefault; + (path: number): LodashPropOr2x3; + (path: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashPropOr2x5; + (path: number, object: lodash.NumericDictionary | null | undefined): T | TDefault; + (path: lodash.PropertyPath): LodashPropOr3x3; + (path: lodash.__, object: null | undefined): LodashPropOr3x5; + (path: lodash.PropertyPath, object: null | undefined): TDefault; + } + interface LodashPropOr1x2 { + (defaultValue: TDefault): LodashPropOr1x3; + (defaultValue: lodash.__, object: TObject | null | undefined): LodashPropOr1x6; + (defaultValue: TDefault, object: TObject | null | undefined): Exclude | TDefault; + } + type LodashPropOr1x3 = (object: TObject | null | undefined) => Exclude | TDefault; + interface LodashPropOr1x4 { + (defaultValue: TDefault): LodashPropOr1x5; + (defaultValue: lodash.__, path: TKey | [TKey]): LodashPropOr1x6; + (defaultValue: TDefault, path: TKey | [TKey]): Exclude | TDefault; + } + type LodashPropOr1x5 = (path: TKey | [TKey]) => Exclude | TDefault; + type LodashPropOr1x6 = (defaultValue: TDefault) => Exclude | TDefault; + interface LodashPropOr2x2 { + (defaultValue: TDefault): LodashPropOr2x3; + (defaultValue: lodash.__, object: lodash.NumericDictionary | null | undefined): LodashPropOr2x6; + (defaultValue: TDefault, object: lodash.NumericDictionary | null | undefined): T | TDefault; + } + type LodashPropOr2x3 = (object: lodash.NumericDictionary | null | undefined) => T | TDefault; + interface LodashPropOr2x4 { + (defaultValue: TDefault): LodashPropOr2x5; + (defaultValue: lodash.__, path: number): LodashPropOr2x6; + (defaultValue: TDefault, path: number): T | TDefault; + } + type LodashPropOr2x5 = (path: number) => T | TDefault; + type LodashPropOr2x6 = (defaultValue: TDefault) => T | TDefault; + interface LodashPropOr3x2 { + (defaultValue: TDefault): LodashPropOr3x3; + (defaultValue: lodash.__, object: null | undefined): LodashPropOr3x6; + (defaultValue: TDefault, object: null | undefined): TDefault; + (defaultValue: any): LodashPropOr4x3; + (defaultValue: lodash.__, object: any): LodashPropOr4x6; + (defaultValue: any, object: any): any; + } + type LodashPropOr3x3 = (object: null | undefined) => TDefault; + interface LodashPropOr3x4 { + (defaultValue: TDefault): LodashPropOr3x5; + (defaultValue: lodash.__, path: lodash.PropertyPath): LodashPropOr3x6; + (defaultValue: TDefault, path: lodash.PropertyPath): TDefault; + } + type LodashPropOr3x5 = (path: lodash.PropertyPath) => TDefault; + type LodashPropOr3x6 = (defaultValue: TDefault) => TDefault; + interface LodashPropOr4x1 { + (path: lodash.PropertyPath): LodashPropOr4x3; + (path: lodash.__, object: any): LodashPropOr4x5; + (path: lodash.PropertyPath, object: any): any; + } + type LodashPropOr4x3 = (object: any) => any; + interface LodashPropOr4x4 { + (defaultValue: any): LodashPropOr4x5; + (defaultValue: lodash.__, path: lodash.PropertyPath): LodashPropOr4x6; + (defaultValue: any, path: lodash.PropertyPath): any; + } + type LodashPropOr4x5 = (path: lodash.PropertyPath) => any; + type LodashPropOr4x6 = (defaultValue: any) => any; + interface LodashPull { + (values: T): LodashPull1x1; + (values: lodash.__, array: ReadonlyArray): LodashPull1x2; + (values: T, array: ReadonlyArray): T[]; + (values: lodash.__, array: lodash.List): LodashPull2x2; + (values: T, array: lodash.List): lodash.List; + } + interface LodashPull1x1 { + (array: ReadonlyArray): T[]; + (array: lodash.List): lodash.List; + } + type LodashPull1x2 = (values: T) => T[]; + type LodashPull2x2 = (values: T) => lodash.List; + interface LodashPullAll { + (values: lodash.List): LodashPullAll1x1; + (values: lodash.__, array: ReadonlyArray): LodashPullAll1x2; + (values: lodash.List, array: ReadonlyArray): T[]; + (values: lodash.__, array: lodash.List): LodashPullAll2x2; + (values: lodash.List, array: lodash.List): lodash.List; + } + interface LodashPullAll1x1 { + (array: ReadonlyArray): T[]; + (array: lodash.List): lodash.List; + } + type LodashPullAll1x2 = (values: lodash.List) => T[]; + type LodashPullAll2x2 = (values: lodash.List) => lodash.List; + interface LodashPullAllBy { + (iteratee: lodash.ValueIteratee): LodashPullAllBy1x1; + (iteratee: lodash.__, values: lodash.List): LodashPullAllBy1x2; + (iteratee: lodash.ValueIteratee, values: lodash.List): LodashPullAllBy1x3; + (iteratee: lodash.__, values: lodash.__, array: ReadonlyArray): LodashPullAllBy1x4; + (iteratee: lodash.ValueIteratee, values: lodash.__, array: ReadonlyArray): LodashPullAllBy1x5; + (iteratee: lodash.__, values: lodash.List, array: ReadonlyArray): LodashPullAllBy1x6; + (iteratee: lodash.ValueIteratee, values: lodash.List, array: ReadonlyArray): T[]; + (iteratee: lodash.__, values: lodash.__, array: lodash.List): LodashPullAllBy2x4; + (iteratee: lodash.ValueIteratee, values: lodash.__, array: lodash.List): LodashPullAllBy2x5; + (iteratee: lodash.__, values: lodash.List, array: lodash.List): LodashPullAllBy2x6; + (iteratee: lodash.ValueIteratee, values: lodash.List, array: lodash.List): lodash.List; + (iteratee: lodash.ValueIteratee): LodashPullAllBy3x1; + (iteratee: lodash.__, values: lodash.List): LodashPullAllBy3x2; + (iteratee: lodash.ValueIteratee, values: lodash.List): LodashPullAllBy3x3; + (iteratee: lodash.__, values: lodash.__, array: ReadonlyArray): LodashPullAllBy3x4; + (iteratee: lodash.ValueIteratee, values: lodash.__, array: ReadonlyArray): LodashPullAllBy3x5; + (iteratee: lodash.__, values: lodash.List, array: ReadonlyArray): LodashPullAllBy3x6; + (iteratee: lodash.ValueIteratee, values: lodash.List, array: ReadonlyArray): T1[]; + (iteratee: lodash.__, values: lodash.__, array: lodash.List): LodashPullAllBy4x4; + (iteratee: lodash.ValueIteratee, values: lodash.__, array: lodash.List): LodashPullAllBy4x5; + (iteratee: lodash.__, values: lodash.List, array: lodash.List): LodashPullAllBy4x6; + (iteratee: lodash.ValueIteratee, values: lodash.List, array: lodash.List): lodash.List; + } + interface LodashPullAllBy1x1 { + (values: lodash.List): LodashPullAllBy1x3; + (values: lodash.__, array: ReadonlyArray): LodashPullAllBy1x5; + (values: lodash.List, array: ReadonlyArray): T[]; + (values: lodash.__, array: lodash.List): LodashPullAllBy2x5; + (values: lodash.List, array: lodash.List): lodash.List; + } + interface LodashPullAllBy1x2 { + (iteratee: lodash.ValueIteratee): LodashPullAllBy1x3; + (iteratee: lodash.__, array: ReadonlyArray): LodashPullAllBy1x6; + (iteratee: lodash.ValueIteratee, array: ReadonlyArray): T[]; + (iteratee: lodash.__, array: lodash.List): LodashPullAllBy2x6; + (iteratee: lodash.ValueIteratee, array: lodash.List): lodash.List; + } + interface LodashPullAllBy1x3 { + (array: ReadonlyArray): T[]; + (array: lodash.List): lodash.List; + } + interface LodashPullAllBy1x4 { + (iteratee: lodash.ValueIteratee): LodashPullAllBy1x5; + (iteratee: lodash.__, values: lodash.List): LodashPullAllBy1x6; + (iteratee: lodash.ValueIteratee, values: lodash.List): T[]; + } + type LodashPullAllBy1x5 = (values: lodash.List) => T[]; + type LodashPullAllBy1x6 = (iteratee: lodash.ValueIteratee) => T[]; + interface LodashPullAllBy2x4 { + (iteratee: lodash.ValueIteratee): LodashPullAllBy2x5; + (iteratee: lodash.__, values: lodash.List): LodashPullAllBy2x6; + (iteratee: lodash.ValueIteratee, values: lodash.List): lodash.List; + } + type LodashPullAllBy2x5 = (values: lodash.List) => lodash.List; + type LodashPullAllBy2x6 = (iteratee: lodash.ValueIteratee) => lodash.List; + interface LodashPullAllBy3x1 { + (values: lodash.List): LodashPullAllBy3x3; + (values: lodash.__, array: ReadonlyArray): LodashPullAllBy3x5; + (values: lodash.List, array: ReadonlyArray): T1[]; + (values: lodash.__, array: lodash.List): LodashPullAllBy4x5; + (values: lodash.List, array: lodash.List): lodash.List; + } + interface LodashPullAllBy3x2 { + (iteratee: lodash.ValueIteratee): LodashPullAllBy3x3; + (iteratee: lodash.__, array: ReadonlyArray): LodashPullAllBy3x6; + (iteratee: lodash.ValueIteratee, array: ReadonlyArray): T1[]; + (iteratee: lodash.__, array: lodash.List): LodashPullAllBy4x6; + (iteratee: lodash.ValueIteratee, array: lodash.List): lodash.List; + } + interface LodashPullAllBy3x3 { + (array: ReadonlyArray): T1[]; + (array: lodash.List): lodash.List; + } + interface LodashPullAllBy3x4 { + (iteratee: lodash.ValueIteratee): LodashPullAllBy3x5; + (iteratee: lodash.__, values: lodash.List): LodashPullAllBy3x6; + (iteratee: lodash.ValueIteratee, values: lodash.List): T1[]; + } + type LodashPullAllBy3x5 = (values: lodash.List) => T1[]; + type LodashPullAllBy3x6 = (iteratee: lodash.ValueIteratee) => T1[]; + interface LodashPullAllBy4x4 { + (iteratee: lodash.ValueIteratee): LodashPullAllBy4x5; + (iteratee: lodash.__, values: lodash.List): LodashPullAllBy4x6; + (iteratee: lodash.ValueIteratee, values: lodash.List): lodash.List; + } + type LodashPullAllBy4x5 = (values: lodash.List) => lodash.List; + type LodashPullAllBy4x6 = (iteratee: lodash.ValueIteratee) => lodash.List; + interface LodashPullAllWith { + (comparator: lodash.Comparator): LodashPullAllWith1x1; + (comparator: lodash.__, values: lodash.List): LodashPullAllWith1x2; + (comparator: lodash.Comparator, values: lodash.List): LodashPullAllWith1x3; + (comparator: lodash.__, values: lodash.__, array: ReadonlyArray): LodashPullAllWith1x4; + (comparator: lodash.Comparator, values: lodash.__, array: ReadonlyArray): LodashPullAllWith1x5; + (comparator: lodash.__, values: lodash.List, array: ReadonlyArray): LodashPullAllWith1x6; + (comparator: lodash.Comparator, values: lodash.List, array: ReadonlyArray): T[]; + (comparator: lodash.__, values: lodash.__, array: lodash.List): LodashPullAllWith2x4; + (comparator: lodash.Comparator, values: lodash.__, array: lodash.List): LodashPullAllWith2x5; + (comparator: lodash.__, values: lodash.List, array: lodash.List): LodashPullAllWith2x6; + (comparator: lodash.Comparator, values: lodash.List, array: lodash.List): lodash.List; + (comparator: lodash.Comparator2): LodashPullAllWith3x1; + (comparator: lodash.__, values: lodash.List): LodashPullAllWith3x2; + (comparator: lodash.Comparator2, values: lodash.List): LodashPullAllWith3x3; + (comparator: lodash.__, values: lodash.__, array: ReadonlyArray): LodashPullAllWith3x4; + (comparator: lodash.Comparator2, values: lodash.__, array: ReadonlyArray): LodashPullAllWith3x5; + (comparator: lodash.__, values: lodash.List, array: ReadonlyArray): LodashPullAllWith3x6; + (comparator: lodash.Comparator2, values: lodash.List, array: ReadonlyArray): T1[]; + (comparator: lodash.__, values: lodash.__, array: lodash.List): LodashPullAllWith4x4; + (comparator: lodash.Comparator2, values: lodash.__, array: lodash.List): LodashPullAllWith4x5; + (comparator: lodash.__, values: lodash.List, array: lodash.List): LodashPullAllWith4x6; + (comparator: lodash.Comparator2, values: lodash.List, array: lodash.List): lodash.List; + } + interface LodashPullAllWith1x1 { + (values: lodash.List): LodashPullAllWith1x3; + (values: lodash.__, array: ReadonlyArray): LodashPullAllWith1x5; + (values: lodash.List, array: ReadonlyArray): T[]; + (values: lodash.__, array: lodash.List): LodashPullAllWith2x5; + (values: lodash.List, array: lodash.List): lodash.List; + } + interface LodashPullAllWith1x2 { + (comparator: lodash.Comparator): LodashPullAllWith1x3; + (comparator: lodash.__, array: ReadonlyArray): LodashPullAllWith1x6; + (comparator: lodash.Comparator, array: ReadonlyArray): T[]; + (comparator: lodash.__, array: lodash.List): LodashPullAllWith2x6; + (comparator: lodash.Comparator, array: lodash.List): lodash.List; + } + interface LodashPullAllWith1x3 { + (array: ReadonlyArray): T[]; + (array: lodash.List): lodash.List; + } + interface LodashPullAllWith1x4 { + (comparator: lodash.Comparator): LodashPullAllWith1x5; + (comparator: lodash.__, values: lodash.List): LodashPullAllWith1x6; + (comparator: lodash.Comparator, values: lodash.List): T[]; + } + type LodashPullAllWith1x5 = (values: lodash.List) => T[]; + type LodashPullAllWith1x6 = (comparator: lodash.Comparator) => T[]; + interface LodashPullAllWith2x4 { + (comparator: lodash.Comparator): LodashPullAllWith2x5; + (comparator: lodash.__, values: lodash.List): LodashPullAllWith2x6; + (comparator: lodash.Comparator, values: lodash.List): lodash.List; + } + type LodashPullAllWith2x5 = (values: lodash.List) => lodash.List; + type LodashPullAllWith2x6 = (comparator: lodash.Comparator) => lodash.List; + interface LodashPullAllWith3x1 { + (values: lodash.List): LodashPullAllWith3x3; + (values: lodash.__, array: ReadonlyArray): LodashPullAllWith3x5; + (values: lodash.List, array: ReadonlyArray): T1[]; + (values: lodash.__, array: lodash.List): LodashPullAllWith4x5; + (values: lodash.List, array: lodash.List): lodash.List; + } + interface LodashPullAllWith3x2 { + (comparator: lodash.Comparator2): LodashPullAllWith3x3; + (comparator: lodash.__, array: ReadonlyArray): LodashPullAllWith3x6; + (comparator: lodash.Comparator2, array: ReadonlyArray): T1[]; + (comparator: lodash.__, array: lodash.List): LodashPullAllWith4x6; + (comparator: lodash.Comparator2, array: lodash.List): lodash.List; + } + interface LodashPullAllWith3x3 { + (array: ReadonlyArray): T1[]; + (array: lodash.List): lodash.List; + } + interface LodashPullAllWith3x4 { + (comparator: lodash.Comparator2): LodashPullAllWith3x5; + (comparator: lodash.__, values: lodash.List): LodashPullAllWith3x6; + (comparator: lodash.Comparator2, values: lodash.List): T1[]; + } + type LodashPullAllWith3x5 = (values: lodash.List) => T1[]; + type LodashPullAllWith3x6 = (comparator: lodash.Comparator2) => T1[]; + interface LodashPullAllWith4x4 { + (comparator: lodash.Comparator2): LodashPullAllWith4x5; + (comparator: lodash.__, values: lodash.List): LodashPullAllWith4x6; + (comparator: lodash.Comparator2, values: lodash.List): lodash.List; + } + type LodashPullAllWith4x5 = (values: lodash.List) => lodash.List; + type LodashPullAllWith4x6 = (comparator: lodash.Comparator2) => lodash.List; + interface LodashPullAt { + (indexes: lodash.Many): LodashPullAt1x1; + (indexes: lodash.__, array: ReadonlyArray): LodashPullAt1x2; + (indexes: lodash.Many, array: ReadonlyArray): T[]; + (indexes: lodash.__, array: lodash.List): LodashPullAt2x2; + (indexes: lodash.Many, array: lodash.List): lodash.List; + } + interface LodashPullAt1x1 { + (array: ReadonlyArray): T[]; + (array: lodash.List): lodash.List; + } + type LodashPullAt1x2 = (indexes: lodash.Many) => T[]; + type LodashPullAt2x2 = (indexes: lodash.Many) => lodash.List; + interface LodashRandom { + (maxOrMin: number): LodashRandom1x1; + (max: lodash.__, floating: boolean): LodashRandom1x2; + (maxOrMin: number, floatingOrMax: boolean | number): number; + (min: lodash.__, max: number): LodashRandom2x2; + } + type LodashRandom1x1 = (floatingOrMax: boolean | number) => number; + type LodashRandom1x2 = (max: number) => number; + type LodashRandom2x2 = (min: number) => number; + interface LodashRange { + (start: number): LodashRange1x1; + (start: lodash.__, end: number): LodashRange1x2; + (start: number, end: number): number[]; + } + type LodashRange1x1 = (end: number) => number[]; + type LodashRange1x2 = (start: number) => number[]; + interface LodashRangeRight { + (start: number): LodashRangeRight1x1; + (start: lodash.__, end: number): LodashRangeRight1x2; + (start: number, end: number): number[]; + } + type LodashRangeRight1x1 = (end: number) => number[]; + type LodashRangeRight1x2 = (start: number) => number[]; + interface LodashRangeStep { + (start: number): LodashRangeStep1x1; + (start: lodash.__, end: number): LodashRangeStep1x2; + (start: number, end: number): LodashRangeStep1x3; + (start: lodash.__, end: lodash.__, step: number): LodashRangeStep1x4; + (start: number, end: lodash.__, step: number): LodashRangeStep1x5; + (start: lodash.__, end: number, step: number): LodashRangeStep1x6; + (start: number, end: number, step: number): number[]; + } + interface LodashRangeStep1x1 { + (end: number): LodashRangeStep1x3; + (end: lodash.__, step: number): LodashRangeStep1x5; + (end: number, step: number): number[]; + } + interface LodashRangeStep1x2 { + (start: number): LodashRangeStep1x3; + (start: lodash.__, step: number): LodashRangeStep1x6; + (start: number, step: number): number[]; + } + type LodashRangeStep1x3 = (step: number) => number[]; + interface LodashRangeStep1x4 { + (start: number): LodashRangeStep1x5; + (start: lodash.__, end: number): LodashRangeStep1x6; + (start: number, end: number): number[]; + } + type LodashRangeStep1x5 = (end: number) => number[]; + type LodashRangeStep1x6 = (start: number) => number[]; + interface LodashRangeStepRight { + (start: number): LodashRangeStepRight1x1; + (start: lodash.__, end: number): LodashRangeStepRight1x2; + (start: number, end: number): LodashRangeStepRight1x3; + (start: lodash.__, end: lodash.__, step: number): LodashRangeStepRight1x4; + (start: number, end: lodash.__, step: number): LodashRangeStepRight1x5; + (start: lodash.__, end: number, step: number): LodashRangeStepRight1x6; + (start: number, end: number, step: number): number[]; + } + interface LodashRangeStepRight1x1 { + (end: number): LodashRangeStepRight1x3; + (end: lodash.__, step: number): LodashRangeStepRight1x5; + (end: number, step: number): number[]; + } + interface LodashRangeStepRight1x2 { + (start: number): LodashRangeStepRight1x3; + (start: lodash.__, step: number): LodashRangeStepRight1x6; + (start: number, step: number): number[]; + } + type LodashRangeStepRight1x3 = (step: number) => number[]; + interface LodashRangeStepRight1x4 { + (start: number): LodashRangeStepRight1x5; + (start: lodash.__, end: number): LodashRangeStepRight1x6; + (start: number, end: number): number[]; + } + type LodashRangeStepRight1x5 = (end: number) => number[]; + type LodashRangeStepRight1x6 = (start: number) => number[]; + interface LodashRearg { + (indexes: lodash.Many): LodashRearg1x1; + (indexes: lodash.__, func: (...args: any[]) => any): LodashRearg1x2; + (indexes: lodash.Many, func: (...args: any[]) => any): (...args: any[]) => any; + } + type LodashRearg1x1 = (func: (...args: any[]) => any) => (...args: any[]) => any; + type LodashRearg1x2 = (indexes: lodash.Many) => (...args: any[]) => any; + interface LodashReduce { + (callback: lodash.MemoIteratorCapped): LodashReduce1x1; + (callback: lodash.__, accumulator: TResult): LodashReduce1x2; + (callback: lodash.MemoIteratorCapped, accumulator: TResult): LodashReduce1x3; + (callback: lodash.__, accumulator: lodash.__, collection: T[] | null | undefined): LodashReduce1x4; + (callback: lodash.MemoIteratorCapped, accumulator: lodash.__, collection: T[] | null | undefined): LodashReduce1x5; + (callback: lodash.__, accumulator: TResult, collection: T[] | null | undefined): LodashReduce1x6; + (callback: lodash.MemoIteratorCapped, accumulator: TResult, collection: T[] | lodash.List | null | undefined): TResult; + (callback: lodash.__, accumulator: lodash.__, collection: lodash.List | null | undefined): LodashReduce2x4; + (callback: lodash.MemoIteratorCapped, accumulator: lodash.__, collection: lodash.List | null | undefined): LodashReduce2x5; + (callback: lodash.__, accumulator: TResult, collection: lodash.List | null | undefined): LodashReduce2x6; + (callback: lodash.MemoIteratorCapped): LodashReduce3x1; + (callback: lodash.MemoIteratorCapped, accumulator: TResult): LodashReduce3x3; + (callback: lodash.__, accumulator: lodash.__, collection: T | null | undefined): LodashReduce3x4; + (callback: lodash.MemoIteratorCapped, accumulator: lodash.__, collection: T | null | undefined): LodashReduce3x5; + (callback: lodash.__, accumulator: TResult, collection: T | null | undefined): LodashReduce3x6; + (callback: lodash.MemoIteratorCapped, accumulator: TResult, collection: T | null | undefined): TResult; + } + interface LodashReduce1x1 { + (accumulator: TResult): LodashReduce1x3; + (accumulator: lodash.__, collection: T[] | null | undefined): LodashReduce1x5; + (accumulator: TResult, collection: T[] | lodash.List | null | undefined): TResult; + (accumulator: lodash.__, collection: lodash.List | null | undefined): LodashReduce2x5; + } + interface LodashReduce1x2 { + (callback: lodash.MemoIteratorCapped): LodashReduce1x3; + (callback: lodash.__, collection: T[] | null | undefined): LodashReduce1x6; + (callback: lodash.MemoIteratorCapped, collection: T[] | lodash.List | null | undefined): TResult; + (callback: lodash.__, collection: lodash.List | null | undefined): LodashReduce2x6; + (callback: lodash.MemoIteratorCapped): LodashReduce3x3; + (callback: lodash.__, collection: T | null | undefined): LodashReduce3x6; + (callback: lodash.MemoIteratorCapped, collection: T | null | undefined): TResult; + } + type LodashReduce1x3 = (collection: T[] | lodash.List | null | undefined) => TResult; + interface LodashReduce1x4 { + (callback: lodash.MemoIteratorCapped): LodashReduce1x5; + (callback: lodash.__, accumulator: TResult): LodashReduce1x6; + (callback: lodash.MemoIteratorCapped, accumulator: TResult): TResult; + } + type LodashReduce1x5 = (accumulator: TResult) => TResult; + type LodashReduce1x6 = (callback: lodash.MemoIteratorCapped) => TResult; + interface LodashReduce2x4 { + (callback: lodash.MemoIteratorCapped): LodashReduce2x5; + (callback: lodash.__, accumulator: TResult): LodashReduce2x6; + (callback: lodash.MemoIteratorCapped, accumulator: TResult): TResult; + } + type LodashReduce2x5 = (accumulator: TResult) => TResult; + type LodashReduce2x6 = (callback: lodash.MemoIteratorCapped) => TResult; + interface LodashReduce3x1 { + (accumulator: TResult): LodashReduce3x3; + (accumulator: lodash.__, collection: T | null | undefined): LodashReduce3x5; + (accumulator: TResult, collection: T | null | undefined): TResult; + } + type LodashReduce3x3 = (collection: T | null | undefined) => TResult; + interface LodashReduce3x4 { + (callback: lodash.MemoIteratorCapped): LodashReduce3x5; + (callback: lodash.__, accumulator: TResult): LodashReduce3x6; + (callback: lodash.MemoIteratorCapped, accumulator: TResult): TResult; + } + type LodashReduce3x5 = (accumulator: TResult) => TResult; + type LodashReduce3x6 = (callback: lodash.MemoIteratorCapped) => TResult; + interface LodashReduceRight { + (callback: lodash.MemoIteratorCappedRight): LodashReduceRight1x1; + (callback: lodash.__, accumulator: TResult): LodashReduceRight1x2; + (callback: lodash.MemoIteratorCappedRight, accumulator: TResult): LodashReduceRight1x3; + (callback: lodash.__, accumulator: lodash.__, collection: T[] | null | undefined): LodashReduceRight1x4; + (callback: lodash.MemoIteratorCappedRight, accumulator: lodash.__, collection: T[] | null | undefined): LodashReduceRight1x5; + (callback: lodash.__, accumulator: TResult, collection: T[] | null | undefined): LodashReduceRight1x6; + (callback: lodash.MemoIteratorCappedRight, accumulator: TResult, collection: T[] | lodash.List | null | undefined): TResult; + (callback: lodash.__, accumulator: lodash.__, collection: lodash.List | null | undefined): LodashReduceRight2x4; + (callback: lodash.MemoIteratorCappedRight, accumulator: lodash.__, collection: lodash.List | null | undefined): LodashReduceRight2x5; + (callback: lodash.__, accumulator: TResult, collection: lodash.List | null | undefined): LodashReduceRight2x6; + (callback: lodash.MemoIteratorCappedRight): LodashReduceRight3x1; + (callback: lodash.MemoIteratorCappedRight, accumulator: TResult): LodashReduceRight3x3; + (callback: lodash.__, accumulator: lodash.__, collection: T | null | undefined): LodashReduceRight3x4; + (callback: lodash.MemoIteratorCappedRight, accumulator: lodash.__, collection: T | null | undefined): LodashReduceRight3x5; + (callback: lodash.__, accumulator: TResult, collection: T | null | undefined): LodashReduceRight3x6; + (callback: lodash.MemoIteratorCappedRight, accumulator: TResult, collection: T | null | undefined): TResult; + } + interface LodashReduceRight1x1 { + (accumulator: TResult): LodashReduceRight1x3; + (accumulator: lodash.__, collection: T[] | null | undefined): LodashReduceRight1x5; + (accumulator: TResult, collection: T[] | lodash.List | null | undefined): TResult; + (accumulator: lodash.__, collection: lodash.List | null | undefined): LodashReduceRight2x5; + } + interface LodashReduceRight1x2 { + (callback: lodash.MemoIteratorCappedRight): LodashReduceRight1x3; + (callback: lodash.__, collection: T[] | null | undefined): LodashReduceRight1x6; + (callback: lodash.MemoIteratorCappedRight, collection: T[] | lodash.List | null | undefined): TResult; + (callback: lodash.__, collection: lodash.List | null | undefined): LodashReduceRight2x6; + (callback: lodash.MemoIteratorCappedRight): LodashReduceRight3x3; + (callback: lodash.__, collection: T | null | undefined): LodashReduceRight3x6; + (callback: lodash.MemoIteratorCappedRight, collection: T | null | undefined): TResult; + } + type LodashReduceRight1x3 = (collection: T[] | lodash.List | null | undefined) => TResult; + interface LodashReduceRight1x4 { + (callback: lodash.MemoIteratorCappedRight): LodashReduceRight1x5; + (callback: lodash.__, accumulator: TResult): LodashReduceRight1x6; + (callback: lodash.MemoIteratorCappedRight, accumulator: TResult): TResult; + } + type LodashReduceRight1x5 = (accumulator: TResult) => TResult; + type LodashReduceRight1x6 = (callback: lodash.MemoIteratorCappedRight) => TResult; + interface LodashReduceRight2x4 { + (callback: lodash.MemoIteratorCappedRight): LodashReduceRight2x5; + (callback: lodash.__, accumulator: TResult): LodashReduceRight2x6; + (callback: lodash.MemoIteratorCappedRight, accumulator: TResult): TResult; + } + type LodashReduceRight2x5 = (accumulator: TResult) => TResult; + type LodashReduceRight2x6 = (callback: lodash.MemoIteratorCappedRight) => TResult; + interface LodashReduceRight3x1 { + (accumulator: TResult): LodashReduceRight3x3; + (accumulator: lodash.__, collection: T | null | undefined): LodashReduceRight3x5; + (accumulator: TResult, collection: T | null | undefined): TResult; + } + type LodashReduceRight3x3 = (collection: T | null | undefined) => TResult; + interface LodashReduceRight3x4 { + (callback: lodash.MemoIteratorCappedRight): LodashReduceRight3x5; + (callback: lodash.__, accumulator: TResult): LodashReduceRight3x6; + (callback: lodash.MemoIteratorCappedRight, accumulator: TResult): TResult; + } + type LodashReduceRight3x5 = (accumulator: TResult) => TResult; + type LodashReduceRight3x6 = (callback: lodash.MemoIteratorCappedRight) => TResult; + interface LodashReject { + (predicate: lodash.ValueIterateeCustom): LodashReject1x1; + (predicate: lodash.__, collection: lodash.List | null | undefined): LodashReject1x2; + (predicate: lodash.ValueIterateeCustom, collection: lodash.List | null | undefined): T[]; + (predicate: lodash.__, collection: T | null | undefined): LodashReject2x2; + (predicate: lodash.ValueIterateeCustom, collection: T | null | undefined): Array; + } + type LodashReject1x1 = (collection: lodash.List | object | null | undefined) => T[]; + type LodashReject1x2 = (predicate: lodash.ValueIterateeCustom) => T[]; + type LodashReject2x2 = (predicate: lodash.ValueIterateeCustom) => Array; + interface LodashRemove { + (predicate: lodash.ValueIteratee): LodashRemove1x1; + (predicate: lodash.__, array: lodash.List): LodashRemove1x2; + (predicate: lodash.ValueIteratee, array: lodash.List): T[]; + } + type LodashRemove1x1 = (array: lodash.List) => T[]; + type LodashRemove1x2 = (predicate: lodash.ValueIteratee) => T[]; + interface LodashRepeat { + (n: number): LodashRepeat1x1; + (n: lodash.__, string: string): LodashRepeat1x2; + (n: number, string: string): string; + } + type LodashRepeat1x1 = (string: string) => string; + type LodashRepeat1x2 = (n: number) => string; + interface LodashReplace { + (pattern: RegExp | string): LodashReplace1x1; + (pattern: lodash.__, replacement: lodash.ReplaceFunction | string): LodashReplace1x2; + (pattern: RegExp | string, replacement: lodash.ReplaceFunction | string): LodashReplace1x3; + (pattern: lodash.__, replacement: lodash.__, string: string): LodashReplace1x4; + (pattern: RegExp | string, replacement: lodash.__, string: string): LodashReplace1x5; + (pattern: lodash.__, replacement: lodash.ReplaceFunction | string, string: string): LodashReplace1x6; + (pattern: RegExp | string, replacement: lodash.ReplaceFunction | string, string: string): string; + } + interface LodashReplace1x1 { + (replacement: lodash.ReplaceFunction | string): LodashReplace1x3; + (replacement: lodash.__, string: string): LodashReplace1x5; + (replacement: lodash.ReplaceFunction | string, string: string): string; + } + interface LodashReplace1x2 { + (pattern: RegExp | string): LodashReplace1x3; + (pattern: lodash.__, string: string): LodashReplace1x6; + (pattern: RegExp | string, string: string): string; + } + type LodashReplace1x3 = (string: string) => string; + interface LodashReplace1x4 { + (pattern: RegExp | string): LodashReplace1x5; + (pattern: lodash.__, replacement: lodash.ReplaceFunction | string): LodashReplace1x6; + (pattern: RegExp | string, replacement: lodash.ReplaceFunction | string): string; + } + type LodashReplace1x5 = (replacement: lodash.ReplaceFunction | string) => string; + type LodashReplace1x6 = (pattern: RegExp | string) => string; + type LodashRest = (func: (...args: any[]) => any) => (...args: any[]) => any; + interface LodashRestFrom { + (start: number): LodashRestFrom1x1; + (start: lodash.__, func: (...args: any[]) => any): LodashRestFrom1x2; + (start: number, func: (...args: any[]) => any): (...args: any[]) => any; + } + type LodashRestFrom1x1 = (func: (...args: any[]) => any) => (...args: any[]) => any; + type LodashRestFrom1x2 = (start: number) => (...args: any[]) => any; + interface LodashResult { + (path: lodash.PropertyPath): LodashResult1x1; + (path: lodash.__, object: any): LodashResult1x2; + (path: lodash.PropertyPath, object: any): TResult; + } + type LodashResult1x1 = (object: any) => TResult; + type LodashResult1x2 = (path: lodash.PropertyPath) => TResult; + type LodashReverse = >(array: TList) => TList; + type LodashRound = (n: number) => number; + type LodashRunInContext = (context: object) => lodash.LoDashStatic; + interface LodashSample { + (collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): T | undefined; + (collection: T | null | undefined): T[keyof T] | undefined; + } + interface LodashSampleSize { + (n: number): LodashSampleSize1x1; + (n: lodash.__, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): LodashSampleSize1x2; + (n: number, collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): T[]; + (n: lodash.__, collection: T | null | undefined): LodashSampleSize2x2; + (n: number, collection: T | null | undefined): Array; + } + interface LodashSampleSize1x1 { + (collection: lodash.Dictionary | lodash.NumericDictionary | null | undefined): T[]; + (collection: T | null | undefined): Array; + } + type LodashSampleSize1x2 = (n: number) => T[]; + type LodashSampleSize2x2 = (n: number) => Array; + interface LodashSetWith { + (customizer: lodash.SetWithCustomizer): LodashSetWith1x1; + (customizer: lodash.__, path: lodash.PropertyPath): LodashSetWith1x2; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath): LodashSetWith1x3; + (customizer: lodash.__, path: lodash.__, value: any): LodashSetWith1x4; + (customizer: lodash.SetWithCustomizer, path: lodash.__, value: any): LodashSetWith1x5; + (customizer: lodash.__, path: lodash.PropertyPath, value: any): LodashSetWith1x6; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath, value: any): LodashSetWith1x7; + (customizer: lodash.__, path: lodash.__, value: lodash.__, object: T): LodashSetWith1x8; + (customizer: lodash.SetWithCustomizer, path: lodash.__, value: lodash.__, object: T): LodashSetWith1x9; + (customizer: lodash.__, path: lodash.PropertyPath, value: lodash.__, object: T): LodashSetWith1x10; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath, value: lodash.__, object: T): LodashSetWith1x11; + (customizer: lodash.__, path: lodash.__, value: any, object: T): LodashSetWith1x12; + (customizer: lodash.SetWithCustomizer, path: lodash.__, value: any, object: T): LodashSetWith1x13; + (customizer: lodash.__, path: lodash.PropertyPath, value: any, object: T): LodashSetWith1x14; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath, value: any, object: T): T; + } + interface LodashSetWith1x1 { + (path: lodash.PropertyPath): LodashSetWith1x3; + (path: lodash.__, value: any): LodashSetWith1x5; + (path: lodash.PropertyPath, value: any): LodashSetWith1x7; + (path: lodash.__, value: lodash.__, object: T): LodashSetWith1x9; + (path: lodash.PropertyPath, value: lodash.__, object: T): LodashSetWith1x11; + (path: lodash.__, value: any, object: T): LodashSetWith1x13; + (path: lodash.PropertyPath, value: any, object: T): T; + } + interface LodashSetWith1x2 { + (customizer: lodash.SetWithCustomizer): LodashSetWith1x3; + (customizer: lodash.__, value: any): LodashSetWith1x6; + (customizer: lodash.SetWithCustomizer, value: any): LodashSetWith1x7; + (customizer: lodash.__, value: lodash.__, object: T): LodashSetWith1x10; + (customizer: lodash.SetWithCustomizer, value: lodash.__, object: T): LodashSetWith1x11; + (customizer: lodash.__, value: any, object: T): LodashSetWith1x14; + (customizer: lodash.SetWithCustomizer, value: any, object: T): T; + } + interface LodashSetWith1x3 { + (value: any): LodashSetWith1x7; + (value: lodash.__, object: T): LodashSetWith1x11; + (value: any, object: T): T; + } + interface LodashSetWith1x4 { + (customizer: lodash.SetWithCustomizer): LodashSetWith1x5; + (customizer: lodash.__, path: lodash.PropertyPath): LodashSetWith1x6; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath): LodashSetWith1x7; + (customizer: lodash.__, path: lodash.__, object: T): LodashSetWith1x12; + (customizer: lodash.SetWithCustomizer, path: lodash.__, object: T): LodashSetWith1x13; + (customizer: lodash.__, path: lodash.PropertyPath, object: T): LodashSetWith1x14; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath, object: T): T; + } + interface LodashSetWith1x5 { + (path: lodash.PropertyPath): LodashSetWith1x7; + (path: lodash.__, object: T): LodashSetWith1x13; + (path: lodash.PropertyPath, object: T): T; + } + interface LodashSetWith1x6 { + (customizer: lodash.SetWithCustomizer): LodashSetWith1x7; + (customizer: lodash.__, object: T): LodashSetWith1x14; + (customizer: lodash.SetWithCustomizer, object: T): T; + } + type LodashSetWith1x7 = (object: T) => T; + interface LodashSetWith1x8 { + (customizer: lodash.SetWithCustomizer): LodashSetWith1x9; + (customizer: lodash.__, path: lodash.PropertyPath): LodashSetWith1x10; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath): LodashSetWith1x11; + (customizer: lodash.__, path: lodash.__, value: any): LodashSetWith1x12; + (customizer: lodash.SetWithCustomizer, path: lodash.__, value: any): LodashSetWith1x13; + (customizer: lodash.__, path: lodash.PropertyPath, value: any): LodashSetWith1x14; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath, value: any): T; + } + interface LodashSetWith1x9 { + (path: lodash.PropertyPath): LodashSetWith1x11; + (path: lodash.__, value: any): LodashSetWith1x13; + (path: lodash.PropertyPath, value: any): T; + } + interface LodashSetWith1x10 { + (customizer: lodash.SetWithCustomizer): LodashSetWith1x11; + (customizer: lodash.__, value: any): LodashSetWith1x14; + (customizer: lodash.SetWithCustomizer, value: any): T; + } + type LodashSetWith1x11 = (value: any) => T; + interface LodashSetWith1x12 { + (customizer: lodash.SetWithCustomizer): LodashSetWith1x13; + (customizer: lodash.__, path: lodash.PropertyPath): LodashSetWith1x14; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath): T; + } + type LodashSetWith1x13 = (path: lodash.PropertyPath) => T; + type LodashSetWith1x14 = (customizer: lodash.SetWithCustomizer) => T; + interface LodashShuffle { + (collection: lodash.List | null | undefined): T[]; + (collection: T | null | undefined): Array; + } + type LodashSize = (collection: object | string | null | undefined) => number; + interface LodashSlice { + (start: number): LodashSlice1x1; + (start: lodash.__, end: number): LodashSlice1x2; + (start: number, end: number): LodashSlice1x3; + (start: lodash.__, end: lodash.__, array: lodash.List | null | undefined): LodashSlice1x4; + (start: number, end: lodash.__, array: lodash.List | null | undefined): LodashSlice1x5; + (start: lodash.__, end: number, array: lodash.List | null | undefined): LodashSlice1x6; + (start: number, end: number, array: lodash.List | null | undefined): T[]; + } + interface LodashSlice1x1 { + (end: number): LodashSlice1x3; + (end: lodash.__, array: lodash.List | null | undefined): LodashSlice1x5; + (end: number, array: lodash.List | null | undefined): T[]; + } + interface LodashSlice1x2 { + (start: number): LodashSlice1x3; + (start: lodash.__, array: lodash.List | null | undefined): LodashSlice1x6; + (start: number, array: lodash.List | null | undefined): T[]; + } + type LodashSlice1x3 = (array: lodash.List | null | undefined) => T[]; + interface LodashSlice1x4 { + (start: number): LodashSlice1x5; + (start: lodash.__, end: number): LodashSlice1x6; + (start: number, end: number): T[]; + } + type LodashSlice1x5 = (end: number) => T[]; + type LodashSlice1x6 = (start: number) => T[]; + type LodashSnakeCase = (string: string) => string; + interface LodashSortBy { + (iteratees: lodash.Many>): LodashSortBy1x1; + (iteratees: lodash.__, collection: lodash.List | null | undefined): LodashSortBy1x2; + (iteratees: lodash.Many>, collection: lodash.List | null | undefined): T[]; + (iteratees: lodash.__, collection: T | null | undefined): LodashSortBy2x2; + (iteratees: lodash.Many>, collection: T | null | undefined): Array; + } + type LodashSortBy1x1 = (collection: lodash.List | object | null | undefined) => T[]; + type LodashSortBy1x2 = (iteratees: lodash.Many>) => T[]; + type LodashSortBy2x2 = (iteratees: lodash.Many>) => Array; + interface LodashSortedIndex { + (value: T): LodashSortedIndex1x1; + (value: lodash.__, array: lodash.List | null | undefined): LodashSortedIndex1x2; + (value: T, array: lodash.List | null | undefined): number; + } + type LodashSortedIndex1x1 = (array: lodash.List | null | undefined) => number; + type LodashSortedIndex1x2 = (value: T) => number; + interface LodashSortedIndexBy { + (iteratee: lodash.ValueIteratee): LodashSortedIndexBy1x1; + (iteratee: lodash.__, value: T): LodashSortedIndexBy1x2; + (iteratee: lodash.ValueIteratee, value: T): LodashSortedIndexBy1x3; + (iteratee: lodash.__, value: lodash.__, array: lodash.List | null | undefined): LodashSortedIndexBy1x4; + (iteratee: lodash.ValueIteratee, value: lodash.__, array: lodash.List | null | undefined): LodashSortedIndexBy1x5; + (iteratee: lodash.__, value: T, array: lodash.List | null | undefined): LodashSortedIndexBy1x6; + (iteratee: lodash.ValueIteratee, value: T, array: lodash.List | null | undefined): number; + } + interface LodashSortedIndexBy1x1 { + (value: T): LodashSortedIndexBy1x3; + (value: lodash.__, array: lodash.List | null | undefined): LodashSortedIndexBy1x5; + (value: T, array: lodash.List | null | undefined): number; + } + interface LodashSortedIndexBy1x2 { + (iteratee: lodash.ValueIteratee): LodashSortedIndexBy1x3; + (iteratee: lodash.__, array: lodash.List | null | undefined): LodashSortedIndexBy1x6; + (iteratee: lodash.ValueIteratee, array: lodash.List | null | undefined): number; + } + type LodashSortedIndexBy1x3 = (array: lodash.List | null | undefined) => number; + interface LodashSortedIndexBy1x4 { + (iteratee: lodash.ValueIteratee): LodashSortedIndexBy1x5; + (iteratee: lodash.__, value: T): LodashSortedIndexBy1x6; + (iteratee: lodash.ValueIteratee, value: T): number; + } + type LodashSortedIndexBy1x5 = (value: T) => number; + type LodashSortedIndexBy1x6 = (iteratee: lodash.ValueIteratee) => number; + interface LodashSortedIndexOf { + (value: T): LodashSortedIndexOf1x1; + (value: lodash.__, array: lodash.List | null | undefined): LodashSortedIndexOf1x2; + (value: T, array: lodash.List | null | undefined): number; + } + type LodashSortedIndexOf1x1 = (array: lodash.List | null | undefined) => number; + type LodashSortedIndexOf1x2 = (value: T) => number; + interface LodashSortedLastIndex { + (value: T): LodashSortedLastIndex1x1; + (value: lodash.__, array: lodash.List | null | undefined): LodashSortedLastIndex1x2; + (value: T, array: lodash.List | null | undefined): number; + } + type LodashSortedLastIndex1x1 = (array: lodash.List | null | undefined) => number; + type LodashSortedLastIndex1x2 = (value: T) => number; + interface LodashSortedLastIndexBy { + (iteratee: lodash.ValueIteratee): LodashSortedLastIndexBy1x1; + (iteratee: lodash.__, value: T): LodashSortedLastIndexBy1x2; + (iteratee: lodash.ValueIteratee, value: T): LodashSortedLastIndexBy1x3; + (iteratee: lodash.__, value: lodash.__, array: lodash.List | null | undefined): LodashSortedLastIndexBy1x4; + (iteratee: lodash.ValueIteratee, value: lodash.__, array: lodash.List | null | undefined): LodashSortedLastIndexBy1x5; + (iteratee: lodash.__, value: T, array: lodash.List | null | undefined): LodashSortedLastIndexBy1x6; + (iteratee: lodash.ValueIteratee, value: T, array: lodash.List | null | undefined): number; + } + interface LodashSortedLastIndexBy1x1 { + (value: T): LodashSortedLastIndexBy1x3; + (value: lodash.__, array: lodash.List | null | undefined): LodashSortedLastIndexBy1x5; + (value: T, array: lodash.List | null | undefined): number; + } + interface LodashSortedLastIndexBy1x2 { + (iteratee: lodash.ValueIteratee): LodashSortedLastIndexBy1x3; + (iteratee: lodash.__, array: lodash.List | null | undefined): LodashSortedLastIndexBy1x6; + (iteratee: lodash.ValueIteratee, array: lodash.List | null | undefined): number; + } + type LodashSortedLastIndexBy1x3 = (array: lodash.List | null | undefined) => number; + interface LodashSortedLastIndexBy1x4 { + (iteratee: lodash.ValueIteratee): LodashSortedLastIndexBy1x5; + (iteratee: lodash.__, value: T): LodashSortedLastIndexBy1x6; + (iteratee: lodash.ValueIteratee, value: T): number; + } + type LodashSortedLastIndexBy1x5 = (value: T) => number; + type LodashSortedLastIndexBy1x6 = (iteratee: lodash.ValueIteratee) => number; + interface LodashSortedLastIndexOf { + (value: T): LodashSortedLastIndexOf1x1; + (value: lodash.__, array: lodash.List | null | undefined): LodashSortedLastIndexOf1x2; + (value: T, array: lodash.List | null | undefined): number; + } + type LodashSortedLastIndexOf1x1 = (array: lodash.List | null | undefined) => number; + type LodashSortedLastIndexOf1x2 = (value: T) => number; + type LodashSortedUniq = (array: lodash.List | null | undefined) => T[]; + interface LodashSortedUniqBy { + (iteratee: lodash.ValueIteratee): LodashSortedUniqBy1x1; + (iteratee: lodash.__, array: lodash.List | null | undefined): LodashSortedUniqBy1x2; + (iteratee: lodash.ValueIteratee, array: lodash.List | null | undefined): T[]; + } + type LodashSortedUniqBy1x1 = (array: lodash.List | null | undefined) => T[]; + type LodashSortedUniqBy1x2 = (iteratee: lodash.ValueIteratee) => T[]; + interface LodashSplit { + (separator: RegExp | string): LodashSplit1x1; + (separator: lodash.__, string: string): LodashSplit1x2; + (separator: RegExp | string, string: string): string[]; + } + type LodashSplit1x1 = (string: string) => string[]; + type LodashSplit1x2 = (separator: RegExp | string) => string[]; + type LodashSpread = (func: (...args: any[]) => TResult) => (...args: any[]) => TResult; + interface LodashSpreadFrom { + (start: number): LodashSpreadFrom1x1; + (start: lodash.__, func: (...args: any[]) => TResult): LodashSpreadFrom1x2; + (start: number, func: (...args: any[]) => TResult): (...args: any[]) => TResult; + } + type LodashSpreadFrom1x1 = (func: (...args: any[]) => TResult) => (...args: any[]) => TResult; + type LodashSpreadFrom1x2 = (start: number) => (...args: any[]) => TResult; + type LodashStartCase = (string: string) => string; + interface LodashStartsWith { + (target: string): LodashStartsWith1x1; + (target: lodash.__, string: string): LodashStartsWith1x2; + (target: string, string: string): boolean; + } + type LodashStartsWith1x1 = (string: string) => boolean; + type LodashStartsWith1x2 = (target: string) => boolean; + type LodashStubArray = () => any[]; + type LodashStubObject = () => any; + type LodashStubString = () => string; + type LodashStubTrue = () => true; + interface LodashSubtract { + (minuend: number): LodashSubtract1x1; + (minuend: lodash.__, subtrahend: number): LodashSubtract1x2; + (minuend: number, subtrahend: number): number; + } + type LodashSubtract1x1 = (subtrahend: number) => number; + type LodashSubtract1x2 = (minuend: number) => number; + type LodashSum = (collection: lodash.List | null | undefined) => number; + interface LodashSumBy { + (iteratee: ((value: T) => number) | string): LodashSumBy1x1; + (iteratee: lodash.__, collection: lodash.List | null | undefined): LodashSumBy1x2; + (iteratee: ((value: T) => number) | string, collection: lodash.List | null | undefined): number; + } + type LodashSumBy1x1 = (collection: lodash.List | null | undefined) => number; + type LodashSumBy1x2 = (iteratee: ((value: T) => number) | string) => number; + interface LodashXor { + (arrays2: lodash.List | null | undefined): LodashXor1x1; + (arrays2: lodash.__, arrays: lodash.List | null | undefined): LodashXor1x2; + (arrays2: lodash.List | null | undefined, arrays: lodash.List | null | undefined): T[]; + } + type LodashXor1x1 = (arrays: lodash.List | null | undefined) => T[]; + type LodashXor1x2 = (arrays2: lodash.List | null | undefined) => T[]; + interface LodashXorBy { + (iteratee: lodash.ValueIteratee): LodashXorBy1x1; + (iteratee: lodash.__, arrays: lodash.List | null | undefined): LodashXorBy1x2; + (iteratee: lodash.ValueIteratee, arrays: lodash.List | null | undefined): LodashXorBy1x3; + (iteratee: lodash.__, arrays: lodash.__, arrays2: lodash.List | null | undefined): LodashXorBy1x4; + (iteratee: lodash.ValueIteratee, arrays: lodash.__, arrays2: lodash.List | null | undefined): LodashXorBy1x5; + (iteratee: lodash.__, arrays: lodash.List | null | undefined, arrays2: lodash.List | null | undefined): LodashXorBy1x6; + (iteratee: lodash.ValueIteratee, arrays: lodash.List | null | undefined, arrays2: lodash.List | null | undefined): T[]; + } + interface LodashXorBy1x1 { + (arrays: lodash.List | null | undefined): LodashXorBy1x3; + (arrays: lodash.__, arrays2: lodash.List | null | undefined): LodashXorBy1x5; + (arrays: lodash.List | null | undefined, arrays2: lodash.List | null | undefined): T[]; + } + interface LodashXorBy1x2 { + (iteratee: lodash.ValueIteratee): LodashXorBy1x3; + (iteratee: lodash.__, arrays2: lodash.List | null | undefined): LodashXorBy1x6; + (iteratee: lodash.ValueIteratee, arrays2: lodash.List | null | undefined): T[]; + } + type LodashXorBy1x3 = (arrays2: lodash.List | null | undefined) => T[]; + interface LodashXorBy1x4 { + (iteratee: lodash.ValueIteratee): LodashXorBy1x5; + (iteratee: lodash.__, arrays: lodash.List | null | undefined): LodashXorBy1x6; + (iteratee: lodash.ValueIteratee, arrays: lodash.List | null | undefined): T[]; + } + type LodashXorBy1x5 = (arrays: lodash.List | null | undefined) => T[]; + type LodashXorBy1x6 = (iteratee: lodash.ValueIteratee) => T[]; + interface LodashXorWith { + (comparator: lodash.Comparator): LodashXorWith1x1; + (comparator: lodash.__, arrays: lodash.List | null | undefined): LodashXorWith1x2; + (comparator: lodash.Comparator, arrays: lodash.List | null | undefined): LodashXorWith1x3; + (comparator: lodash.__, arrays: lodash.__, arrays2: lodash.List | null | undefined): LodashXorWith1x4; + (comparator: lodash.Comparator, arrays: lodash.__, arrays2: lodash.List | null | undefined): LodashXorWith1x5; + (comparator: lodash.__, arrays: lodash.List | null | undefined, arrays2: lodash.List | null | undefined): LodashXorWith1x6; + (comparator: lodash.Comparator, arrays: lodash.List | null | undefined, arrays2: lodash.List | null | undefined): T[]; + } + interface LodashXorWith1x1 { + (arrays: lodash.List | null | undefined): LodashXorWith1x3; + (arrays: lodash.__, arrays2: lodash.List | null | undefined): LodashXorWith1x5; + (arrays: lodash.List | null | undefined, arrays2: lodash.List | null | undefined): T[]; + } + interface LodashXorWith1x2 { + (comparator: lodash.Comparator): LodashXorWith1x3; + (comparator: lodash.__, arrays2: lodash.List | null | undefined): LodashXorWith1x6; + (comparator: lodash.Comparator, arrays2: lodash.List | null | undefined): T[]; + } + type LodashXorWith1x3 = (arrays2: lodash.List | null | undefined) => T[]; + interface LodashXorWith1x4 { + (comparator: lodash.Comparator): LodashXorWith1x5; + (comparator: lodash.__, arrays: lodash.List | null | undefined): LodashXorWith1x6; + (comparator: lodash.Comparator, arrays: lodash.List | null | undefined): T[]; + } + type LodashXorWith1x5 = (arrays: lodash.List | null | undefined) => T[]; + type LodashXorWith1x6 = (comparator: lodash.Comparator) => T[]; + type LodashTail = (array: lodash.List | null | undefined) => T[]; + interface LodashTake { + (n: number): LodashTake1x1; + (n: lodash.__, array: lodash.List | null | undefined): LodashTake1x2; + (n: number, array: lodash.List | null | undefined): T[]; + } + type LodashTake1x1 = (array: lodash.List | null | undefined) => T[]; + type LodashTake1x2 = (n: number) => T[]; + interface LodashTakeRight { + (n: number): LodashTakeRight1x1; + (n: lodash.__, array: lodash.List | null | undefined): LodashTakeRight1x2; + (n: number, array: lodash.List | null | undefined): T[]; + } + type LodashTakeRight1x1 = (array: lodash.List | null | undefined) => T[]; + type LodashTakeRight1x2 = (n: number) => T[]; + interface LodashTakeRightWhile { + (predicate: lodash.ValueIteratee): LodashTakeRightWhile1x1; + (predicate: lodash.__, array: lodash.List | null | undefined): LodashTakeRightWhile1x2; + (predicate: lodash.ValueIteratee, array: lodash.List | null | undefined): T[]; + } + type LodashTakeRightWhile1x1 = (array: lodash.List | null | undefined) => T[]; + type LodashTakeRightWhile1x2 = (predicate: lodash.ValueIteratee) => T[]; + interface LodashTakeWhile { + (predicate: lodash.ValueIteratee): LodashTakeWhile1x1; + (predicate: lodash.__, array: lodash.List | null | undefined): LodashTakeWhile1x2; + (predicate: lodash.ValueIteratee, array: lodash.List | null | undefined): T[]; + } + type LodashTakeWhile1x1 = (array: lodash.List | null | undefined) => T[]; + type LodashTakeWhile1x2 = (predicate: lodash.ValueIteratee) => T[]; + interface LodashTap { + (interceptor: (value: T) => void): LodashTap1x1; + (interceptor: lodash.__, value: T): LodashTap1x2; + (interceptor: (value: T) => void, value: T): T; + } + type LodashTap1x1 = (value: T) => T; + type LodashTap1x2 = (interceptor: (value: T) => void) => T; + type LodashTemplate = (string: string) => lodash.TemplateExecutor; + interface LodashThrottle { + (wait: number): LodashThrottle1x1; + any>(wait: lodash.__, func: T): LodashThrottle1x2; + any>(wait: number, func: T): T & lodash.Cancelable; + } + type LodashThrottle1x1 = any>(func: T) => T & lodash.Cancelable; + type LodashThrottle1x2 = (wait: number) => T & lodash.Cancelable; + interface LodashThru { + (interceptor: (value: T) => TResult): LodashThru1x1; + (interceptor: lodash.__, value: T): LodashThru1x2; + (interceptor: (value: T) => TResult, value: T): TResult; + } + type LodashThru1x1 = (value: T) => TResult; + type LodashThru1x2 = (interceptor: (value: T) => TResult) => TResult; + interface LodashTimes { + (iteratee: (num: number) => TResult): LodashTimes1x1; + (iteratee: lodash.__, n: number): LodashTimes1x2; + (iteratee: (num: number) => TResult, n: number): TResult[]; + } + type LodashTimes1x1 = (n: number) => TResult[]; + type LodashTimes1x2 = (iteratee: (num: number) => TResult) => TResult[]; + interface LodashToArray { + (value: lodash.Dictionary | lodash.NumericDictionary | null | undefined): T[]; + (value: T): Array; + (): any[]; + } + type LodashToFinite = (value: any) => number; + type LodashToInteger = (value: any) => number; + type LodashToLength = (value: any) => number; + type LodashToLower = (string: string) => string; + type LodashToNumber = (value: any) => number; + type LodashToPath = (value: any) => string[]; + type LodashToPlainObject = (value: any) => any; + type LodashToSafeInteger = (value: any) => number; + type LodashToString = (value: any) => string; + type LodashToUpper = (string: string) => string; + interface LodashTransform { + (iteratee: lodash.MemoVoidIteratorCapped): LodashTransform1x1; + (iteratee: lodash.__, accumulator: TResult): LodashTransform1x2; + (iteratee: lodash.MemoVoidIteratorCapped, accumulator: TResult): LodashTransform1x3; + (iteratee: lodash.__, accumulator: lodash.__, object: ReadonlyArray): LodashTransform1x4; + (iteratee: lodash.MemoVoidIteratorCapped, accumulator: lodash.__, object: ReadonlyArray): LodashTransform1x5; + (iteratee: lodash.__, accumulator: TResult, object: ReadonlyArray): LodashTransform1x6; + (iteratee: lodash.MemoVoidIteratorCapped, accumulator: TResult, object: ReadonlyArray | lodash.Dictionary): TResult; + (iteratee: lodash.__, accumulator: lodash.__, object: lodash.Dictionary): LodashTransform2x4; + (iteratee: lodash.MemoVoidIteratorCapped, accumulator: lodash.__, object: lodash.Dictionary): LodashTransform2x5; + (iteratee: lodash.__, accumulator: TResult, object: lodash.Dictionary): LodashTransform2x6; + } + interface LodashTransform1x1 { + (accumulator: TResult): LodashTransform1x3; + (accumulator: lodash.__, object: ReadonlyArray): LodashTransform1x5; + (accumulator: TResult, object: ReadonlyArray | lodash.Dictionary): TResult; + (accumulator: lodash.__, object: lodash.Dictionary): LodashTransform2x5; + } + interface LodashTransform1x2 { + (iteratee: lodash.MemoVoidIteratorCapped): LodashTransform1x3; + (iteratee: lodash.__, object: ReadonlyArray): LodashTransform1x6; + (iteratee: lodash.MemoVoidIteratorCapped, object: ReadonlyArray | lodash.Dictionary): TResult; + (iteratee: lodash.__, object: lodash.Dictionary): LodashTransform2x6; + } + type LodashTransform1x3 = (object: ReadonlyArray | lodash.Dictionary) => TResult; + interface LodashTransform1x4 { + (iteratee: lodash.MemoVoidIteratorCapped): LodashTransform1x5; + (iteratee: lodash.__, accumulator: TResult): LodashTransform1x6; + (iteratee: lodash.MemoVoidIteratorCapped, accumulator: TResult): TResult; + } + type LodashTransform1x5 = (accumulator: TResult) => TResult; + type LodashTransform1x6 = (iteratee: lodash.MemoVoidIteratorCapped) => TResult; + interface LodashTransform2x4 { + (iteratee: lodash.MemoVoidIteratorCapped): LodashTransform2x5; + (iteratee: lodash.__, accumulator: TResult): LodashTransform2x6; + (iteratee: lodash.MemoVoidIteratorCapped, accumulator: TResult): TResult; + } + type LodashTransform2x5 = (accumulator: TResult) => TResult; + type LodashTransform2x6 = (iteratee: lodash.MemoVoidIteratorCapped) => TResult; + type LodashTrim = (string: string) => string; + interface LodashTrimChars { + (chars: string): LodashTrimChars1x1; + (chars: lodash.__, string: string): LodashTrimChars1x2; + (chars: string, string: string): string; + } + type LodashTrimChars1x1 = (string: string) => string; + type LodashTrimChars1x2 = (chars: string) => string; + interface LodashTrimCharsEnd { + (chars: string): LodashTrimCharsEnd1x1; + (chars: lodash.__, string: string): LodashTrimCharsEnd1x2; + (chars: string, string: string): string; + } + type LodashTrimCharsEnd1x1 = (string: string) => string; + type LodashTrimCharsEnd1x2 = (chars: string) => string; + interface LodashTrimCharsStart { + (chars: string): LodashTrimCharsStart1x1; + (chars: lodash.__, string: string): LodashTrimCharsStart1x2; + (chars: string, string: string): string; + } + type LodashTrimCharsStart1x1 = (string: string) => string; + type LodashTrimCharsStart1x2 = (chars: string) => string; + type LodashTrimEnd = (string: string) => string; + type LodashTrimStart = (string: string) => string; + interface LodashTruncate { + (options: lodash.TruncateOptions): LodashTruncate1x1; + (options: lodash.__, string: string): LodashTruncate1x2; + (options: lodash.TruncateOptions, string: string): string; + } + type LodashTruncate1x1 = (string: string) => string; + type LodashTruncate1x2 = (options: lodash.TruncateOptions) => string; + type LodashUnapply = (func: (...args: any[]) => any) => (...args: any[]) => any; + type LodashUnary = (func: (arg1: T, ...args: any[]) => TResult) => (arg1: T) => TResult; + type LodashUnescape = (string: string) => string; + interface LodashUnion { + (arrays2: lodash.List | null | undefined): LodashUnion1x1; + (arrays2: lodash.__, arrays: lodash.List | null | undefined): LodashUnion1x2; + (arrays2: lodash.List | null | undefined, arrays: lodash.List | null | undefined): T[]; + } + type LodashUnion1x1 = (arrays: lodash.List | null | undefined) => T[]; + type LodashUnion1x2 = (arrays2: lodash.List | null | undefined) => T[]; + interface LodashUnionBy { + (iteratee: lodash.ValueIteratee): LodashUnionBy1x1; + (iteratee: lodash.__, arrays1: lodash.List | null | undefined): LodashUnionBy1x2; + (iteratee: lodash.ValueIteratee, arrays1: lodash.List | null | undefined): LodashUnionBy1x3; + (iteratee: lodash.__, arrays1: lodash.__, arrays2: lodash.List | null | undefined): LodashUnionBy1x4; + (iteratee: lodash.ValueIteratee, arrays1: lodash.__, arrays2: lodash.List | null | undefined): LodashUnionBy1x5; + (iteratee: lodash.__, arrays1: lodash.List | null | undefined, arrays2: lodash.List | null | undefined): LodashUnionBy1x6; + (iteratee: lodash.ValueIteratee, arrays1: lodash.List | null | undefined, arrays2: lodash.List | null | undefined): T[]; + } + interface LodashUnionBy1x1 { + (arrays1: lodash.List | null | undefined): LodashUnionBy1x3; + (arrays1: lodash.__, arrays2: lodash.List | null | undefined): LodashUnionBy1x5; + (arrays1: lodash.List | null | undefined, arrays2: lodash.List | null | undefined): T[]; + } + interface LodashUnionBy1x2 { + (iteratee: lodash.ValueIteratee): LodashUnionBy1x3; + (iteratee: lodash.__, arrays2: lodash.List | null | undefined): LodashUnionBy1x6; + (iteratee: lodash.ValueIteratee, arrays2: lodash.List | null | undefined): T[]; + } + type LodashUnionBy1x3 = (arrays2: lodash.List | null | undefined) => T[]; + interface LodashUnionBy1x4 { + (iteratee: lodash.ValueIteratee): LodashUnionBy1x5; + (iteratee: lodash.__, arrays1: lodash.List | null | undefined): LodashUnionBy1x6; + (iteratee: lodash.ValueIteratee, arrays1: lodash.List | null | undefined): T[]; + } + type LodashUnionBy1x5 = (arrays1: lodash.List | null | undefined) => T[]; + type LodashUnionBy1x6 = (iteratee: lodash.ValueIteratee) => T[]; + interface LodashUnionWith { + (comparator: lodash.Comparator): LodashUnionWith1x1; + (comparator: lodash.__, arrays: lodash.List | null | undefined): LodashUnionWith1x2; + (comparator: lodash.Comparator, arrays: lodash.List | null | undefined): LodashUnionWith1x3; + (comparator: lodash.__, arrays: lodash.__, arrays2: lodash.List | null | undefined): LodashUnionWith1x4; + (comparator: lodash.Comparator, arrays: lodash.__, arrays2: lodash.List | null | undefined): LodashUnionWith1x5; + (comparator: lodash.__, arrays: lodash.List | null | undefined, arrays2: lodash.List | null | undefined): LodashUnionWith1x6; + (comparator: lodash.Comparator, arrays: lodash.List | null | undefined, arrays2: lodash.List | null | undefined): T[]; + } + interface LodashUnionWith1x1 { + (arrays: lodash.List | null | undefined): LodashUnionWith1x3; + (arrays: lodash.__, arrays2: lodash.List | null | undefined): LodashUnionWith1x5; + (arrays: lodash.List | null | undefined, arrays2: lodash.List | null | undefined): T[]; + } + interface LodashUnionWith1x2 { + (comparator: lodash.Comparator): LodashUnionWith1x3; + (comparator: lodash.__, arrays2: lodash.List | null | undefined): LodashUnionWith1x6; + (comparator: lodash.Comparator, arrays2: lodash.List | null | undefined): T[]; + } + type LodashUnionWith1x3 = (arrays2: lodash.List | null | undefined) => T[]; + interface LodashUnionWith1x4 { + (comparator: lodash.Comparator): LodashUnionWith1x5; + (comparator: lodash.__, arrays: lodash.List | null | undefined): LodashUnionWith1x6; + (comparator: lodash.Comparator, arrays: lodash.List | null | undefined): T[]; + } + type LodashUnionWith1x5 = (arrays: lodash.List | null | undefined) => T[]; + type LodashUnionWith1x6 = (comparator: lodash.Comparator) => T[]; + type LodashUniq = (array: lodash.List | null | undefined) => T[]; + interface LodashUniqBy { + (iteratee: lodash.ValueIteratee): LodashUniqBy1x1; + (iteratee: lodash.__, array: lodash.List | null | undefined): LodashUniqBy1x2; + (iteratee: lodash.ValueIteratee, array: lodash.List | null | undefined): T[]; + } + type LodashUniqBy1x1 = (array: lodash.List | null | undefined) => T[]; + type LodashUniqBy1x2 = (iteratee: lodash.ValueIteratee) => T[]; + type LodashUniqueId = (prefix: string) => string; + interface LodashUniqWith { + (comparator: lodash.Comparator): LodashUniqWith1x1; + (comparator: lodash.__, array: lodash.List | null | undefined): LodashUniqWith1x2; + (comparator: lodash.Comparator, array: lodash.List | null | undefined): T[]; + } + type LodashUniqWith1x1 = (array: lodash.List | null | undefined) => T[]; + type LodashUniqWith1x2 = (comparator: lodash.Comparator) => T[]; + type LodashUnzip = (array: T[][] | lodash.List> | null | undefined) => T[][]; + interface LodashUnzipWith { + (iteratee: (...values: T[]) => TResult): LodashUnzipWith1x1; + (iteratee: lodash.__, array: lodash.List> | null | undefined): LodashUnzipWith1x2; + (iteratee: (...values: T[]) => TResult, array: lodash.List> | null | undefined): TResult[]; + } + type LodashUnzipWith1x1 = (array: lodash.List> | null | undefined) => TResult[]; + type LodashUnzipWith1x2 = (iteratee: (...values: T[]) => TResult) => TResult[]; + interface LodashUpdate { + (path: lodash.PropertyPath): LodashUpdate1x1; + (path: lodash.__, updater: (value: any) => any): LodashUpdate1x2; + (path: lodash.PropertyPath, updater: (value: any) => any): LodashUpdate1x3; + (path: lodash.__, updater: lodash.__, object: object): LodashUpdate1x4; + (path: lodash.PropertyPath, updater: lodash.__, object: object): LodashUpdate1x5; + (path: lodash.__, updater: (value: any) => any, object: object): LodashUpdate1x6; + (path: lodash.PropertyPath, updater: (value: any) => any, object: object): any; + } + interface LodashUpdate1x1 { + (updater: (value: any) => any): LodashUpdate1x3; + (updater: lodash.__, object: object): LodashUpdate1x5; + (updater: (value: any) => any, object: object): any; + } + interface LodashUpdate1x2 { + (path: lodash.PropertyPath): LodashUpdate1x3; + (path: lodash.__, object: object): LodashUpdate1x6; + (path: lodash.PropertyPath, object: object): any; + } + type LodashUpdate1x3 = (object: object) => any; + interface LodashUpdate1x4 { + (path: lodash.PropertyPath): LodashUpdate1x5; + (path: lodash.__, updater: (value: any) => any): LodashUpdate1x6; + (path: lodash.PropertyPath, updater: (value: any) => any): any; + } + type LodashUpdate1x5 = (updater: (value: any) => any) => any; + type LodashUpdate1x6 = (path: lodash.PropertyPath) => any; + interface LodashUpdateWith { + (customizer: lodash.SetWithCustomizer): LodashUpdateWith1x1; + (customizer: lodash.__, path: lodash.PropertyPath): LodashUpdateWith1x2; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath): LodashUpdateWith1x3; + (customizer: lodash.__, path: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x4; + (customizer: lodash.SetWithCustomizer, path: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x5; + (customizer: lodash.__, path: lodash.PropertyPath, updater: (oldValue: any) => any): LodashUpdateWith1x6; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath, updater: (oldValue: any) => any): LodashUpdateWith1x7; + (customizer: lodash.__, path: lodash.__, updater: lodash.__, object: T): LodashUpdateWith1x8; + (customizer: lodash.SetWithCustomizer, path: lodash.__, updater: lodash.__, object: T): LodashUpdateWith1x9; + (customizer: lodash.__, path: lodash.PropertyPath, updater: lodash.__, object: T): LodashUpdateWith1x10; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath, updater: lodash.__, object: T): LodashUpdateWith1x11; + (customizer: lodash.__, path: lodash.__, updater: (oldValue: any) => any, object: T): LodashUpdateWith1x12; + (customizer: lodash.SetWithCustomizer, path: lodash.__, updater: (oldValue: any) => any, object: T): LodashUpdateWith1x13; + (customizer: lodash.__, path: lodash.PropertyPath, updater: (oldValue: any) => any, object: T): LodashUpdateWith1x14; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath, updater: (oldValue: any) => any, object: T): T; + } + interface LodashUpdateWith1x1 { + (path: lodash.PropertyPath): LodashUpdateWith1x3; + (path: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x5; + (path: lodash.PropertyPath, updater: (oldValue: any) => any): LodashUpdateWith1x7; + (path: lodash.__, updater: lodash.__, object: T): LodashUpdateWith1x9; + (path: lodash.PropertyPath, updater: lodash.__, object: T): LodashUpdateWith1x11; + (path: lodash.__, updater: (oldValue: any) => any, object: T): LodashUpdateWith1x13; + (path: lodash.PropertyPath, updater: (oldValue: any) => any, object: T): T; + } + interface LodashUpdateWith1x2 { + (customizer: lodash.SetWithCustomizer): LodashUpdateWith1x3; + (customizer: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x6; + (customizer: lodash.SetWithCustomizer, updater: (oldValue: any) => any): LodashUpdateWith1x7; + (customizer: lodash.__, updater: lodash.__, object: T): LodashUpdateWith1x10; + (customizer: lodash.SetWithCustomizer, updater: lodash.__, object: T): LodashUpdateWith1x11; + (customizer: lodash.__, updater: (oldValue: any) => any, object: T): LodashUpdateWith1x14; + (customizer: lodash.SetWithCustomizer, updater: (oldValue: any) => any, object: T): T; + } + interface LodashUpdateWith1x3 { + (updater: (oldValue: any) => any): LodashUpdateWith1x7; + (updater: lodash.__, object: T): LodashUpdateWith1x11; + (updater: (oldValue: any) => any, object: T): T; + } + interface LodashUpdateWith1x4 { + (customizer: lodash.SetWithCustomizer): LodashUpdateWith1x5; + (customizer: lodash.__, path: lodash.PropertyPath): LodashUpdateWith1x6; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath): LodashUpdateWith1x7; + (customizer: lodash.__, path: lodash.__, object: T): LodashUpdateWith1x12; + (customizer: lodash.SetWithCustomizer, path: lodash.__, object: T): LodashUpdateWith1x13; + (customizer: lodash.__, path: lodash.PropertyPath, object: T): LodashUpdateWith1x14; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath, object: T): T; + } + interface LodashUpdateWith1x5 { + (path: lodash.PropertyPath): LodashUpdateWith1x7; + (path: lodash.__, object: T): LodashUpdateWith1x13; + (path: lodash.PropertyPath, object: T): T; + } + interface LodashUpdateWith1x6 { + (customizer: lodash.SetWithCustomizer): LodashUpdateWith1x7; + (customizer: lodash.__, object: T): LodashUpdateWith1x14; + (customizer: lodash.SetWithCustomizer, object: T): T; + } + type LodashUpdateWith1x7 = (object: T) => T; + interface LodashUpdateWith1x8 { + (customizer: lodash.SetWithCustomizer): LodashUpdateWith1x9; + (customizer: lodash.__, path: lodash.PropertyPath): LodashUpdateWith1x10; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath): LodashUpdateWith1x11; + (customizer: lodash.__, path: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x12; + (customizer: lodash.SetWithCustomizer, path: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x13; + (customizer: lodash.__, path: lodash.PropertyPath, updater: (oldValue: any) => any): LodashUpdateWith1x14; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath, updater: (oldValue: any) => any): T; + } + interface LodashUpdateWith1x9 { + (path: lodash.PropertyPath): LodashUpdateWith1x11; + (path: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x13; + (path: lodash.PropertyPath, updater: (oldValue: any) => any): T; + } + interface LodashUpdateWith1x10 { + (customizer: lodash.SetWithCustomizer): LodashUpdateWith1x11; + (customizer: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x14; + (customizer: lodash.SetWithCustomizer, updater: (oldValue: any) => any): T; + } + type LodashUpdateWith1x11 = (updater: (oldValue: any) => any) => T; + interface LodashUpdateWith1x12 { + (customizer: lodash.SetWithCustomizer): LodashUpdateWith1x13; + (customizer: lodash.__, path: lodash.PropertyPath): LodashUpdateWith1x14; + (customizer: lodash.SetWithCustomizer, path: lodash.PropertyPath): T; + } + type LodashUpdateWith1x13 = (path: lodash.PropertyPath) => T; + type LodashUpdateWith1x14 = (customizer: lodash.SetWithCustomizer) => T; + type LodashUpperCase = (string: string) => string; + type LodashUpperFirst = (string: string) => string; + interface LodashValues { + (object: lodash.Dictionary | lodash.NumericDictionary | lodash.List | null | undefined): T[]; + (object: T | null | undefined): Array; + (object: any): any[]; + } + interface LodashValuesIn { + (object: lodash.Dictionary | lodash.NumericDictionary | lodash.List | null | undefined): T[]; + (object: T | null | undefined): Array; + } + interface LodashWithout { + (values: ReadonlyArray): LodashWithout1x1; + (values: lodash.__, array: lodash.List | null | undefined): LodashWithout1x2; + (values: ReadonlyArray, array: lodash.List | null | undefined): T[]; + } + type LodashWithout1x1 = (array: lodash.List | null | undefined) => T[]; + type LodashWithout1x2 = (values: ReadonlyArray) => T[]; + type LodashWords = (string: string) => string[]; + interface LodashWrap { + (wrapper: (value: T, ...args: TArgs[]) => TResult): LodashWrap1x1; + (wrapper: lodash.__, value: T): LodashWrap1x2; + (wrapper: (value: T, ...args: TArgs[]) => TResult, value: T): (...args: TArgs[]) => TResult; + } + type LodashWrap1x1 = (value: T) => (...args: TArgs[]) => TResult; + type LodashWrap1x2 = (wrapper: (value: T, ...args: TArgs[]) => TResult) => (...args: TArgs[]) => TResult; + interface LodashZip { + (arrays1: lodash.List): LodashZip1x1; + (arrays1: lodash.__, arrays2: lodash.List): LodashZip1x2; + (arrays1: lodash.List, arrays2: lodash.List): Array<[T1 | undefined, T2 | undefined]>; + } + type LodashZip1x1 = (arrays2: lodash.List) => Array<[T1 | undefined, T2 | undefined]>; + type LodashZip1x2 = (arrays1: lodash.List) => Array<[T1 | undefined, T2 | undefined]>; + interface LodashZipAll { + (arrays1: [lodash.List, lodash.List]): Array<[T1 | undefined, T2 | undefined]>; + (arrays1: [lodash.List, lodash.List, lodash.List]): Array<[T1 | undefined, T2 | undefined, T3 | undefined]>; + (arrays1: [lodash.List, lodash.List, lodash.List, lodash.List]): Array<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined]>; + (arrays1: [lodash.List, lodash.List, lodash.List, lodash.List, lodash.List]): Array<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined, T5 | undefined]>; + (arrays: ReadonlyArray | null | undefined>): Array>; + } + interface LodashZipObject { + (props: lodash.List): LodashZipObject1x1; + (props: lodash.__, values: lodash.List): LodashZipObject1x2; + (props: lodash.List, values: lodash.List): lodash.Dictionary; + } + type LodashZipObject1x1 = (values: lodash.List) => lodash.Dictionary; + type LodashZipObject1x2 = (props: lodash.List) => lodash.Dictionary; + interface LodashZipObjectDeep { + (paths: lodash.List): LodashZipObjectDeep1x1; + (paths: lodash.__, values: lodash.List): LodashZipObjectDeep1x2; + (paths: lodash.List, values: lodash.List): object; + } + type LodashZipObjectDeep1x1 = (values: lodash.List) => object; + type LodashZipObjectDeep1x2 = (paths: lodash.List) => object; + interface LodashZipWith { + (iteratee: (value1: T1, value2: T2) => TResult): LodashZipWith1x1; + (iteratee: lodash.__, arrays1: lodash.List): LodashZipWith1x2; + (iteratee: (value1: T1, value2: T2) => TResult, arrays1: lodash.List): LodashZipWith1x3; + (iteratee: lodash.__, arrays1: lodash.__, arrays2: lodash.List): LodashZipWith1x4; + (iteratee: (value1: T1, value2: T2) => TResult, arrays1: lodash.__, arrays2: lodash.List): LodashZipWith1x5; + (iteratee: lodash.__, arrays1: lodash.List, arrays2: lodash.List): LodashZipWith1x6; + (iteratee: (value1: T1, value2: T2) => TResult, arrays1: lodash.List, arrays2: lodash.List): TResult[]; + } + interface LodashZipWith1x1 { + (arrays1: lodash.List): LodashZipWith1x3; + (arrays1: lodash.__, arrays2: lodash.List): LodashZipWith1x5; + (arrays1: lodash.List, arrays2: lodash.List): TResult[]; + } + interface LodashZipWith1x2 { + (iteratee: (value1: T1, value2: T2) => TResult): LodashZipWith1x3; + (iteratee: lodash.__, arrays2: lodash.List): LodashZipWith1x6; + (iteratee: (value1: T1, value2: T2) => TResult, arrays2: lodash.List): TResult[]; + } + type LodashZipWith1x3 = (arrays2: lodash.List) => TResult[]; + interface LodashZipWith1x4 { + (iteratee: (value1: T1, value2: T2) => TResult): LodashZipWith1x5; + (iteratee: lodash.__, arrays1: lodash.List): LodashZipWith1x6; + (iteratee: (value1: T1, value2: T2) => TResult, arrays1: lodash.List): TResult[]; + } + type LodashZipWith1x5 = (arrays1: lodash.List) => TResult[]; + type LodashZipWith1x6 = (iteratee: (value1: T1, value2: T2) => TResult) => TResult[]; + + interface LoDashFp { + add: LodashAdd; + after: LodashAfter; + all: LodashEvery; + allPass: LodashOverEvery; + always: LodashConstant; + any: LodashSome; + anyPass: LodashOverSome; + apply: LodashApply; + ary: LodashAry; + assign: LodashAssign; + assignAll: LodashAssignAll; + assignAllWith: LodashAssignAllWith; + assignIn: LodashAssignIn; + assignInAll: LodashAssignInAll; + assignInAllWith: LodashAssignInAllWith; + assignInWith: LodashAssignInWith; + assignWith: LodashAssignWith; + assoc: LodashSet; + assocPath: LodashSet; + at: LodashAt; + attempt: LodashAttempt; + before: LodashBefore; + bind: LodashBind; + bindAll: LodashBindAll; + bindKey: LodashBindKey; + camelCase: LodashCamelCase; + capitalize: LodashCapitalize; + castArray: LodashCastArray; + ceil: LodashCeil; + chunk: LodashChunk; + clamp: LodashClamp; + clone: LodashClone; + cloneDeep: LodashCloneDeep; + cloneDeepWith: LodashCloneDeepWith; + cloneWith: LodashCloneWith; + compact: LodashCompact; + complement: LodashNegate; + compose: LodashFlowRight; + concat: LodashConcat; + cond: LodashCond; + conforms: LodashConformsTo; + conformsTo: LodashConformsTo; + constant: LodashConstant; + contains: LodashContains; + countBy: LodashCountBy; + create: LodashCreate; + curry: LodashCurry; + curryN: LodashCurryN; + curryRight: LodashCurryRight; + curryRightN: LodashCurryRightN; + debounce: LodashDebounce; + deburr: LodashDeburr; + defaults: LodashDefaults; + defaultsAll: LodashDefaultsAll; + defaultsDeep: LodashDefaultsDeep; + defaultsDeepAll: LodashDefaultsDeepAll; + defaultTo: LodashDefaultTo; + defer: LodashDefer; + delay: LodashDelay; + difference: LodashDifference; + differenceBy: LodashDifferenceBy; + differenceWith: LodashDifferenceWith; + dissoc: LodashUnset; + dissocPath: LodashUnset; + divide: LodashDivide; + drop: LodashDrop; + dropLast: LodashDropRight; + dropLastWhile: LodashDropRightWhile; + dropRight: LodashDropRight; + dropRightWhile: LodashDropRightWhile; + dropWhile: LodashDropWhile; + each: LodashForEach; + eachRight: LodashForEachRight; + endsWith: LodashEndsWith; + entries: LodashToPairs; + entriesIn: LodashToPairsIn; + eq: LodashEq; + equals: LodashIsEqual; + escape: LodashEscape; + escapeRegExp: LodashEscapeRegExp; + every: LodashEvery; + extend: LodashExtend; + extendAll: LodashExtendAll; + extendAllWith: LodashExtendAllWith; + extendWith: LodashExtendWith; + F: LodashStubFalse; + fill: LodashFill; + filter: LodashFilter; + find: LodashFind; + findFrom: LodashFindFrom; + findIndex: LodashFindIndex; + findIndexFrom: LodashFindIndexFrom; + findKey: LodashFindKey; + findLast: LodashFindLast; + findLastFrom: LodashFindLastFrom; + findLastIndex: LodashFindLastIndex; + findLastIndexFrom: LodashFindLastIndexFrom; + findLastKey: LodashFindLastKey; + first: LodashHead; + flatMap: LodashFlatMap; + flatMapDeep: LodashFlatMapDeep; + flatMapDepth: LodashFlatMapDepth; + flatten: LodashFlatten; + flattenDeep: LodashFlattenDeep; + flattenDepth: LodashFlattenDepth; + flip: LodashFlip; + floor: LodashFloor; + flow: LodashFlow; + flowRight: LodashFlowRight; + forEach: LodashForEach; + forEachRight: LodashForEachRight; + forIn: LodashForIn; + forInRight: LodashForInRight; + forOwn: LodashForOwn; + forOwnRight: LodashForOwnRight; + fromPairs: LodashFromPairs; + functions: LodashFunctions; + functionsIn: LodashFunctionsIn; + get: LodashGet; + getOr: LodashGetOr; + groupBy: LodashGroupBy; + gt: LodashGt; + gte: LodashGte; + has: LodashHas; + hasIn: LodashHasIn; + head: LodashHead; + identical: LodashEq; + identity: LodashIdentity; + includes: LodashIncludes; + includesFrom: LodashIncludesFrom; + indexBy: LodashKeyBy; + indexOf: LodashIndexOf; + indexOfFrom: LodashIndexOfFrom; + init: LodashInitial; + initial: LodashInitial; + inRange: LodashInRange; + intersection: LodashIntersection; + intersectionBy: LodashIntersectionBy; + intersectionWith: LodashIntersectionWith; + invert: LodashInvert; + invertBy: LodashInvertBy; + invertObj: LodashInvert; + invoke: LodashInvoke; + invokeArgs: LodashInvokeArgs; + invokeArgsMap: LodashInvokeArgsMap; + invokeMap: LodashInvokeMap; + isArguments: LodashIsArguments; + isArray: LodashIsArray; + isArrayBuffer: LodashIsArrayBuffer; + isArrayLike: LodashIsArrayLike; + isArrayLikeObject: LodashIsArrayLikeObject; + isBoolean: LodashIsBoolean; + isBuffer: LodashIsBuffer; + isDate: LodashIsDate; + isElement: LodashIsElement; + isEmpty: LodashIsEmpty; + isEqual: LodashIsEqual; + isEqualWith: LodashIsEqualWith; + isError: LodashIsError; + isFinite: LodashIsFinite; + isFunction: LodashIsFunction; + isInteger: LodashIsInteger; + isLength: LodashIsLength; + isMap: LodashIsMap; + isMatch: LodashIsMatch; + isMatchWith: LodashIsMatchWith; + isNaN: LodashIsNaN; + isNative: LodashIsNative; + isNil: LodashIsNil; + isNull: LodashIsNull; + isNumber: LodashIsNumber; + isObject: LodashIsObject; + isObjectLike: LodashIsObjectLike; + isPlainObject: LodashIsPlainObject; + isRegExp: LodashIsRegExp; + isSafeInteger: LodashIsSafeInteger; + isSet: LodashIsSet; + isString: LodashIsString; + isSymbol: LodashIsSymbol; + isTypedArray: LodashIsTypedArray; + isUndefined: LodashIsUndefined; + isWeakMap: LodashIsWeakMap; + isWeakSet: LodashIsWeakSet; + iteratee: LodashIteratee; + join: LodashJoin; + juxt: LodashOver; + kebabCase: LodashKebabCase; + keyBy: LodashKeyBy; + keys: LodashKeys; + keysIn: LodashKeysIn; + last: LodashLast; + lastIndexOf: LodashLastIndexOf; + lastIndexOfFrom: LodashLastIndexOfFrom; + lowerCase: LodashLowerCase; + lowerFirst: LodashLowerFirst; + lt: LodashLt; + lte: LodashLte; + map: LodashMap; + mapKeys: LodashMapKeys; + mapValues: LodashMapValues; + matches: LodashIsMatch; + matchesProperty: LodashMatchesProperty; + max: LodashMax; + maxBy: LodashMaxBy; + mean: LodashMean; + meanBy: LodashMeanBy; + memoize: LodashMemoize; + merge: LodashMerge; + mergeAll: LodashMergeAll; + mergeAllWith: LodashMergeAllWith; + mergeWith: LodashMergeWith; + method: LodashMethod; + methodOf: LodashMethodOf; + min: LodashMin; + minBy: LodashMinBy; + multiply: LodashMultiply; + nAry: LodashAry; + negate: LodashNegate; + noConflict: LodashNoConflict; + noop: LodashNoop; + now: LodashNow; + nth: LodashNth; + nthArg: LodashNthArg; + omit: LodashOmit; + omitAll: LodashOmit; + omitBy: LodashOmitBy; + once: LodashOnce; + orderBy: LodashOrderBy; + over: LodashOver; + overArgs: LodashOverArgs; + overEvery: LodashOverEvery; + overSome: LodashOverSome; + pad: LodashPad; + padChars: LodashPadChars; + padCharsEnd: LodashPadCharsEnd; + padCharsStart: LodashPadCharsStart; + padEnd: LodashPadEnd; + padStart: LodashPadStart; + parseInt: LodashParseInt; + partial: LodashPartial; + partialRight: LodashPartialRight; + partition: LodashPartition; + path: LodashPath; + pathEq: LodashMatchesProperty; + pathOr: LodashPathOr; + paths: LodashAt; + pick: LodashPick; + pickAll: LodashPick; + pickBy: LodashPickBy; + pipe: LodashFlow; + pluck: LodashMap; + prop: LodashProp; + propEq: LodashMatchesProperty; + property: LodashProperty; + propertyOf: LodashPropertyOf; + propOr: LodashPropOr; + props: LodashAt; + pull: LodashPull; + pullAll: LodashPullAll; + pullAllBy: LodashPullAllBy; + pullAllWith: LodashPullAllWith; + pullAt: LodashPullAt; + random: LodashRandom; + range: LodashRange; + rangeRight: LodashRangeRight; + rangeStep: LodashRangeStep; + rangeStepRight: LodashRangeStepRight; + rearg: LodashRearg; + reduce: LodashReduce; + reduceRight: LodashReduceRight; + reject: LodashReject; + remove: LodashRemove; + repeat: LodashRepeat; + replace: LodashReplace; + rest: LodashRest; + restFrom: LodashRestFrom; + result: LodashResult; + reverse: LodashReverse; + round: LodashRound; + runInContext: LodashRunInContext; + sample: LodashSample; + sampleSize: LodashSampleSize; + set: LodashSet; + setWith: LodashSetWith; + shuffle: LodashShuffle; + size: LodashSize; + slice: LodashSlice; + snakeCase: LodashSnakeCase; + some: LodashSome; + sortBy: LodashSortBy; + sortedIndex: LodashSortedIndex; + sortedIndexBy: LodashSortedIndexBy; + sortedIndexOf: LodashSortedIndexOf; + sortedLastIndex: LodashSortedLastIndex; + sortedLastIndexBy: LodashSortedLastIndexBy; + sortedLastIndexOf: LodashSortedLastIndexOf; + sortedUniq: LodashSortedUniq; + sortedUniqBy: LodashSortedUniqBy; + split: LodashSplit; + spread: LodashSpread; + spreadFrom: LodashSpreadFrom; + startCase: LodashStartCase; + startsWith: LodashStartsWith; + stubArray: LodashStubArray; + stubFalse: LodashStubFalse; + stubObject: LodashStubObject; + stubString: LodashStubString; + stubTrue: LodashStubTrue; + subtract: LodashSubtract; + sum: LodashSum; + sumBy: LodashSumBy; + symmetricDifference: LodashXor; + symmetricDifferenceBy: LodashXorBy; + symmetricDifferenceWith: LodashXorWith; + T: LodashStubTrue; + tail: LodashTail; + take: LodashTake; + takeLast: LodashTakeRight; + takeLastWhile: LodashTakeRightWhile; + takeRight: LodashTakeRight; + takeRightWhile: LodashTakeRightWhile; + takeWhile: LodashTakeWhile; + tap: LodashTap; + template: LodashTemplate; + throttle: LodashThrottle; + thru: LodashThru; + times: LodashTimes; + toArray: LodashToArray; + toFinite: LodashToFinite; + toInteger: LodashToInteger; + toLength: LodashToLength; + toLower: LodashToLower; + toNumber: LodashToNumber; + toPairs: LodashToPairs; + toPairsIn: LodashToPairsIn; + toPath: LodashToPath; + toPlainObject: LodashToPlainObject; + toSafeInteger: LodashToSafeInteger; + toString: LodashToString; + toUpper: LodashToUpper; + transform: LodashTransform; + trim: LodashTrim; + trimChars: LodashTrimChars; + trimCharsEnd: LodashTrimCharsEnd; + trimCharsStart: LodashTrimCharsStart; + trimEnd: LodashTrimEnd; + trimStart: LodashTrimStart; + truncate: LodashTruncate; + unapply: LodashUnapply; + unary: LodashUnary; + unescape: LodashUnescape; + union: LodashUnion; + unionBy: LodashUnionBy; + unionWith: LodashUnionWith; + uniq: LodashUniq; + uniqBy: LodashUniqBy; + uniqueId: LodashUniqueId; + uniqWith: LodashUniqWith; + unnest: LodashFlatten; + unset: LodashUnset; + unzip: LodashUnzip; + unzipWith: LodashUnzipWith; + update: LodashUpdate; + updateWith: LodashUpdateWith; + upperCase: LodashUpperCase; + upperFirst: LodashUpperFirst; + useWith: LodashOverArgs; + values: LodashValues; + valuesIn: LodashValuesIn; + where: LodashConformsTo; + whereEq: LodashIsMatch; + without: LodashWithout; + words: LodashWords; + wrap: LodashWrap; + xor: LodashXor; + xorBy: LodashXorBy; + xorWith: LodashXorWith; + zip: LodashZip; + zipAll: LodashZipAll; + zipObj: LodashZipObject; + zipObject: LodashZipObject; + zipObjectDeep: LodashZipObjectDeep; + zipWith: LodashZipWith; + __: lodash.__; + placeholder: lodash.__; + } +} diff --git a/types/lodash/ts3.1/fp/F.d.ts b/types/lodash/ts3.1/fp/F.d.ts new file mode 100644 index 0000000000..33fc57930d --- /dev/null +++ b/types/lodash/ts3.1/fp/F.d.ts @@ -0,0 +1,2 @@ +import { F } from "../fp"; +export = F; diff --git a/types/lodash/ts3.1/fp/T.d.ts b/types/lodash/ts3.1/fp/T.d.ts new file mode 100644 index 0000000000..886606ef6f --- /dev/null +++ b/types/lodash/ts3.1/fp/T.d.ts @@ -0,0 +1,2 @@ +import { T } from "../fp"; +export = T; diff --git a/types/lodash/ts3.1/fp/__.d.ts b/types/lodash/ts3.1/fp/__.d.ts new file mode 100644 index 0000000000..aec0a51422 --- /dev/null +++ b/types/lodash/ts3.1/fp/__.d.ts @@ -0,0 +1,3 @@ +import _ = require("../index"); +declare const __: _.__; +export = __; diff --git a/types/lodash/ts3.1/fp/add.d.ts b/types/lodash/ts3.1/fp/add.d.ts new file mode 100644 index 0000000000..47c9c6a1a4 --- /dev/null +++ b/types/lodash/ts3.1/fp/add.d.ts @@ -0,0 +1,2 @@ +import { add } from "../fp"; +export = add; diff --git a/types/lodash/ts3.1/fp/after.d.ts b/types/lodash/ts3.1/fp/after.d.ts new file mode 100644 index 0000000000..93863a5613 --- /dev/null +++ b/types/lodash/ts3.1/fp/after.d.ts @@ -0,0 +1,2 @@ +import { after } from "../fp"; +export = after; diff --git a/types/lodash/ts3.1/fp/all.d.ts b/types/lodash/ts3.1/fp/all.d.ts new file mode 100644 index 0000000000..5ca0f70736 --- /dev/null +++ b/types/lodash/ts3.1/fp/all.d.ts @@ -0,0 +1,2 @@ +import { all } from "../fp"; +export = all; diff --git a/types/lodash/ts3.1/fp/allPass.d.ts b/types/lodash/ts3.1/fp/allPass.d.ts new file mode 100644 index 0000000000..5013913efc --- /dev/null +++ b/types/lodash/ts3.1/fp/allPass.d.ts @@ -0,0 +1,2 @@ +import { allPass } from "../fp"; +export = allPass; diff --git a/types/lodash/ts3.1/fp/always.d.ts b/types/lodash/ts3.1/fp/always.d.ts new file mode 100644 index 0000000000..07bd82d47c --- /dev/null +++ b/types/lodash/ts3.1/fp/always.d.ts @@ -0,0 +1,2 @@ +import { always } from "../fp"; +export = always; diff --git a/types/lodash/ts3.1/fp/any.d.ts b/types/lodash/ts3.1/fp/any.d.ts new file mode 100644 index 0000000000..5d8c38f27c --- /dev/null +++ b/types/lodash/ts3.1/fp/any.d.ts @@ -0,0 +1,2 @@ +import { any } from "../fp"; +export = any; diff --git a/types/lodash/ts3.1/fp/anyPass.d.ts b/types/lodash/ts3.1/fp/anyPass.d.ts new file mode 100644 index 0000000000..b69becfaf3 --- /dev/null +++ b/types/lodash/ts3.1/fp/anyPass.d.ts @@ -0,0 +1,2 @@ +import { anyPass } from "../fp"; +export = anyPass; diff --git a/types/lodash/ts3.1/fp/apply.d.ts b/types/lodash/ts3.1/fp/apply.d.ts new file mode 100644 index 0000000000..e13c42c5de --- /dev/null +++ b/types/lodash/ts3.1/fp/apply.d.ts @@ -0,0 +1,2 @@ +import { apply } from "../fp"; +export = apply; diff --git a/types/lodash/ts3.1/fp/ary.d.ts b/types/lodash/ts3.1/fp/ary.d.ts new file mode 100644 index 0000000000..932d7f45f3 --- /dev/null +++ b/types/lodash/ts3.1/fp/ary.d.ts @@ -0,0 +1,2 @@ +import { ary } from "../fp"; +export = ary; diff --git a/types/lodash/ts3.1/fp/assign.d.ts b/types/lodash/ts3.1/fp/assign.d.ts new file mode 100644 index 0000000000..cf173104ab --- /dev/null +++ b/types/lodash/ts3.1/fp/assign.d.ts @@ -0,0 +1,2 @@ +import { assign } from "../fp"; +export = assign; diff --git a/types/lodash/ts3.1/fp/assignAll.d.ts b/types/lodash/ts3.1/fp/assignAll.d.ts new file mode 100644 index 0000000000..f95b06b475 --- /dev/null +++ b/types/lodash/ts3.1/fp/assignAll.d.ts @@ -0,0 +1,2 @@ +import { assignAll } from "../fp"; +export = assignAll; diff --git a/types/lodash/ts3.1/fp/assignAllWith.d.ts b/types/lodash/ts3.1/fp/assignAllWith.d.ts new file mode 100644 index 0000000000..c2695a07a6 --- /dev/null +++ b/types/lodash/ts3.1/fp/assignAllWith.d.ts @@ -0,0 +1,2 @@ +import { assignAllWith } from "../fp"; +export = assignAllWith; diff --git a/types/lodash/ts3.1/fp/assignIn.d.ts b/types/lodash/ts3.1/fp/assignIn.d.ts new file mode 100644 index 0000000000..f6cdee768b --- /dev/null +++ b/types/lodash/ts3.1/fp/assignIn.d.ts @@ -0,0 +1,2 @@ +import { assignIn } from "../fp"; +export = assignIn; diff --git a/types/lodash/ts3.1/fp/assignInAll.d.ts b/types/lodash/ts3.1/fp/assignInAll.d.ts new file mode 100644 index 0000000000..539344b67b --- /dev/null +++ b/types/lodash/ts3.1/fp/assignInAll.d.ts @@ -0,0 +1,2 @@ +import { assignInAll } from "../fp"; +export = assignInAll; diff --git a/types/lodash/ts3.1/fp/assignInAllWith.d.ts b/types/lodash/ts3.1/fp/assignInAllWith.d.ts new file mode 100644 index 0000000000..3b421fb332 --- /dev/null +++ b/types/lodash/ts3.1/fp/assignInAllWith.d.ts @@ -0,0 +1,2 @@ +import { assignInAllWith } from "../fp"; +export = assignInAllWith; diff --git a/types/lodash/ts3.1/fp/assignInWith.d.ts b/types/lodash/ts3.1/fp/assignInWith.d.ts new file mode 100644 index 0000000000..c410091c62 --- /dev/null +++ b/types/lodash/ts3.1/fp/assignInWith.d.ts @@ -0,0 +1,2 @@ +import { assignInWith } from "../fp"; +export = assignInWith; diff --git a/types/lodash/ts3.1/fp/assignWith.d.ts b/types/lodash/ts3.1/fp/assignWith.d.ts new file mode 100644 index 0000000000..2205db0119 --- /dev/null +++ b/types/lodash/ts3.1/fp/assignWith.d.ts @@ -0,0 +1,2 @@ +import { assignWith } from "../fp"; +export = assignWith; diff --git a/types/lodash/ts3.1/fp/assoc.d.ts b/types/lodash/ts3.1/fp/assoc.d.ts new file mode 100644 index 0000000000..2a2e29c6f0 --- /dev/null +++ b/types/lodash/ts3.1/fp/assoc.d.ts @@ -0,0 +1,2 @@ +import { assoc } from "../fp"; +export = assoc; diff --git a/types/lodash/ts3.1/fp/assocPath.d.ts b/types/lodash/ts3.1/fp/assocPath.d.ts new file mode 100644 index 0000000000..e2dd5179e3 --- /dev/null +++ b/types/lodash/ts3.1/fp/assocPath.d.ts @@ -0,0 +1,2 @@ +import { assocPath } from "../fp"; +export = assocPath; diff --git a/types/lodash/ts3.1/fp/at.d.ts b/types/lodash/ts3.1/fp/at.d.ts new file mode 100644 index 0000000000..beefa3343b --- /dev/null +++ b/types/lodash/ts3.1/fp/at.d.ts @@ -0,0 +1,2 @@ +import { at } from "../fp"; +export = at; diff --git a/types/lodash/ts3.1/fp/attempt.d.ts b/types/lodash/ts3.1/fp/attempt.d.ts new file mode 100644 index 0000000000..72d60af08f --- /dev/null +++ b/types/lodash/ts3.1/fp/attempt.d.ts @@ -0,0 +1,2 @@ +import { attempt } from "../fp"; +export = attempt; diff --git a/types/lodash/ts3.1/fp/before.d.ts b/types/lodash/ts3.1/fp/before.d.ts new file mode 100644 index 0000000000..ead2869093 --- /dev/null +++ b/types/lodash/ts3.1/fp/before.d.ts @@ -0,0 +1,2 @@ +import { before } from "../fp"; +export = before; diff --git a/types/lodash/ts3.1/fp/bind.d.ts b/types/lodash/ts3.1/fp/bind.d.ts new file mode 100644 index 0000000000..a312192a31 --- /dev/null +++ b/types/lodash/ts3.1/fp/bind.d.ts @@ -0,0 +1,2 @@ +import { bind } from "../fp"; +export = bind; diff --git a/types/lodash/ts3.1/fp/bindAll.d.ts b/types/lodash/ts3.1/fp/bindAll.d.ts new file mode 100644 index 0000000000..4f7c7dbffc --- /dev/null +++ b/types/lodash/ts3.1/fp/bindAll.d.ts @@ -0,0 +1,2 @@ +import { bindAll } from "../fp"; +export = bindAll; diff --git a/types/lodash/ts3.1/fp/bindKey.d.ts b/types/lodash/ts3.1/fp/bindKey.d.ts new file mode 100644 index 0000000000..8986b2f3a5 --- /dev/null +++ b/types/lodash/ts3.1/fp/bindKey.d.ts @@ -0,0 +1,2 @@ +import { bindKey } from "../fp"; +export = bindKey; diff --git a/types/lodash/ts3.1/fp/camelCase.d.ts b/types/lodash/ts3.1/fp/camelCase.d.ts new file mode 100644 index 0000000000..be6628dd27 --- /dev/null +++ b/types/lodash/ts3.1/fp/camelCase.d.ts @@ -0,0 +1,2 @@ +import { camelCase } from "../fp"; +export = camelCase; diff --git a/types/lodash/ts3.1/fp/capitalize.d.ts b/types/lodash/ts3.1/fp/capitalize.d.ts new file mode 100644 index 0000000000..7dc552f9e4 --- /dev/null +++ b/types/lodash/ts3.1/fp/capitalize.d.ts @@ -0,0 +1,2 @@ +import { capitalize } from "../fp"; +export = capitalize; diff --git a/types/lodash/ts3.1/fp/castArray.d.ts b/types/lodash/ts3.1/fp/castArray.d.ts new file mode 100644 index 0000000000..a431805adf --- /dev/null +++ b/types/lodash/ts3.1/fp/castArray.d.ts @@ -0,0 +1,2 @@ +import { castArray } from "../fp"; +export = castArray; diff --git a/types/lodash/ts3.1/fp/ceil.d.ts b/types/lodash/ts3.1/fp/ceil.d.ts new file mode 100644 index 0000000000..13cd7317b1 --- /dev/null +++ b/types/lodash/ts3.1/fp/ceil.d.ts @@ -0,0 +1,2 @@ +import { ceil } from "../fp"; +export = ceil; diff --git a/types/lodash/ts3.1/fp/chunk.d.ts b/types/lodash/ts3.1/fp/chunk.d.ts new file mode 100644 index 0000000000..2e4066660b --- /dev/null +++ b/types/lodash/ts3.1/fp/chunk.d.ts @@ -0,0 +1,2 @@ +import { chunk } from "../fp"; +export = chunk; diff --git a/types/lodash/ts3.1/fp/clamp.d.ts b/types/lodash/ts3.1/fp/clamp.d.ts new file mode 100644 index 0000000000..121c6f9b9c --- /dev/null +++ b/types/lodash/ts3.1/fp/clamp.d.ts @@ -0,0 +1,2 @@ +import { clamp } from "../fp"; +export = clamp; diff --git a/types/lodash/ts3.1/fp/clone.d.ts b/types/lodash/ts3.1/fp/clone.d.ts new file mode 100644 index 0000000000..9edf0c8d13 --- /dev/null +++ b/types/lodash/ts3.1/fp/clone.d.ts @@ -0,0 +1,2 @@ +import { clone } from "../fp"; +export = clone; diff --git a/types/lodash/ts3.1/fp/cloneDeep.d.ts b/types/lodash/ts3.1/fp/cloneDeep.d.ts new file mode 100644 index 0000000000..3bdab159ac --- /dev/null +++ b/types/lodash/ts3.1/fp/cloneDeep.d.ts @@ -0,0 +1,2 @@ +import { cloneDeep } from "../fp"; +export = cloneDeep; diff --git a/types/lodash/ts3.1/fp/cloneDeepWith.d.ts b/types/lodash/ts3.1/fp/cloneDeepWith.d.ts new file mode 100644 index 0000000000..57cf5af8bd --- /dev/null +++ b/types/lodash/ts3.1/fp/cloneDeepWith.d.ts @@ -0,0 +1,2 @@ +import { cloneDeepWith } from "../fp"; +export = cloneDeepWith; diff --git a/types/lodash/ts3.1/fp/cloneWith.d.ts b/types/lodash/ts3.1/fp/cloneWith.d.ts new file mode 100644 index 0000000000..9c63e13693 --- /dev/null +++ b/types/lodash/ts3.1/fp/cloneWith.d.ts @@ -0,0 +1,2 @@ +import { cloneWith } from "../fp"; +export = cloneWith; diff --git a/types/lodash/ts3.1/fp/compact.d.ts b/types/lodash/ts3.1/fp/compact.d.ts new file mode 100644 index 0000000000..6ca1547040 --- /dev/null +++ b/types/lodash/ts3.1/fp/compact.d.ts @@ -0,0 +1,2 @@ +import { compact } from "../fp"; +export = compact; diff --git a/types/lodash/ts3.1/fp/complement.d.ts b/types/lodash/ts3.1/fp/complement.d.ts new file mode 100644 index 0000000000..e4c3112534 --- /dev/null +++ b/types/lodash/ts3.1/fp/complement.d.ts @@ -0,0 +1,2 @@ +import { complement } from "../fp"; +export = complement; diff --git a/types/lodash/ts3.1/fp/compose.d.ts b/types/lodash/ts3.1/fp/compose.d.ts new file mode 100644 index 0000000000..7950c7c585 --- /dev/null +++ b/types/lodash/ts3.1/fp/compose.d.ts @@ -0,0 +1,2 @@ +import { compose } from "../fp"; +export = compose; diff --git a/types/lodash/ts3.1/fp/concat.d.ts b/types/lodash/ts3.1/fp/concat.d.ts new file mode 100644 index 0000000000..5e109d1daa --- /dev/null +++ b/types/lodash/ts3.1/fp/concat.d.ts @@ -0,0 +1,2 @@ +import { concat } from "../fp"; +export = concat; diff --git a/types/lodash/ts3.1/fp/cond.d.ts b/types/lodash/ts3.1/fp/cond.d.ts new file mode 100644 index 0000000000..b9216e308f --- /dev/null +++ b/types/lodash/ts3.1/fp/cond.d.ts @@ -0,0 +1,2 @@ +import { cond } from "../fp"; +export = cond; diff --git a/types/lodash/ts3.1/fp/conforms.d.ts b/types/lodash/ts3.1/fp/conforms.d.ts new file mode 100644 index 0000000000..9bd3353f44 --- /dev/null +++ b/types/lodash/ts3.1/fp/conforms.d.ts @@ -0,0 +1,2 @@ +import { conforms } from "../fp"; +export = conforms; diff --git a/types/lodash/ts3.1/fp/conformsTo.d.ts b/types/lodash/ts3.1/fp/conformsTo.d.ts new file mode 100644 index 0000000000..ad1728006d --- /dev/null +++ b/types/lodash/ts3.1/fp/conformsTo.d.ts @@ -0,0 +1,2 @@ +import { conformsTo } from "../fp"; +export = conformsTo; diff --git a/types/lodash/ts3.1/fp/constant.d.ts b/types/lodash/ts3.1/fp/constant.d.ts new file mode 100644 index 0000000000..ef80ff57c3 --- /dev/null +++ b/types/lodash/ts3.1/fp/constant.d.ts @@ -0,0 +1,2 @@ +import { constant } from "../fp"; +export = constant; diff --git a/types/lodash/ts3.1/fp/contains.d.ts b/types/lodash/ts3.1/fp/contains.d.ts new file mode 100644 index 0000000000..6c29e95f1a --- /dev/null +++ b/types/lodash/ts3.1/fp/contains.d.ts @@ -0,0 +1,2 @@ +import { contains } from "../fp"; +export = contains; diff --git a/types/lodash/ts3.1/fp/convert.d.ts b/types/lodash/ts3.1/fp/convert.d.ts new file mode 100644 index 0000000000..c06ecd9370 --- /dev/null +++ b/types/lodash/ts3.1/fp/convert.d.ts @@ -0,0 +1,15 @@ +interface ConvertOptions { + cap?: boolean; + curry?: boolean; + fixed?: boolean; + immutable?: boolean; + rearg?: boolean; +} + +interface Convert { + (func: object, options?: ConvertOptions): any; + (name: string, func: (...args: any[]) => any, options?: ConvertOptions): any; +} + +declare const convert: Convert; +export = convert; diff --git a/types/lodash/ts3.1/fp/countBy.d.ts b/types/lodash/ts3.1/fp/countBy.d.ts new file mode 100644 index 0000000000..e3725c3521 --- /dev/null +++ b/types/lodash/ts3.1/fp/countBy.d.ts @@ -0,0 +1,2 @@ +import { countBy } from "../fp"; +export = countBy; diff --git a/types/lodash/ts3.1/fp/create.d.ts b/types/lodash/ts3.1/fp/create.d.ts new file mode 100644 index 0000000000..2818e10e8d --- /dev/null +++ b/types/lodash/ts3.1/fp/create.d.ts @@ -0,0 +1,2 @@ +import { create } from "../fp"; +export = create; diff --git a/types/lodash/ts3.1/fp/curry.d.ts b/types/lodash/ts3.1/fp/curry.d.ts new file mode 100644 index 0000000000..e8fcf1ded7 --- /dev/null +++ b/types/lodash/ts3.1/fp/curry.d.ts @@ -0,0 +1,2 @@ +import { curry } from "../fp"; +export = curry; diff --git a/types/lodash/ts3.1/fp/curryN.d.ts b/types/lodash/ts3.1/fp/curryN.d.ts new file mode 100644 index 0000000000..55b579b716 --- /dev/null +++ b/types/lodash/ts3.1/fp/curryN.d.ts @@ -0,0 +1,2 @@ +import { curryN } from "../fp"; +export = curryN; diff --git a/types/lodash/ts3.1/fp/curryRight.d.ts b/types/lodash/ts3.1/fp/curryRight.d.ts new file mode 100644 index 0000000000..d431f3c673 --- /dev/null +++ b/types/lodash/ts3.1/fp/curryRight.d.ts @@ -0,0 +1,2 @@ +import { curryRight } from "../fp"; +export = curryRight; diff --git a/types/lodash/ts3.1/fp/curryRightN.d.ts b/types/lodash/ts3.1/fp/curryRightN.d.ts new file mode 100644 index 0000000000..89866d16ae --- /dev/null +++ b/types/lodash/ts3.1/fp/curryRightN.d.ts @@ -0,0 +1,2 @@ +import { curryRightN } from "../fp"; +export = curryRightN; diff --git a/types/lodash/ts3.1/fp/debounce.d.ts b/types/lodash/ts3.1/fp/debounce.d.ts new file mode 100644 index 0000000000..88b003cbb0 --- /dev/null +++ b/types/lodash/ts3.1/fp/debounce.d.ts @@ -0,0 +1,2 @@ +import { debounce } from "../fp"; +export = debounce; diff --git a/types/lodash/ts3.1/fp/deburr.d.ts b/types/lodash/ts3.1/fp/deburr.d.ts new file mode 100644 index 0000000000..769abfb504 --- /dev/null +++ b/types/lodash/ts3.1/fp/deburr.d.ts @@ -0,0 +1,2 @@ +import { deburr } from "../fp"; +export = deburr; diff --git a/types/lodash/ts3.1/fp/defaultTo.d.ts b/types/lodash/ts3.1/fp/defaultTo.d.ts new file mode 100644 index 0000000000..e02cc46fed --- /dev/null +++ b/types/lodash/ts3.1/fp/defaultTo.d.ts @@ -0,0 +1,2 @@ +import { defaultTo } from "../fp"; +export = defaultTo; diff --git a/types/lodash/ts3.1/fp/defaults.d.ts b/types/lodash/ts3.1/fp/defaults.d.ts new file mode 100644 index 0000000000..132e47ba2e --- /dev/null +++ b/types/lodash/ts3.1/fp/defaults.d.ts @@ -0,0 +1,2 @@ +import { defaults } from "../fp"; +export = defaults; diff --git a/types/lodash/ts3.1/fp/defaultsAll.d.ts b/types/lodash/ts3.1/fp/defaultsAll.d.ts new file mode 100644 index 0000000000..1f2a3309e7 --- /dev/null +++ b/types/lodash/ts3.1/fp/defaultsAll.d.ts @@ -0,0 +1,2 @@ +import { defaultsAll } from "../fp"; +export = defaultsAll; diff --git a/types/lodash/ts3.1/fp/defaultsDeep.d.ts b/types/lodash/ts3.1/fp/defaultsDeep.d.ts new file mode 100644 index 0000000000..6268a02594 --- /dev/null +++ b/types/lodash/ts3.1/fp/defaultsDeep.d.ts @@ -0,0 +1,2 @@ +import { defaultsDeep } from "../fp"; +export = defaultsDeep; diff --git a/types/lodash/ts3.1/fp/defaultsDeepAll.d.ts b/types/lodash/ts3.1/fp/defaultsDeepAll.d.ts new file mode 100644 index 0000000000..7791666232 --- /dev/null +++ b/types/lodash/ts3.1/fp/defaultsDeepAll.d.ts @@ -0,0 +1,2 @@ +import { defaultsDeepAll } from "../fp"; +export = defaultsDeepAll; diff --git a/types/lodash/ts3.1/fp/defer.d.ts b/types/lodash/ts3.1/fp/defer.d.ts new file mode 100644 index 0000000000..f8be4ae8e2 --- /dev/null +++ b/types/lodash/ts3.1/fp/defer.d.ts @@ -0,0 +1,2 @@ +import { defer } from "../fp"; +export = defer; diff --git a/types/lodash/ts3.1/fp/delay.d.ts b/types/lodash/ts3.1/fp/delay.d.ts new file mode 100644 index 0000000000..2f0c39909f --- /dev/null +++ b/types/lodash/ts3.1/fp/delay.d.ts @@ -0,0 +1,2 @@ +import { delay } from "../fp"; +export = delay; diff --git a/types/lodash/ts3.1/fp/difference.d.ts b/types/lodash/ts3.1/fp/difference.d.ts new file mode 100644 index 0000000000..9448085041 --- /dev/null +++ b/types/lodash/ts3.1/fp/difference.d.ts @@ -0,0 +1,2 @@ +import { difference } from "../fp"; +export = difference; diff --git a/types/lodash/ts3.1/fp/differenceBy.d.ts b/types/lodash/ts3.1/fp/differenceBy.d.ts new file mode 100644 index 0000000000..52ba5b80ac --- /dev/null +++ b/types/lodash/ts3.1/fp/differenceBy.d.ts @@ -0,0 +1,2 @@ +import { differenceBy } from "../fp"; +export = differenceBy; diff --git a/types/lodash/ts3.1/fp/differenceWith.d.ts b/types/lodash/ts3.1/fp/differenceWith.d.ts new file mode 100644 index 0000000000..fd3c9a2cd4 --- /dev/null +++ b/types/lodash/ts3.1/fp/differenceWith.d.ts @@ -0,0 +1,2 @@ +import { differenceWith } from "../fp"; +export = differenceWith; diff --git a/types/lodash/ts3.1/fp/dissoc.d.ts b/types/lodash/ts3.1/fp/dissoc.d.ts new file mode 100644 index 0000000000..9b0fd6bb90 --- /dev/null +++ b/types/lodash/ts3.1/fp/dissoc.d.ts @@ -0,0 +1,2 @@ +import { dissoc } from "../fp"; +export = dissoc; diff --git a/types/lodash/ts3.1/fp/dissocPath.d.ts b/types/lodash/ts3.1/fp/dissocPath.d.ts new file mode 100644 index 0000000000..a201aa4b88 --- /dev/null +++ b/types/lodash/ts3.1/fp/dissocPath.d.ts @@ -0,0 +1,2 @@ +import { dissocPath } from "../fp"; +export = dissocPath; diff --git a/types/lodash/ts3.1/fp/divide.d.ts b/types/lodash/ts3.1/fp/divide.d.ts new file mode 100644 index 0000000000..5cd02e49dc --- /dev/null +++ b/types/lodash/ts3.1/fp/divide.d.ts @@ -0,0 +1,2 @@ +import { divide } from "../fp"; +export = divide; diff --git a/types/lodash/ts3.1/fp/drop.d.ts b/types/lodash/ts3.1/fp/drop.d.ts new file mode 100644 index 0000000000..bc3b9b2049 --- /dev/null +++ b/types/lodash/ts3.1/fp/drop.d.ts @@ -0,0 +1,2 @@ +import { drop } from "../fp"; +export = drop; diff --git a/types/lodash/ts3.1/fp/dropLast.d.ts b/types/lodash/ts3.1/fp/dropLast.d.ts new file mode 100644 index 0000000000..1dd388ae15 --- /dev/null +++ b/types/lodash/ts3.1/fp/dropLast.d.ts @@ -0,0 +1,2 @@ +import { dropLast } from "../fp"; +export = dropLast; diff --git a/types/lodash/ts3.1/fp/dropLastWhile.d.ts b/types/lodash/ts3.1/fp/dropLastWhile.d.ts new file mode 100644 index 0000000000..97529a6a49 --- /dev/null +++ b/types/lodash/ts3.1/fp/dropLastWhile.d.ts @@ -0,0 +1,2 @@ +import { dropLastWhile } from "../fp"; +export = dropLastWhile; diff --git a/types/lodash/ts3.1/fp/dropRight.d.ts b/types/lodash/ts3.1/fp/dropRight.d.ts new file mode 100644 index 0000000000..a2740ff029 --- /dev/null +++ b/types/lodash/ts3.1/fp/dropRight.d.ts @@ -0,0 +1,2 @@ +import { dropRight } from "../fp"; +export = dropRight; diff --git a/types/lodash/ts3.1/fp/dropRightWhile.d.ts b/types/lodash/ts3.1/fp/dropRightWhile.d.ts new file mode 100644 index 0000000000..1a5aa5fe3e --- /dev/null +++ b/types/lodash/ts3.1/fp/dropRightWhile.d.ts @@ -0,0 +1,2 @@ +import { dropRightWhile } from "../fp"; +export = dropRightWhile; diff --git a/types/lodash/ts3.1/fp/dropWhile.d.ts b/types/lodash/ts3.1/fp/dropWhile.d.ts new file mode 100644 index 0000000000..2cab8d8698 --- /dev/null +++ b/types/lodash/ts3.1/fp/dropWhile.d.ts @@ -0,0 +1,2 @@ +import { dropWhile } from "../fp"; +export = dropWhile; diff --git a/types/lodash/ts3.1/fp/each.d.ts b/types/lodash/ts3.1/fp/each.d.ts new file mode 100644 index 0000000000..af1d3b20a6 --- /dev/null +++ b/types/lodash/ts3.1/fp/each.d.ts @@ -0,0 +1,2 @@ +import { each } from "../fp"; +export = each; diff --git a/types/lodash/ts3.1/fp/eachRight.d.ts b/types/lodash/ts3.1/fp/eachRight.d.ts new file mode 100644 index 0000000000..5ca2934abd --- /dev/null +++ b/types/lodash/ts3.1/fp/eachRight.d.ts @@ -0,0 +1,2 @@ +import { eachRight } from "../fp"; +export = eachRight; diff --git a/types/lodash/ts3.1/fp/endsWith.d.ts b/types/lodash/ts3.1/fp/endsWith.d.ts new file mode 100644 index 0000000000..7e1b243d6f --- /dev/null +++ b/types/lodash/ts3.1/fp/endsWith.d.ts @@ -0,0 +1,2 @@ +import { endsWith } from "../fp"; +export = endsWith; diff --git a/types/lodash/ts3.1/fp/entries.d.ts b/types/lodash/ts3.1/fp/entries.d.ts new file mode 100644 index 0000000000..534c7bda3d --- /dev/null +++ b/types/lodash/ts3.1/fp/entries.d.ts @@ -0,0 +1,2 @@ +import { entries } from "../fp"; +export = entries; diff --git a/types/lodash/ts3.1/fp/entriesIn.d.ts b/types/lodash/ts3.1/fp/entriesIn.d.ts new file mode 100644 index 0000000000..932b17f625 --- /dev/null +++ b/types/lodash/ts3.1/fp/entriesIn.d.ts @@ -0,0 +1,2 @@ +import { entriesIn } from "../fp"; +export = entriesIn; diff --git a/types/lodash/ts3.1/fp/eq.d.ts b/types/lodash/ts3.1/fp/eq.d.ts new file mode 100644 index 0000000000..4778846a30 --- /dev/null +++ b/types/lodash/ts3.1/fp/eq.d.ts @@ -0,0 +1,2 @@ +import { eq } from "../fp"; +export = eq; diff --git a/types/lodash/ts3.1/fp/equals.d.ts b/types/lodash/ts3.1/fp/equals.d.ts new file mode 100644 index 0000000000..18ec108d66 --- /dev/null +++ b/types/lodash/ts3.1/fp/equals.d.ts @@ -0,0 +1,2 @@ +import { equals } from "../fp"; +export = equals; diff --git a/types/lodash/ts3.1/fp/escape.d.ts b/types/lodash/ts3.1/fp/escape.d.ts new file mode 100644 index 0000000000..36e7e87556 --- /dev/null +++ b/types/lodash/ts3.1/fp/escape.d.ts @@ -0,0 +1,2 @@ +import { escape } from "../fp"; +export = escape; diff --git a/types/lodash/ts3.1/fp/escapeRegExp.d.ts b/types/lodash/ts3.1/fp/escapeRegExp.d.ts new file mode 100644 index 0000000000..6adc20e806 --- /dev/null +++ b/types/lodash/ts3.1/fp/escapeRegExp.d.ts @@ -0,0 +1,2 @@ +import { escapeRegExp } from "../fp"; +export = escapeRegExp; diff --git a/types/lodash/ts3.1/fp/every.d.ts b/types/lodash/ts3.1/fp/every.d.ts new file mode 100644 index 0000000000..7fbeaf7b15 --- /dev/null +++ b/types/lodash/ts3.1/fp/every.d.ts @@ -0,0 +1,2 @@ +import { every } from "../fp"; +export = every; diff --git a/types/lodash/ts3.1/fp/extend.d.ts b/types/lodash/ts3.1/fp/extend.d.ts new file mode 100644 index 0000000000..cbe294ee0b --- /dev/null +++ b/types/lodash/ts3.1/fp/extend.d.ts @@ -0,0 +1,2 @@ +import { extend } from "../fp"; +export = extend; diff --git a/types/lodash/ts3.1/fp/extendAll.d.ts b/types/lodash/ts3.1/fp/extendAll.d.ts new file mode 100644 index 0000000000..92cb3d6e0c --- /dev/null +++ b/types/lodash/ts3.1/fp/extendAll.d.ts @@ -0,0 +1,2 @@ +import { extendAll } from "../fp"; +export = extendAll; diff --git a/types/lodash/ts3.1/fp/extendAllWith.d.ts b/types/lodash/ts3.1/fp/extendAllWith.d.ts new file mode 100644 index 0000000000..712d1d8eea --- /dev/null +++ b/types/lodash/ts3.1/fp/extendAllWith.d.ts @@ -0,0 +1,2 @@ +import { extendAllWith } from "../fp"; +export = extendAllWith; diff --git a/types/lodash/ts3.1/fp/extendWith.d.ts b/types/lodash/ts3.1/fp/extendWith.d.ts new file mode 100644 index 0000000000..9681360bbf --- /dev/null +++ b/types/lodash/ts3.1/fp/extendWith.d.ts @@ -0,0 +1,2 @@ +import { extendWith } from "../fp"; +export = extendWith; diff --git a/types/lodash/ts3.1/fp/fill.d.ts b/types/lodash/ts3.1/fp/fill.d.ts new file mode 100644 index 0000000000..577801504d --- /dev/null +++ b/types/lodash/ts3.1/fp/fill.d.ts @@ -0,0 +1,2 @@ +import { fill } from "../fp"; +export = fill; diff --git a/types/lodash/ts3.1/fp/filter.d.ts b/types/lodash/ts3.1/fp/filter.d.ts new file mode 100644 index 0000000000..8619741343 --- /dev/null +++ b/types/lodash/ts3.1/fp/filter.d.ts @@ -0,0 +1,2 @@ +import { filter } from "../fp"; +export = filter; diff --git a/types/lodash/ts3.1/fp/find.d.ts b/types/lodash/ts3.1/fp/find.d.ts new file mode 100644 index 0000000000..06418fb456 --- /dev/null +++ b/types/lodash/ts3.1/fp/find.d.ts @@ -0,0 +1,2 @@ +import { find } from "../fp"; +export = find; diff --git a/types/lodash/ts3.1/fp/findFrom.d.ts b/types/lodash/ts3.1/fp/findFrom.d.ts new file mode 100644 index 0000000000..64275d0c83 --- /dev/null +++ b/types/lodash/ts3.1/fp/findFrom.d.ts @@ -0,0 +1,2 @@ +import { findFrom } from "../fp"; +export = findFrom; diff --git a/types/lodash/ts3.1/fp/findIndex.d.ts b/types/lodash/ts3.1/fp/findIndex.d.ts new file mode 100644 index 0000000000..77d1f7b6be --- /dev/null +++ b/types/lodash/ts3.1/fp/findIndex.d.ts @@ -0,0 +1,2 @@ +import { findIndex } from "../fp"; +export = findIndex; diff --git a/types/lodash/ts3.1/fp/findIndexFrom.d.ts b/types/lodash/ts3.1/fp/findIndexFrom.d.ts new file mode 100644 index 0000000000..22330adc53 --- /dev/null +++ b/types/lodash/ts3.1/fp/findIndexFrom.d.ts @@ -0,0 +1,2 @@ +import { findIndexFrom } from "../fp"; +export = findIndexFrom; diff --git a/types/lodash/ts3.1/fp/findKey.d.ts b/types/lodash/ts3.1/fp/findKey.d.ts new file mode 100644 index 0000000000..c5a225a776 --- /dev/null +++ b/types/lodash/ts3.1/fp/findKey.d.ts @@ -0,0 +1,2 @@ +import { findKey } from "../fp"; +export = findKey; diff --git a/types/lodash/ts3.1/fp/findLast.d.ts b/types/lodash/ts3.1/fp/findLast.d.ts new file mode 100644 index 0000000000..b400c946b0 --- /dev/null +++ b/types/lodash/ts3.1/fp/findLast.d.ts @@ -0,0 +1,2 @@ +import { findLast } from "../fp"; +export = findLast; diff --git a/types/lodash/ts3.1/fp/findLastFrom.d.ts b/types/lodash/ts3.1/fp/findLastFrom.d.ts new file mode 100644 index 0000000000..1f034dfa88 --- /dev/null +++ b/types/lodash/ts3.1/fp/findLastFrom.d.ts @@ -0,0 +1,2 @@ +import { findLastFrom } from "../fp"; +export = findLastFrom; diff --git a/types/lodash/ts3.1/fp/findLastIndex.d.ts b/types/lodash/ts3.1/fp/findLastIndex.d.ts new file mode 100644 index 0000000000..51ee410fb1 --- /dev/null +++ b/types/lodash/ts3.1/fp/findLastIndex.d.ts @@ -0,0 +1,2 @@ +import { findLastIndex } from "../fp"; +export = findLastIndex; diff --git a/types/lodash/ts3.1/fp/findLastIndexFrom.d.ts b/types/lodash/ts3.1/fp/findLastIndexFrom.d.ts new file mode 100644 index 0000000000..08bd53a087 --- /dev/null +++ b/types/lodash/ts3.1/fp/findLastIndexFrom.d.ts @@ -0,0 +1,2 @@ +import { findLastIndexFrom } from "../fp"; +export = findLastIndexFrom; diff --git a/types/lodash/ts3.1/fp/findLastKey.d.ts b/types/lodash/ts3.1/fp/findLastKey.d.ts new file mode 100644 index 0000000000..7437a9ddda --- /dev/null +++ b/types/lodash/ts3.1/fp/findLastKey.d.ts @@ -0,0 +1,2 @@ +import { findLastKey } from "../fp"; +export = findLastKey; diff --git a/types/lodash/ts3.1/fp/first.d.ts b/types/lodash/ts3.1/fp/first.d.ts new file mode 100644 index 0000000000..4554ad0e92 --- /dev/null +++ b/types/lodash/ts3.1/fp/first.d.ts @@ -0,0 +1,2 @@ +import { first } from "../fp"; +export = first; diff --git a/types/lodash/ts3.1/fp/flatMap.d.ts b/types/lodash/ts3.1/fp/flatMap.d.ts new file mode 100644 index 0000000000..eb6d80434f --- /dev/null +++ b/types/lodash/ts3.1/fp/flatMap.d.ts @@ -0,0 +1,2 @@ +import { flatMap } from "../fp"; +export = flatMap; diff --git a/types/lodash/ts3.1/fp/flatMapDeep.d.ts b/types/lodash/ts3.1/fp/flatMapDeep.d.ts new file mode 100644 index 0000000000..0ce4db4801 --- /dev/null +++ b/types/lodash/ts3.1/fp/flatMapDeep.d.ts @@ -0,0 +1,2 @@ +import { flatMapDeep } from "../fp"; +export = flatMapDeep; diff --git a/types/lodash/ts3.1/fp/flatMapDepth.d.ts b/types/lodash/ts3.1/fp/flatMapDepth.d.ts new file mode 100644 index 0000000000..b60af92cc4 --- /dev/null +++ b/types/lodash/ts3.1/fp/flatMapDepth.d.ts @@ -0,0 +1,2 @@ +import { flatMapDepth } from "../fp"; +export = flatMapDepth; diff --git a/types/lodash/ts3.1/fp/flatten.d.ts b/types/lodash/ts3.1/fp/flatten.d.ts new file mode 100644 index 0000000000..02c051ff0b --- /dev/null +++ b/types/lodash/ts3.1/fp/flatten.d.ts @@ -0,0 +1,2 @@ +import { flatten } from "../fp"; +export = flatten; diff --git a/types/lodash/ts3.1/fp/flattenDeep.d.ts b/types/lodash/ts3.1/fp/flattenDeep.d.ts new file mode 100644 index 0000000000..44b40e3a1f --- /dev/null +++ b/types/lodash/ts3.1/fp/flattenDeep.d.ts @@ -0,0 +1,2 @@ +import { flattenDeep } from "../fp"; +export = flattenDeep; diff --git a/types/lodash/ts3.1/fp/flattenDepth.d.ts b/types/lodash/ts3.1/fp/flattenDepth.d.ts new file mode 100644 index 0000000000..f046f2086a --- /dev/null +++ b/types/lodash/ts3.1/fp/flattenDepth.d.ts @@ -0,0 +1,2 @@ +import { flattenDepth } from "../fp"; +export = flattenDepth; diff --git a/types/lodash/ts3.1/fp/flip.d.ts b/types/lodash/ts3.1/fp/flip.d.ts new file mode 100644 index 0000000000..e5b3b7d4f9 --- /dev/null +++ b/types/lodash/ts3.1/fp/flip.d.ts @@ -0,0 +1,2 @@ +import { flip } from "../fp"; +export = flip; diff --git a/types/lodash/ts3.1/fp/floor.d.ts b/types/lodash/ts3.1/fp/floor.d.ts new file mode 100644 index 0000000000..167ab95438 --- /dev/null +++ b/types/lodash/ts3.1/fp/floor.d.ts @@ -0,0 +1,2 @@ +import { floor } from "../fp"; +export = floor; diff --git a/types/lodash/ts3.1/fp/flow.d.ts b/types/lodash/ts3.1/fp/flow.d.ts new file mode 100644 index 0000000000..97f0fb82b2 --- /dev/null +++ b/types/lodash/ts3.1/fp/flow.d.ts @@ -0,0 +1,2 @@ +import { flow } from "../fp"; +export = flow; diff --git a/types/lodash/ts3.1/fp/flowRight.d.ts b/types/lodash/ts3.1/fp/flowRight.d.ts new file mode 100644 index 0000000000..f148feaad9 --- /dev/null +++ b/types/lodash/ts3.1/fp/flowRight.d.ts @@ -0,0 +1,2 @@ +import { flowRight } from "../fp"; +export = flowRight; diff --git a/types/lodash/ts3.1/fp/forEach.d.ts b/types/lodash/ts3.1/fp/forEach.d.ts new file mode 100644 index 0000000000..f8aa7a4a1a --- /dev/null +++ b/types/lodash/ts3.1/fp/forEach.d.ts @@ -0,0 +1,2 @@ +import { forEach } from "../fp"; +export = forEach; diff --git a/types/lodash/ts3.1/fp/forEachRight.d.ts b/types/lodash/ts3.1/fp/forEachRight.d.ts new file mode 100644 index 0000000000..135a4243a9 --- /dev/null +++ b/types/lodash/ts3.1/fp/forEachRight.d.ts @@ -0,0 +1,2 @@ +import { forEachRight } from "../fp"; +export = forEachRight; diff --git a/types/lodash/ts3.1/fp/forIn.d.ts b/types/lodash/ts3.1/fp/forIn.d.ts new file mode 100644 index 0000000000..dab37b1075 --- /dev/null +++ b/types/lodash/ts3.1/fp/forIn.d.ts @@ -0,0 +1,2 @@ +import { forIn } from "../fp"; +export = forIn; diff --git a/types/lodash/ts3.1/fp/forInRight.d.ts b/types/lodash/ts3.1/fp/forInRight.d.ts new file mode 100644 index 0000000000..c560df0cef --- /dev/null +++ b/types/lodash/ts3.1/fp/forInRight.d.ts @@ -0,0 +1,2 @@ +import { forInRight } from "../fp"; +export = forInRight; diff --git a/types/lodash/ts3.1/fp/forOwn.d.ts b/types/lodash/ts3.1/fp/forOwn.d.ts new file mode 100644 index 0000000000..7099c48a9d --- /dev/null +++ b/types/lodash/ts3.1/fp/forOwn.d.ts @@ -0,0 +1,2 @@ +import { forOwn } from "../fp"; +export = forOwn; diff --git a/types/lodash/ts3.1/fp/forOwnRight.d.ts b/types/lodash/ts3.1/fp/forOwnRight.d.ts new file mode 100644 index 0000000000..f1e3928866 --- /dev/null +++ b/types/lodash/ts3.1/fp/forOwnRight.d.ts @@ -0,0 +1,2 @@ +import { forOwnRight } from "../fp"; +export = forOwnRight; diff --git a/types/lodash/ts3.1/fp/fromPairs.d.ts b/types/lodash/ts3.1/fp/fromPairs.d.ts new file mode 100644 index 0000000000..b0d0082a59 --- /dev/null +++ b/types/lodash/ts3.1/fp/fromPairs.d.ts @@ -0,0 +1,2 @@ +import { fromPairs } from "../fp"; +export = fromPairs; diff --git a/types/lodash/ts3.1/fp/functions.d.ts b/types/lodash/ts3.1/fp/functions.d.ts new file mode 100644 index 0000000000..727d68e138 --- /dev/null +++ b/types/lodash/ts3.1/fp/functions.d.ts @@ -0,0 +1,2 @@ +import { functions } from "../fp"; +export = functions; diff --git a/types/lodash/ts3.1/fp/functionsIn.d.ts b/types/lodash/ts3.1/fp/functionsIn.d.ts new file mode 100644 index 0000000000..448746e619 --- /dev/null +++ b/types/lodash/ts3.1/fp/functionsIn.d.ts @@ -0,0 +1,2 @@ +import { functionsIn } from "../fp"; +export = functionsIn; diff --git a/types/lodash/ts3.1/fp/get.d.ts b/types/lodash/ts3.1/fp/get.d.ts new file mode 100644 index 0000000000..ff3ab8b09d --- /dev/null +++ b/types/lodash/ts3.1/fp/get.d.ts @@ -0,0 +1,2 @@ +import { get } from "../fp"; +export = get; diff --git a/types/lodash/ts3.1/fp/getOr.d.ts b/types/lodash/ts3.1/fp/getOr.d.ts new file mode 100644 index 0000000000..ce3d5bba31 --- /dev/null +++ b/types/lodash/ts3.1/fp/getOr.d.ts @@ -0,0 +1,2 @@ +import { getOr } from "../fp"; +export = getOr; diff --git a/types/lodash/ts3.1/fp/groupBy.d.ts b/types/lodash/ts3.1/fp/groupBy.d.ts new file mode 100644 index 0000000000..813830aa0e --- /dev/null +++ b/types/lodash/ts3.1/fp/groupBy.d.ts @@ -0,0 +1,2 @@ +import { groupBy } from "../fp"; +export = groupBy; diff --git a/types/lodash/ts3.1/fp/gt.d.ts b/types/lodash/ts3.1/fp/gt.d.ts new file mode 100644 index 0000000000..517071f511 --- /dev/null +++ b/types/lodash/ts3.1/fp/gt.d.ts @@ -0,0 +1,2 @@ +import { gt } from "../fp"; +export = gt; diff --git a/types/lodash/ts3.1/fp/gte.d.ts b/types/lodash/ts3.1/fp/gte.d.ts new file mode 100644 index 0000000000..5f6d85c7f0 --- /dev/null +++ b/types/lodash/ts3.1/fp/gte.d.ts @@ -0,0 +1,2 @@ +import { gte } from "../fp"; +export = gte; diff --git a/types/lodash/ts3.1/fp/has.d.ts b/types/lodash/ts3.1/fp/has.d.ts new file mode 100644 index 0000000000..8cbda7fb8c --- /dev/null +++ b/types/lodash/ts3.1/fp/has.d.ts @@ -0,0 +1,2 @@ +import { has } from "../fp"; +export = has; diff --git a/types/lodash/ts3.1/fp/hasIn.d.ts b/types/lodash/ts3.1/fp/hasIn.d.ts new file mode 100644 index 0000000000..7e06a87ae3 --- /dev/null +++ b/types/lodash/ts3.1/fp/hasIn.d.ts @@ -0,0 +1,2 @@ +import { hasIn } from "../fp"; +export = hasIn; diff --git a/types/lodash/ts3.1/fp/head.d.ts b/types/lodash/ts3.1/fp/head.d.ts new file mode 100644 index 0000000000..4a7d5e59cd --- /dev/null +++ b/types/lodash/ts3.1/fp/head.d.ts @@ -0,0 +1,2 @@ +import { head } from "../fp"; +export = head; diff --git a/types/lodash/ts3.1/fp/identical.d.ts b/types/lodash/ts3.1/fp/identical.d.ts new file mode 100644 index 0000000000..954dff5569 --- /dev/null +++ b/types/lodash/ts3.1/fp/identical.d.ts @@ -0,0 +1,2 @@ +import { identical } from "../fp"; +export = identical; diff --git a/types/lodash/ts3.1/fp/identity.d.ts b/types/lodash/ts3.1/fp/identity.d.ts new file mode 100644 index 0000000000..97e613c6c8 --- /dev/null +++ b/types/lodash/ts3.1/fp/identity.d.ts @@ -0,0 +1,2 @@ +import { identity } from "../fp"; +export = identity; diff --git a/types/lodash/ts3.1/fp/inRange.d.ts b/types/lodash/ts3.1/fp/inRange.d.ts new file mode 100644 index 0000000000..06ed312687 --- /dev/null +++ b/types/lodash/ts3.1/fp/inRange.d.ts @@ -0,0 +1,2 @@ +import { inRange } from "../fp"; +export = inRange; diff --git a/types/lodash/ts3.1/fp/includes.d.ts b/types/lodash/ts3.1/fp/includes.d.ts new file mode 100644 index 0000000000..afc9984286 --- /dev/null +++ b/types/lodash/ts3.1/fp/includes.d.ts @@ -0,0 +1,2 @@ +import { includes } from "../fp"; +export = includes; diff --git a/types/lodash/ts3.1/fp/includesFrom.d.ts b/types/lodash/ts3.1/fp/includesFrom.d.ts new file mode 100644 index 0000000000..13042d029a --- /dev/null +++ b/types/lodash/ts3.1/fp/includesFrom.d.ts @@ -0,0 +1,2 @@ +import { includesFrom } from "../fp"; +export = includesFrom; diff --git a/types/lodash/ts3.1/fp/indexBy.d.ts b/types/lodash/ts3.1/fp/indexBy.d.ts new file mode 100644 index 0000000000..f3f75a41fa --- /dev/null +++ b/types/lodash/ts3.1/fp/indexBy.d.ts @@ -0,0 +1,2 @@ +import { indexBy } from "../fp"; +export = indexBy; diff --git a/types/lodash/ts3.1/fp/indexOf.d.ts b/types/lodash/ts3.1/fp/indexOf.d.ts new file mode 100644 index 0000000000..8078c468fd --- /dev/null +++ b/types/lodash/ts3.1/fp/indexOf.d.ts @@ -0,0 +1,2 @@ +import { indexOf } from "../fp"; +export = indexOf; diff --git a/types/lodash/ts3.1/fp/indexOfFrom.d.ts b/types/lodash/ts3.1/fp/indexOfFrom.d.ts new file mode 100644 index 0000000000..fe66609f7a --- /dev/null +++ b/types/lodash/ts3.1/fp/indexOfFrom.d.ts @@ -0,0 +1,2 @@ +import { indexOfFrom } from "../fp"; +export = indexOfFrom; diff --git a/types/lodash/ts3.1/fp/init.d.ts b/types/lodash/ts3.1/fp/init.d.ts new file mode 100644 index 0000000000..2f37ecd284 --- /dev/null +++ b/types/lodash/ts3.1/fp/init.d.ts @@ -0,0 +1,2 @@ +import { init } from "../fp"; +export = init; diff --git a/types/lodash/ts3.1/fp/initial.d.ts b/types/lodash/ts3.1/fp/initial.d.ts new file mode 100644 index 0000000000..446da0678b --- /dev/null +++ b/types/lodash/ts3.1/fp/initial.d.ts @@ -0,0 +1,2 @@ +import { initial } from "../fp"; +export = initial; diff --git a/types/lodash/ts3.1/fp/intersection.d.ts b/types/lodash/ts3.1/fp/intersection.d.ts new file mode 100644 index 0000000000..41d7915841 --- /dev/null +++ b/types/lodash/ts3.1/fp/intersection.d.ts @@ -0,0 +1,2 @@ +import { intersection } from "../fp"; +export = intersection; diff --git a/types/lodash/ts3.1/fp/intersectionBy.d.ts b/types/lodash/ts3.1/fp/intersectionBy.d.ts new file mode 100644 index 0000000000..a123ddda0d --- /dev/null +++ b/types/lodash/ts3.1/fp/intersectionBy.d.ts @@ -0,0 +1,2 @@ +import { intersectionBy } from "../fp"; +export = intersectionBy; diff --git a/types/lodash/ts3.1/fp/intersectionWith.d.ts b/types/lodash/ts3.1/fp/intersectionWith.d.ts new file mode 100644 index 0000000000..9ad9941570 --- /dev/null +++ b/types/lodash/ts3.1/fp/intersectionWith.d.ts @@ -0,0 +1,2 @@ +import { intersectionWith } from "../fp"; +export = intersectionWith; diff --git a/types/lodash/ts3.1/fp/invert.d.ts b/types/lodash/ts3.1/fp/invert.d.ts new file mode 100644 index 0000000000..a41c2bc244 --- /dev/null +++ b/types/lodash/ts3.1/fp/invert.d.ts @@ -0,0 +1,2 @@ +import { invert } from "../fp"; +export = invert; diff --git a/types/lodash/ts3.1/fp/invertBy.d.ts b/types/lodash/ts3.1/fp/invertBy.d.ts new file mode 100644 index 0000000000..e28f7135f4 --- /dev/null +++ b/types/lodash/ts3.1/fp/invertBy.d.ts @@ -0,0 +1,2 @@ +import { invertBy } from "../fp"; +export = invertBy; diff --git a/types/lodash/ts3.1/fp/invertObj.d.ts b/types/lodash/ts3.1/fp/invertObj.d.ts new file mode 100644 index 0000000000..2e16c4f8fb --- /dev/null +++ b/types/lodash/ts3.1/fp/invertObj.d.ts @@ -0,0 +1,2 @@ +import { invertObj } from "../fp"; +export = invertObj; diff --git a/types/lodash/ts3.1/fp/invoke.d.ts b/types/lodash/ts3.1/fp/invoke.d.ts new file mode 100644 index 0000000000..1a9ce3b355 --- /dev/null +++ b/types/lodash/ts3.1/fp/invoke.d.ts @@ -0,0 +1,2 @@ +import { invoke } from "../fp"; +export = invoke; diff --git a/types/lodash/ts3.1/fp/invokeArgs.d.ts b/types/lodash/ts3.1/fp/invokeArgs.d.ts new file mode 100644 index 0000000000..8b498e0ec1 --- /dev/null +++ b/types/lodash/ts3.1/fp/invokeArgs.d.ts @@ -0,0 +1,2 @@ +import { invokeArgs } from "../fp"; +export = invokeArgs; diff --git a/types/lodash/ts3.1/fp/invokeArgsMap.d.ts b/types/lodash/ts3.1/fp/invokeArgsMap.d.ts new file mode 100644 index 0000000000..f5ba3e7ec5 --- /dev/null +++ b/types/lodash/ts3.1/fp/invokeArgsMap.d.ts @@ -0,0 +1,2 @@ +import { invokeArgsMap } from "../fp"; +export = invokeArgsMap; diff --git a/types/lodash/ts3.1/fp/invokeMap.d.ts b/types/lodash/ts3.1/fp/invokeMap.d.ts new file mode 100644 index 0000000000..9f0aea9c11 --- /dev/null +++ b/types/lodash/ts3.1/fp/invokeMap.d.ts @@ -0,0 +1,2 @@ +import { invokeMap } from "../fp"; +export = invokeMap; diff --git a/types/lodash/ts3.1/fp/isArguments.d.ts b/types/lodash/ts3.1/fp/isArguments.d.ts new file mode 100644 index 0000000000..23c438c0a5 --- /dev/null +++ b/types/lodash/ts3.1/fp/isArguments.d.ts @@ -0,0 +1,2 @@ +import { isArguments } from "../fp"; +export = isArguments; diff --git a/types/lodash/ts3.1/fp/isArray.d.ts b/types/lodash/ts3.1/fp/isArray.d.ts new file mode 100644 index 0000000000..dadecce65f --- /dev/null +++ b/types/lodash/ts3.1/fp/isArray.d.ts @@ -0,0 +1,2 @@ +import { isArray } from "../fp"; +export = isArray; diff --git a/types/lodash/ts3.1/fp/isArrayBuffer.d.ts b/types/lodash/ts3.1/fp/isArrayBuffer.d.ts new file mode 100644 index 0000000000..32018346ba --- /dev/null +++ b/types/lodash/ts3.1/fp/isArrayBuffer.d.ts @@ -0,0 +1,2 @@ +import { isArrayBuffer } from "../fp"; +export = isArrayBuffer; diff --git a/types/lodash/ts3.1/fp/isArrayLike.d.ts b/types/lodash/ts3.1/fp/isArrayLike.d.ts new file mode 100644 index 0000000000..2be9b54c93 --- /dev/null +++ b/types/lodash/ts3.1/fp/isArrayLike.d.ts @@ -0,0 +1,2 @@ +import { isArrayLike } from "../fp"; +export = isArrayLike; diff --git a/types/lodash/ts3.1/fp/isArrayLikeObject.d.ts b/types/lodash/ts3.1/fp/isArrayLikeObject.d.ts new file mode 100644 index 0000000000..709f5135fe --- /dev/null +++ b/types/lodash/ts3.1/fp/isArrayLikeObject.d.ts @@ -0,0 +1,2 @@ +import { isArrayLikeObject } from "../fp"; +export = isArrayLikeObject; diff --git a/types/lodash/ts3.1/fp/isBoolean.d.ts b/types/lodash/ts3.1/fp/isBoolean.d.ts new file mode 100644 index 0000000000..605cb2cb7e --- /dev/null +++ b/types/lodash/ts3.1/fp/isBoolean.d.ts @@ -0,0 +1,2 @@ +import { isBoolean } from "../fp"; +export = isBoolean; diff --git a/types/lodash/ts3.1/fp/isBuffer.d.ts b/types/lodash/ts3.1/fp/isBuffer.d.ts new file mode 100644 index 0000000000..3d06b548c1 --- /dev/null +++ b/types/lodash/ts3.1/fp/isBuffer.d.ts @@ -0,0 +1,2 @@ +import { isBuffer } from "../fp"; +export = isBuffer; diff --git a/types/lodash/ts3.1/fp/isDate.d.ts b/types/lodash/ts3.1/fp/isDate.d.ts new file mode 100644 index 0000000000..979594f995 --- /dev/null +++ b/types/lodash/ts3.1/fp/isDate.d.ts @@ -0,0 +1,2 @@ +import { isDate } from "../fp"; +export = isDate; diff --git a/types/lodash/ts3.1/fp/isElement.d.ts b/types/lodash/ts3.1/fp/isElement.d.ts new file mode 100644 index 0000000000..26739ad952 --- /dev/null +++ b/types/lodash/ts3.1/fp/isElement.d.ts @@ -0,0 +1,2 @@ +import { isElement } from "../fp"; +export = isElement; diff --git a/types/lodash/ts3.1/fp/isEmpty.d.ts b/types/lodash/ts3.1/fp/isEmpty.d.ts new file mode 100644 index 0000000000..ed9b33f822 --- /dev/null +++ b/types/lodash/ts3.1/fp/isEmpty.d.ts @@ -0,0 +1,2 @@ +import { isEmpty } from "../fp"; +export = isEmpty; diff --git a/types/lodash/ts3.1/fp/isEqual.d.ts b/types/lodash/ts3.1/fp/isEqual.d.ts new file mode 100644 index 0000000000..0a51c5c80d --- /dev/null +++ b/types/lodash/ts3.1/fp/isEqual.d.ts @@ -0,0 +1,2 @@ +import { isEqual } from "../fp"; +export = isEqual; diff --git a/types/lodash/ts3.1/fp/isEqualWith.d.ts b/types/lodash/ts3.1/fp/isEqualWith.d.ts new file mode 100644 index 0000000000..27fa4414cb --- /dev/null +++ b/types/lodash/ts3.1/fp/isEqualWith.d.ts @@ -0,0 +1,2 @@ +import { isEqualWith } from "../fp"; +export = isEqualWith; diff --git a/types/lodash/ts3.1/fp/isError.d.ts b/types/lodash/ts3.1/fp/isError.d.ts new file mode 100644 index 0000000000..4adb9885ca --- /dev/null +++ b/types/lodash/ts3.1/fp/isError.d.ts @@ -0,0 +1,2 @@ +import { isError } from "../fp"; +export = isError; diff --git a/types/lodash/ts3.1/fp/isFinite.d.ts b/types/lodash/ts3.1/fp/isFinite.d.ts new file mode 100644 index 0000000000..5641edc0ae --- /dev/null +++ b/types/lodash/ts3.1/fp/isFinite.d.ts @@ -0,0 +1,2 @@ +import { isFinite } from "../fp"; +export = isFinite; diff --git a/types/lodash/ts3.1/fp/isFunction.d.ts b/types/lodash/ts3.1/fp/isFunction.d.ts new file mode 100644 index 0000000000..3404e74871 --- /dev/null +++ b/types/lodash/ts3.1/fp/isFunction.d.ts @@ -0,0 +1,2 @@ +import { isFunction } from "../fp"; +export = isFunction; diff --git a/types/lodash/ts3.1/fp/isInteger.d.ts b/types/lodash/ts3.1/fp/isInteger.d.ts new file mode 100644 index 0000000000..310df93478 --- /dev/null +++ b/types/lodash/ts3.1/fp/isInteger.d.ts @@ -0,0 +1,2 @@ +import { isInteger } from "../fp"; +export = isInteger; diff --git a/types/lodash/ts3.1/fp/isLength.d.ts b/types/lodash/ts3.1/fp/isLength.d.ts new file mode 100644 index 0000000000..3073b672b6 --- /dev/null +++ b/types/lodash/ts3.1/fp/isLength.d.ts @@ -0,0 +1,2 @@ +import { isLength } from "../fp"; +export = isLength; diff --git a/types/lodash/ts3.1/fp/isMap.d.ts b/types/lodash/ts3.1/fp/isMap.d.ts new file mode 100644 index 0000000000..e76745c1e2 --- /dev/null +++ b/types/lodash/ts3.1/fp/isMap.d.ts @@ -0,0 +1,2 @@ +import { isMap } from "../fp"; +export = isMap; diff --git a/types/lodash/ts3.1/fp/isMatch.d.ts b/types/lodash/ts3.1/fp/isMatch.d.ts new file mode 100644 index 0000000000..58a0a2db95 --- /dev/null +++ b/types/lodash/ts3.1/fp/isMatch.d.ts @@ -0,0 +1,2 @@ +import { isMatch } from "../fp"; +export = isMatch; diff --git a/types/lodash/ts3.1/fp/isMatchWith.d.ts b/types/lodash/ts3.1/fp/isMatchWith.d.ts new file mode 100644 index 0000000000..40ff3a691b --- /dev/null +++ b/types/lodash/ts3.1/fp/isMatchWith.d.ts @@ -0,0 +1,2 @@ +import { isMatchWith } from "../fp"; +export = isMatchWith; diff --git a/types/lodash/ts3.1/fp/isNaN.d.ts b/types/lodash/ts3.1/fp/isNaN.d.ts new file mode 100644 index 0000000000..2f92885d09 --- /dev/null +++ b/types/lodash/ts3.1/fp/isNaN.d.ts @@ -0,0 +1,2 @@ +import { isNaN } from "../fp"; +export = isNaN; diff --git a/types/lodash/ts3.1/fp/isNative.d.ts b/types/lodash/ts3.1/fp/isNative.d.ts new file mode 100644 index 0000000000..6e189a8e52 --- /dev/null +++ b/types/lodash/ts3.1/fp/isNative.d.ts @@ -0,0 +1,2 @@ +import { isNative } from "../fp"; +export = isNative; diff --git a/types/lodash/ts3.1/fp/isNil.d.ts b/types/lodash/ts3.1/fp/isNil.d.ts new file mode 100644 index 0000000000..0baee7ff8b --- /dev/null +++ b/types/lodash/ts3.1/fp/isNil.d.ts @@ -0,0 +1,2 @@ +import { isNil } from "../fp"; +export = isNil; diff --git a/types/lodash/ts3.1/fp/isNull.d.ts b/types/lodash/ts3.1/fp/isNull.d.ts new file mode 100644 index 0000000000..5e5fad5575 --- /dev/null +++ b/types/lodash/ts3.1/fp/isNull.d.ts @@ -0,0 +1,2 @@ +import { isNull } from "../fp"; +export = isNull; diff --git a/types/lodash/ts3.1/fp/isNumber.d.ts b/types/lodash/ts3.1/fp/isNumber.d.ts new file mode 100644 index 0000000000..93368f1726 --- /dev/null +++ b/types/lodash/ts3.1/fp/isNumber.d.ts @@ -0,0 +1,2 @@ +import { isNumber } from "../fp"; +export = isNumber; diff --git a/types/lodash/ts3.1/fp/isObject.d.ts b/types/lodash/ts3.1/fp/isObject.d.ts new file mode 100644 index 0000000000..7e9e2575ab --- /dev/null +++ b/types/lodash/ts3.1/fp/isObject.d.ts @@ -0,0 +1,2 @@ +import { isObject } from "../fp"; +export = isObject; diff --git a/types/lodash/ts3.1/fp/isObjectLike.d.ts b/types/lodash/ts3.1/fp/isObjectLike.d.ts new file mode 100644 index 0000000000..ba03ddc0f7 --- /dev/null +++ b/types/lodash/ts3.1/fp/isObjectLike.d.ts @@ -0,0 +1,2 @@ +import { isObjectLike } from "../fp"; +export = isObjectLike; diff --git a/types/lodash/ts3.1/fp/isPlainObject.d.ts b/types/lodash/ts3.1/fp/isPlainObject.d.ts new file mode 100644 index 0000000000..87da4bdb47 --- /dev/null +++ b/types/lodash/ts3.1/fp/isPlainObject.d.ts @@ -0,0 +1,2 @@ +import { isPlainObject } from "../fp"; +export = isPlainObject; diff --git a/types/lodash/ts3.1/fp/isRegExp.d.ts b/types/lodash/ts3.1/fp/isRegExp.d.ts new file mode 100644 index 0000000000..47edf50a1f --- /dev/null +++ b/types/lodash/ts3.1/fp/isRegExp.d.ts @@ -0,0 +1,2 @@ +import { isRegExp } from "../fp"; +export = isRegExp; diff --git a/types/lodash/ts3.1/fp/isSafeInteger.d.ts b/types/lodash/ts3.1/fp/isSafeInteger.d.ts new file mode 100644 index 0000000000..a32b12cfd8 --- /dev/null +++ b/types/lodash/ts3.1/fp/isSafeInteger.d.ts @@ -0,0 +1,2 @@ +import { isSafeInteger } from "../fp"; +export = isSafeInteger; diff --git a/types/lodash/ts3.1/fp/isSet.d.ts b/types/lodash/ts3.1/fp/isSet.d.ts new file mode 100644 index 0000000000..85e493338e --- /dev/null +++ b/types/lodash/ts3.1/fp/isSet.d.ts @@ -0,0 +1,2 @@ +import { isSet } from "../fp"; +export = isSet; diff --git a/types/lodash/ts3.1/fp/isString.d.ts b/types/lodash/ts3.1/fp/isString.d.ts new file mode 100644 index 0000000000..9a2149451d --- /dev/null +++ b/types/lodash/ts3.1/fp/isString.d.ts @@ -0,0 +1,2 @@ +import { isString } from "../fp"; +export = isString; diff --git a/types/lodash/ts3.1/fp/isSymbol.d.ts b/types/lodash/ts3.1/fp/isSymbol.d.ts new file mode 100644 index 0000000000..3d82e9719c --- /dev/null +++ b/types/lodash/ts3.1/fp/isSymbol.d.ts @@ -0,0 +1,2 @@ +import { isSymbol } from "../fp"; +export = isSymbol; diff --git a/types/lodash/ts3.1/fp/isTypedArray.d.ts b/types/lodash/ts3.1/fp/isTypedArray.d.ts new file mode 100644 index 0000000000..fce6c44a69 --- /dev/null +++ b/types/lodash/ts3.1/fp/isTypedArray.d.ts @@ -0,0 +1,2 @@ +import { isTypedArray } from "../fp"; +export = isTypedArray; diff --git a/types/lodash/ts3.1/fp/isUndefined.d.ts b/types/lodash/ts3.1/fp/isUndefined.d.ts new file mode 100644 index 0000000000..ccb010033b --- /dev/null +++ b/types/lodash/ts3.1/fp/isUndefined.d.ts @@ -0,0 +1,2 @@ +import { isUndefined } from "../fp"; +export = isUndefined; diff --git a/types/lodash/ts3.1/fp/isWeakMap.d.ts b/types/lodash/ts3.1/fp/isWeakMap.d.ts new file mode 100644 index 0000000000..11edaab05d --- /dev/null +++ b/types/lodash/ts3.1/fp/isWeakMap.d.ts @@ -0,0 +1,2 @@ +import { isWeakMap } from "../fp"; +export = isWeakMap; diff --git a/types/lodash/ts3.1/fp/isWeakSet.d.ts b/types/lodash/ts3.1/fp/isWeakSet.d.ts new file mode 100644 index 0000000000..6d877e9e23 --- /dev/null +++ b/types/lodash/ts3.1/fp/isWeakSet.d.ts @@ -0,0 +1,2 @@ +import { isWeakSet } from "../fp"; +export = isWeakSet; diff --git a/types/lodash/ts3.1/fp/iteratee.d.ts b/types/lodash/ts3.1/fp/iteratee.d.ts new file mode 100644 index 0000000000..0ec2832c84 --- /dev/null +++ b/types/lodash/ts3.1/fp/iteratee.d.ts @@ -0,0 +1,2 @@ +import { iteratee } from "../fp"; +export = iteratee; diff --git a/types/lodash/ts3.1/fp/join.d.ts b/types/lodash/ts3.1/fp/join.d.ts new file mode 100644 index 0000000000..beee04ccf5 --- /dev/null +++ b/types/lodash/ts3.1/fp/join.d.ts @@ -0,0 +1,2 @@ +import { join } from "../fp"; +export = join; diff --git a/types/lodash/ts3.1/fp/juxt.d.ts b/types/lodash/ts3.1/fp/juxt.d.ts new file mode 100644 index 0000000000..5e972d4488 --- /dev/null +++ b/types/lodash/ts3.1/fp/juxt.d.ts @@ -0,0 +1,2 @@ +import { juxt } from "../fp"; +export = juxt; diff --git a/types/lodash/ts3.1/fp/kebabCase.d.ts b/types/lodash/ts3.1/fp/kebabCase.d.ts new file mode 100644 index 0000000000..8231b1593a --- /dev/null +++ b/types/lodash/ts3.1/fp/kebabCase.d.ts @@ -0,0 +1,2 @@ +import { kebabCase } from "../fp"; +export = kebabCase; diff --git a/types/lodash/ts3.1/fp/keyBy.d.ts b/types/lodash/ts3.1/fp/keyBy.d.ts new file mode 100644 index 0000000000..e4b1381096 --- /dev/null +++ b/types/lodash/ts3.1/fp/keyBy.d.ts @@ -0,0 +1,2 @@ +import { keyBy } from "../fp"; +export = keyBy; diff --git a/types/lodash/ts3.1/fp/keys.d.ts b/types/lodash/ts3.1/fp/keys.d.ts new file mode 100644 index 0000000000..0323484453 --- /dev/null +++ b/types/lodash/ts3.1/fp/keys.d.ts @@ -0,0 +1,2 @@ +import { keys } from "../fp"; +export = keys; diff --git a/types/lodash/ts3.1/fp/keysIn.d.ts b/types/lodash/ts3.1/fp/keysIn.d.ts new file mode 100644 index 0000000000..f6f3482852 --- /dev/null +++ b/types/lodash/ts3.1/fp/keysIn.d.ts @@ -0,0 +1,2 @@ +import { keysIn } from "../fp"; +export = keysIn; diff --git a/types/lodash/ts3.1/fp/last.d.ts b/types/lodash/ts3.1/fp/last.d.ts new file mode 100644 index 0000000000..f74171a309 --- /dev/null +++ b/types/lodash/ts3.1/fp/last.d.ts @@ -0,0 +1,2 @@ +import { last } from "../fp"; +export = last; diff --git a/types/lodash/ts3.1/fp/lastIndexOf.d.ts b/types/lodash/ts3.1/fp/lastIndexOf.d.ts new file mode 100644 index 0000000000..2d60e64837 --- /dev/null +++ b/types/lodash/ts3.1/fp/lastIndexOf.d.ts @@ -0,0 +1,2 @@ +import { lastIndexOf } from "../fp"; +export = lastIndexOf; diff --git a/types/lodash/ts3.1/fp/lastIndexOfFrom.d.ts b/types/lodash/ts3.1/fp/lastIndexOfFrom.d.ts new file mode 100644 index 0000000000..7a2f23e5ae --- /dev/null +++ b/types/lodash/ts3.1/fp/lastIndexOfFrom.d.ts @@ -0,0 +1,2 @@ +import { lastIndexOfFrom } from "../fp"; +export = lastIndexOfFrom; diff --git a/types/lodash/ts3.1/fp/lowerCase.d.ts b/types/lodash/ts3.1/fp/lowerCase.d.ts new file mode 100644 index 0000000000..1a5360fdbc --- /dev/null +++ b/types/lodash/ts3.1/fp/lowerCase.d.ts @@ -0,0 +1,2 @@ +import { lowerCase } from "../fp"; +export = lowerCase; diff --git a/types/lodash/ts3.1/fp/lowerFirst.d.ts b/types/lodash/ts3.1/fp/lowerFirst.d.ts new file mode 100644 index 0000000000..23ce92585d --- /dev/null +++ b/types/lodash/ts3.1/fp/lowerFirst.d.ts @@ -0,0 +1,2 @@ +import { lowerFirst } from "../fp"; +export = lowerFirst; diff --git a/types/lodash/ts3.1/fp/lt.d.ts b/types/lodash/ts3.1/fp/lt.d.ts new file mode 100644 index 0000000000..a309bdce1a --- /dev/null +++ b/types/lodash/ts3.1/fp/lt.d.ts @@ -0,0 +1,2 @@ +import { lt } from "../fp"; +export = lt; diff --git a/types/lodash/ts3.1/fp/lte.d.ts b/types/lodash/ts3.1/fp/lte.d.ts new file mode 100644 index 0000000000..0d4af2cbe3 --- /dev/null +++ b/types/lodash/ts3.1/fp/lte.d.ts @@ -0,0 +1,2 @@ +import { lte } from "../fp"; +export = lte; diff --git a/types/lodash/ts3.1/fp/map.d.ts b/types/lodash/ts3.1/fp/map.d.ts new file mode 100644 index 0000000000..17d014caf4 --- /dev/null +++ b/types/lodash/ts3.1/fp/map.d.ts @@ -0,0 +1,2 @@ +import { map } from "../fp"; +export = map; diff --git a/types/lodash/ts3.1/fp/mapKeys.d.ts b/types/lodash/ts3.1/fp/mapKeys.d.ts new file mode 100644 index 0000000000..acc6d752d8 --- /dev/null +++ b/types/lodash/ts3.1/fp/mapKeys.d.ts @@ -0,0 +1,2 @@ +import { mapKeys } from "../fp"; +export = mapKeys; diff --git a/types/lodash/ts3.1/fp/mapValues.d.ts b/types/lodash/ts3.1/fp/mapValues.d.ts new file mode 100644 index 0000000000..abef821aab --- /dev/null +++ b/types/lodash/ts3.1/fp/mapValues.d.ts @@ -0,0 +1,2 @@ +import { mapValues } from "../fp"; +export = mapValues; diff --git a/types/lodash/ts3.1/fp/matches.d.ts b/types/lodash/ts3.1/fp/matches.d.ts new file mode 100644 index 0000000000..e9796de4fb --- /dev/null +++ b/types/lodash/ts3.1/fp/matches.d.ts @@ -0,0 +1,2 @@ +import { matches } from "../fp"; +export = matches; diff --git a/types/lodash/ts3.1/fp/matchesProperty.d.ts b/types/lodash/ts3.1/fp/matchesProperty.d.ts new file mode 100644 index 0000000000..81db8f75da --- /dev/null +++ b/types/lodash/ts3.1/fp/matchesProperty.d.ts @@ -0,0 +1,2 @@ +import { matchesProperty } from "../fp"; +export = matchesProperty; diff --git a/types/lodash/ts3.1/fp/max.d.ts b/types/lodash/ts3.1/fp/max.d.ts new file mode 100644 index 0000000000..7b08dc52c6 --- /dev/null +++ b/types/lodash/ts3.1/fp/max.d.ts @@ -0,0 +1,2 @@ +import { max } from "../fp"; +export = max; diff --git a/types/lodash/ts3.1/fp/maxBy.d.ts b/types/lodash/ts3.1/fp/maxBy.d.ts new file mode 100644 index 0000000000..68f30dd896 --- /dev/null +++ b/types/lodash/ts3.1/fp/maxBy.d.ts @@ -0,0 +1,2 @@ +import { maxBy } from "../fp"; +export = maxBy; diff --git a/types/lodash/ts3.1/fp/mean.d.ts b/types/lodash/ts3.1/fp/mean.d.ts new file mode 100644 index 0000000000..a0b7e22e5b --- /dev/null +++ b/types/lodash/ts3.1/fp/mean.d.ts @@ -0,0 +1,2 @@ +import { mean } from "../fp"; +export = mean; diff --git a/types/lodash/ts3.1/fp/meanBy.d.ts b/types/lodash/ts3.1/fp/meanBy.d.ts new file mode 100644 index 0000000000..d76afd77c1 --- /dev/null +++ b/types/lodash/ts3.1/fp/meanBy.d.ts @@ -0,0 +1,2 @@ +import { meanBy } from "../fp"; +export = meanBy; diff --git a/types/lodash/ts3.1/fp/memoize.d.ts b/types/lodash/ts3.1/fp/memoize.d.ts new file mode 100644 index 0000000000..a60b79cafa --- /dev/null +++ b/types/lodash/ts3.1/fp/memoize.d.ts @@ -0,0 +1,2 @@ +import { memoize } from "../fp"; +export = memoize; diff --git a/types/lodash/ts3.1/fp/merge.d.ts b/types/lodash/ts3.1/fp/merge.d.ts new file mode 100644 index 0000000000..f80117b7e9 --- /dev/null +++ b/types/lodash/ts3.1/fp/merge.d.ts @@ -0,0 +1,2 @@ +import { merge } from "../fp"; +export = merge; diff --git a/types/lodash/ts3.1/fp/mergeAll.d.ts b/types/lodash/ts3.1/fp/mergeAll.d.ts new file mode 100644 index 0000000000..6b462d85cb --- /dev/null +++ b/types/lodash/ts3.1/fp/mergeAll.d.ts @@ -0,0 +1,2 @@ +import { mergeAll } from "../fp"; +export = mergeAll; diff --git a/types/lodash/ts3.1/fp/mergeAllWith.d.ts b/types/lodash/ts3.1/fp/mergeAllWith.d.ts new file mode 100644 index 0000000000..3d2f7f296e --- /dev/null +++ b/types/lodash/ts3.1/fp/mergeAllWith.d.ts @@ -0,0 +1,2 @@ +import { mergeAllWith } from "../fp"; +export = mergeAllWith; diff --git a/types/lodash/ts3.1/fp/mergeWith.d.ts b/types/lodash/ts3.1/fp/mergeWith.d.ts new file mode 100644 index 0000000000..d1f541e81b --- /dev/null +++ b/types/lodash/ts3.1/fp/mergeWith.d.ts @@ -0,0 +1,2 @@ +import { mergeWith } from "../fp"; +export = mergeWith; diff --git a/types/lodash/ts3.1/fp/method.d.ts b/types/lodash/ts3.1/fp/method.d.ts new file mode 100644 index 0000000000..f9f2ee8795 --- /dev/null +++ b/types/lodash/ts3.1/fp/method.d.ts @@ -0,0 +1,2 @@ +import { method } from "../fp"; +export = method; diff --git a/types/lodash/ts3.1/fp/methodOf.d.ts b/types/lodash/ts3.1/fp/methodOf.d.ts new file mode 100644 index 0000000000..a9e0e4fe14 --- /dev/null +++ b/types/lodash/ts3.1/fp/methodOf.d.ts @@ -0,0 +1,2 @@ +import { methodOf } from "../fp"; +export = methodOf; diff --git a/types/lodash/ts3.1/fp/min.d.ts b/types/lodash/ts3.1/fp/min.d.ts new file mode 100644 index 0000000000..7c80ab0ff9 --- /dev/null +++ b/types/lodash/ts3.1/fp/min.d.ts @@ -0,0 +1,2 @@ +import { min } from "../fp"; +export = min; diff --git a/types/lodash/ts3.1/fp/minBy.d.ts b/types/lodash/ts3.1/fp/minBy.d.ts new file mode 100644 index 0000000000..020a8f506c --- /dev/null +++ b/types/lodash/ts3.1/fp/minBy.d.ts @@ -0,0 +1,2 @@ +import { minBy } from "../fp"; +export = minBy; diff --git a/types/lodash/ts3.1/fp/multiply.d.ts b/types/lodash/ts3.1/fp/multiply.d.ts new file mode 100644 index 0000000000..b3e5f3abd9 --- /dev/null +++ b/types/lodash/ts3.1/fp/multiply.d.ts @@ -0,0 +1,2 @@ +import { multiply } from "../fp"; +export = multiply; diff --git a/types/lodash/ts3.1/fp/nAry.d.ts b/types/lodash/ts3.1/fp/nAry.d.ts new file mode 100644 index 0000000000..882e4a37d6 --- /dev/null +++ b/types/lodash/ts3.1/fp/nAry.d.ts @@ -0,0 +1,2 @@ +import { nAry } from "../fp"; +export = nAry; diff --git a/types/lodash/ts3.1/fp/negate.d.ts b/types/lodash/ts3.1/fp/negate.d.ts new file mode 100644 index 0000000000..a7693c1928 --- /dev/null +++ b/types/lodash/ts3.1/fp/negate.d.ts @@ -0,0 +1,2 @@ +import { negate } from "../fp"; +export = negate; diff --git a/types/lodash/ts3.1/fp/noConflict.d.ts b/types/lodash/ts3.1/fp/noConflict.d.ts new file mode 100644 index 0000000000..7694f5aa5a --- /dev/null +++ b/types/lodash/ts3.1/fp/noConflict.d.ts @@ -0,0 +1,2 @@ +import { noConflict } from "../fp"; +export = noConflict; diff --git a/types/lodash/ts3.1/fp/noop.d.ts b/types/lodash/ts3.1/fp/noop.d.ts new file mode 100644 index 0000000000..5b6a27b61a --- /dev/null +++ b/types/lodash/ts3.1/fp/noop.d.ts @@ -0,0 +1,2 @@ +import { noop } from "../fp"; +export = noop; diff --git a/types/lodash/ts3.1/fp/now.d.ts b/types/lodash/ts3.1/fp/now.d.ts new file mode 100644 index 0000000000..fdbbd2bcf7 --- /dev/null +++ b/types/lodash/ts3.1/fp/now.d.ts @@ -0,0 +1,2 @@ +import { now } from "../fp"; +export = now; diff --git a/types/lodash/ts3.1/fp/nth.d.ts b/types/lodash/ts3.1/fp/nth.d.ts new file mode 100644 index 0000000000..e3987e17cb --- /dev/null +++ b/types/lodash/ts3.1/fp/nth.d.ts @@ -0,0 +1,2 @@ +import { nth } from "../fp"; +export = nth; diff --git a/types/lodash/ts3.1/fp/nthArg.d.ts b/types/lodash/ts3.1/fp/nthArg.d.ts new file mode 100644 index 0000000000..216c9bbab2 --- /dev/null +++ b/types/lodash/ts3.1/fp/nthArg.d.ts @@ -0,0 +1,2 @@ +import { nthArg } from "../fp"; +export = nthArg; diff --git a/types/lodash/ts3.1/fp/omit.d.ts b/types/lodash/ts3.1/fp/omit.d.ts new file mode 100644 index 0000000000..1cd1b7fcc3 --- /dev/null +++ b/types/lodash/ts3.1/fp/omit.d.ts @@ -0,0 +1,2 @@ +import { omit } from "../fp"; +export = omit; diff --git a/types/lodash/ts3.1/fp/omitAll.d.ts b/types/lodash/ts3.1/fp/omitAll.d.ts new file mode 100644 index 0000000000..dab5cfa5fc --- /dev/null +++ b/types/lodash/ts3.1/fp/omitAll.d.ts @@ -0,0 +1,2 @@ +import { omitAll } from "../fp"; +export = omitAll; diff --git a/types/lodash/ts3.1/fp/omitBy.d.ts b/types/lodash/ts3.1/fp/omitBy.d.ts new file mode 100644 index 0000000000..8be4f5b40b --- /dev/null +++ b/types/lodash/ts3.1/fp/omitBy.d.ts @@ -0,0 +1,2 @@ +import { omitBy } from "../fp"; +export = omitBy; diff --git a/types/lodash/ts3.1/fp/once.d.ts b/types/lodash/ts3.1/fp/once.d.ts new file mode 100644 index 0000000000..24d859cc53 --- /dev/null +++ b/types/lodash/ts3.1/fp/once.d.ts @@ -0,0 +1,2 @@ +import { once } from "../fp"; +export = once; diff --git a/types/lodash/ts3.1/fp/orderBy.d.ts b/types/lodash/ts3.1/fp/orderBy.d.ts new file mode 100644 index 0000000000..9443fcfc22 --- /dev/null +++ b/types/lodash/ts3.1/fp/orderBy.d.ts @@ -0,0 +1,2 @@ +import { orderBy } from "../fp"; +export = orderBy; diff --git a/types/lodash/ts3.1/fp/over.d.ts b/types/lodash/ts3.1/fp/over.d.ts new file mode 100644 index 0000000000..1bd2502fdc --- /dev/null +++ b/types/lodash/ts3.1/fp/over.d.ts @@ -0,0 +1,2 @@ +import { over } from "../fp"; +export = over; diff --git a/types/lodash/ts3.1/fp/overArgs.d.ts b/types/lodash/ts3.1/fp/overArgs.d.ts new file mode 100644 index 0000000000..c054c92707 --- /dev/null +++ b/types/lodash/ts3.1/fp/overArgs.d.ts @@ -0,0 +1,2 @@ +import { overArgs } from "../fp"; +export = overArgs; diff --git a/types/lodash/ts3.1/fp/overEvery.d.ts b/types/lodash/ts3.1/fp/overEvery.d.ts new file mode 100644 index 0000000000..1cf8b4061b --- /dev/null +++ b/types/lodash/ts3.1/fp/overEvery.d.ts @@ -0,0 +1,2 @@ +import { overEvery } from "../fp"; +export = overEvery; diff --git a/types/lodash/ts3.1/fp/overSome.d.ts b/types/lodash/ts3.1/fp/overSome.d.ts new file mode 100644 index 0000000000..6b098b73b3 --- /dev/null +++ b/types/lodash/ts3.1/fp/overSome.d.ts @@ -0,0 +1,2 @@ +import { overSome } from "../fp"; +export = overSome; diff --git a/types/lodash/ts3.1/fp/pad.d.ts b/types/lodash/ts3.1/fp/pad.d.ts new file mode 100644 index 0000000000..a5519771dd --- /dev/null +++ b/types/lodash/ts3.1/fp/pad.d.ts @@ -0,0 +1,2 @@ +import { pad } from "../fp"; +export = pad; diff --git a/types/lodash/ts3.1/fp/padChars.d.ts b/types/lodash/ts3.1/fp/padChars.d.ts new file mode 100644 index 0000000000..74d1aabbbf --- /dev/null +++ b/types/lodash/ts3.1/fp/padChars.d.ts @@ -0,0 +1,2 @@ +import { padChars } from "../fp"; +export = padChars; diff --git a/types/lodash/ts3.1/fp/padCharsEnd.d.ts b/types/lodash/ts3.1/fp/padCharsEnd.d.ts new file mode 100644 index 0000000000..3a468dc11f --- /dev/null +++ b/types/lodash/ts3.1/fp/padCharsEnd.d.ts @@ -0,0 +1,2 @@ +import { padCharsEnd } from "../fp"; +export = padCharsEnd; diff --git a/types/lodash/ts3.1/fp/padCharsStart.d.ts b/types/lodash/ts3.1/fp/padCharsStart.d.ts new file mode 100644 index 0000000000..a22523505f --- /dev/null +++ b/types/lodash/ts3.1/fp/padCharsStart.d.ts @@ -0,0 +1,2 @@ +import { padCharsStart } from "../fp"; +export = padCharsStart; diff --git a/types/lodash/ts3.1/fp/padEnd.d.ts b/types/lodash/ts3.1/fp/padEnd.d.ts new file mode 100644 index 0000000000..5c4e4d80ba --- /dev/null +++ b/types/lodash/ts3.1/fp/padEnd.d.ts @@ -0,0 +1,2 @@ +import { padEnd } from "../fp"; +export = padEnd; diff --git a/types/lodash/ts3.1/fp/padStart.d.ts b/types/lodash/ts3.1/fp/padStart.d.ts new file mode 100644 index 0000000000..a4fca5d1ec --- /dev/null +++ b/types/lodash/ts3.1/fp/padStart.d.ts @@ -0,0 +1,2 @@ +import { padStart } from "../fp"; +export = padStart; diff --git a/types/lodash/ts3.1/fp/parseInt.d.ts b/types/lodash/ts3.1/fp/parseInt.d.ts new file mode 100644 index 0000000000..47aff97b71 --- /dev/null +++ b/types/lodash/ts3.1/fp/parseInt.d.ts @@ -0,0 +1,2 @@ +import { parseInt } from "../fp"; +export = parseInt; diff --git a/types/lodash/ts3.1/fp/partial.d.ts b/types/lodash/ts3.1/fp/partial.d.ts new file mode 100644 index 0000000000..f5ebd726e5 --- /dev/null +++ b/types/lodash/ts3.1/fp/partial.d.ts @@ -0,0 +1,2 @@ +import { partial } from "../fp"; +export = partial; diff --git a/types/lodash/ts3.1/fp/partialRight.d.ts b/types/lodash/ts3.1/fp/partialRight.d.ts new file mode 100644 index 0000000000..bc0fa1b9c6 --- /dev/null +++ b/types/lodash/ts3.1/fp/partialRight.d.ts @@ -0,0 +1,2 @@ +import { partialRight } from "../fp"; +export = partialRight; diff --git a/types/lodash/ts3.1/fp/partition.d.ts b/types/lodash/ts3.1/fp/partition.d.ts new file mode 100644 index 0000000000..6ad41cd7db --- /dev/null +++ b/types/lodash/ts3.1/fp/partition.d.ts @@ -0,0 +1,2 @@ +import { partition } from "../fp"; +export = partition; diff --git a/types/lodash/ts3.1/fp/path.d.ts b/types/lodash/ts3.1/fp/path.d.ts new file mode 100644 index 0000000000..db86d6023d --- /dev/null +++ b/types/lodash/ts3.1/fp/path.d.ts @@ -0,0 +1,2 @@ +import { path } from "../fp"; +export = path; diff --git a/types/lodash/ts3.1/fp/pathEq.d.ts b/types/lodash/ts3.1/fp/pathEq.d.ts new file mode 100644 index 0000000000..9f328756c3 --- /dev/null +++ b/types/lodash/ts3.1/fp/pathEq.d.ts @@ -0,0 +1,2 @@ +import { pathEq } from "../fp"; +export = pathEq; diff --git a/types/lodash/ts3.1/fp/pathOr.d.ts b/types/lodash/ts3.1/fp/pathOr.d.ts new file mode 100644 index 0000000000..6cad6b1836 --- /dev/null +++ b/types/lodash/ts3.1/fp/pathOr.d.ts @@ -0,0 +1,2 @@ +import { pathOr } from "../fp"; +export = pathOr; diff --git a/types/lodash/ts3.1/fp/paths.d.ts b/types/lodash/ts3.1/fp/paths.d.ts new file mode 100644 index 0000000000..1e6eb8908f --- /dev/null +++ b/types/lodash/ts3.1/fp/paths.d.ts @@ -0,0 +1,2 @@ +import { paths } from "../fp"; +export = paths; diff --git a/types/lodash/ts3.1/fp/pick.d.ts b/types/lodash/ts3.1/fp/pick.d.ts new file mode 100644 index 0000000000..4772ecacc3 --- /dev/null +++ b/types/lodash/ts3.1/fp/pick.d.ts @@ -0,0 +1,2 @@ +import { pick } from "../fp"; +export = pick; diff --git a/types/lodash/ts3.1/fp/pickAll.d.ts b/types/lodash/ts3.1/fp/pickAll.d.ts new file mode 100644 index 0000000000..38d2e3fe2b --- /dev/null +++ b/types/lodash/ts3.1/fp/pickAll.d.ts @@ -0,0 +1,2 @@ +import { pickAll } from "../fp"; +export = pickAll; diff --git a/types/lodash/ts3.1/fp/pickBy.d.ts b/types/lodash/ts3.1/fp/pickBy.d.ts new file mode 100644 index 0000000000..0b192629e0 --- /dev/null +++ b/types/lodash/ts3.1/fp/pickBy.d.ts @@ -0,0 +1,2 @@ +import { pickBy } from "../fp"; +export = pickBy; diff --git a/types/lodash/ts3.1/fp/pipe.d.ts b/types/lodash/ts3.1/fp/pipe.d.ts new file mode 100644 index 0000000000..a53a04823b --- /dev/null +++ b/types/lodash/ts3.1/fp/pipe.d.ts @@ -0,0 +1,2 @@ +import { pipe } from "../fp"; +export = pipe; diff --git a/types/lodash/ts3.1/fp/placeholder.d.ts b/types/lodash/ts3.1/fp/placeholder.d.ts new file mode 100644 index 0000000000..ddaed8ed1b --- /dev/null +++ b/types/lodash/ts3.1/fp/placeholder.d.ts @@ -0,0 +1,3 @@ +import _ = require("../index"); +declare const placeholder: _.__; +export = placeholder; diff --git a/types/lodash/ts3.1/fp/pluck.d.ts b/types/lodash/ts3.1/fp/pluck.d.ts new file mode 100644 index 0000000000..c5c916f814 --- /dev/null +++ b/types/lodash/ts3.1/fp/pluck.d.ts @@ -0,0 +1,2 @@ +import { pluck } from "../fp"; +export = pluck; diff --git a/types/lodash/ts3.1/fp/prop.d.ts b/types/lodash/ts3.1/fp/prop.d.ts new file mode 100644 index 0000000000..f2061e7d61 --- /dev/null +++ b/types/lodash/ts3.1/fp/prop.d.ts @@ -0,0 +1,2 @@ +import { prop } from "../fp"; +export = prop; diff --git a/types/lodash/ts3.1/fp/propEq.d.ts b/types/lodash/ts3.1/fp/propEq.d.ts new file mode 100644 index 0000000000..5e3f4b413f --- /dev/null +++ b/types/lodash/ts3.1/fp/propEq.d.ts @@ -0,0 +1,2 @@ +import { propEq } from "../fp"; +export = propEq; diff --git a/types/lodash/ts3.1/fp/propOr.d.ts b/types/lodash/ts3.1/fp/propOr.d.ts new file mode 100644 index 0000000000..feabcf6e95 --- /dev/null +++ b/types/lodash/ts3.1/fp/propOr.d.ts @@ -0,0 +1,2 @@ +import { propOr } from "../fp"; +export = propOr; diff --git a/types/lodash/ts3.1/fp/property.d.ts b/types/lodash/ts3.1/fp/property.d.ts new file mode 100644 index 0000000000..aaa6c25711 --- /dev/null +++ b/types/lodash/ts3.1/fp/property.d.ts @@ -0,0 +1,2 @@ +import { property } from "../fp"; +export = property; diff --git a/types/lodash/ts3.1/fp/propertyOf.d.ts b/types/lodash/ts3.1/fp/propertyOf.d.ts new file mode 100644 index 0000000000..a4d55130c6 --- /dev/null +++ b/types/lodash/ts3.1/fp/propertyOf.d.ts @@ -0,0 +1,2 @@ +import { propertyOf } from "../fp"; +export = propertyOf; diff --git a/types/lodash/ts3.1/fp/props.d.ts b/types/lodash/ts3.1/fp/props.d.ts new file mode 100644 index 0000000000..46addba7ad --- /dev/null +++ b/types/lodash/ts3.1/fp/props.d.ts @@ -0,0 +1,2 @@ +import { props } from "../fp"; +export = props; diff --git a/types/lodash/ts3.1/fp/pull.d.ts b/types/lodash/ts3.1/fp/pull.d.ts new file mode 100644 index 0000000000..801cf33771 --- /dev/null +++ b/types/lodash/ts3.1/fp/pull.d.ts @@ -0,0 +1,2 @@ +import { pull } from "../fp"; +export = pull; diff --git a/types/lodash/ts3.1/fp/pullAll.d.ts b/types/lodash/ts3.1/fp/pullAll.d.ts new file mode 100644 index 0000000000..042fe89ac1 --- /dev/null +++ b/types/lodash/ts3.1/fp/pullAll.d.ts @@ -0,0 +1,2 @@ +import { pullAll } from "../fp"; +export = pullAll; diff --git a/types/lodash/ts3.1/fp/pullAllBy.d.ts b/types/lodash/ts3.1/fp/pullAllBy.d.ts new file mode 100644 index 0000000000..5e5de1fc07 --- /dev/null +++ b/types/lodash/ts3.1/fp/pullAllBy.d.ts @@ -0,0 +1,2 @@ +import { pullAllBy } from "../fp"; +export = pullAllBy; diff --git a/types/lodash/ts3.1/fp/pullAllWith.d.ts b/types/lodash/ts3.1/fp/pullAllWith.d.ts new file mode 100644 index 0000000000..0c448bf8c8 --- /dev/null +++ b/types/lodash/ts3.1/fp/pullAllWith.d.ts @@ -0,0 +1,2 @@ +import { pullAllWith } from "../fp"; +export = pullAllWith; diff --git a/types/lodash/ts3.1/fp/pullAt.d.ts b/types/lodash/ts3.1/fp/pullAt.d.ts new file mode 100644 index 0000000000..4bdffd993f --- /dev/null +++ b/types/lodash/ts3.1/fp/pullAt.d.ts @@ -0,0 +1,2 @@ +import { pullAt } from "../fp"; +export = pullAt; diff --git a/types/lodash/ts3.1/fp/random.d.ts b/types/lodash/ts3.1/fp/random.d.ts new file mode 100644 index 0000000000..a69555ca16 --- /dev/null +++ b/types/lodash/ts3.1/fp/random.d.ts @@ -0,0 +1,2 @@ +import { random } from "../fp"; +export = random; diff --git a/types/lodash/ts3.1/fp/range.d.ts b/types/lodash/ts3.1/fp/range.d.ts new file mode 100644 index 0000000000..ace50ce46b --- /dev/null +++ b/types/lodash/ts3.1/fp/range.d.ts @@ -0,0 +1,2 @@ +import { range } from "../fp"; +export = range; diff --git a/types/lodash/ts3.1/fp/rangeRight.d.ts b/types/lodash/ts3.1/fp/rangeRight.d.ts new file mode 100644 index 0000000000..20c8baefaa --- /dev/null +++ b/types/lodash/ts3.1/fp/rangeRight.d.ts @@ -0,0 +1,2 @@ +import { rangeRight } from "../fp"; +export = rangeRight; diff --git a/types/lodash/ts3.1/fp/rangeStep.d.ts b/types/lodash/ts3.1/fp/rangeStep.d.ts new file mode 100644 index 0000000000..e5f4c891ce --- /dev/null +++ b/types/lodash/ts3.1/fp/rangeStep.d.ts @@ -0,0 +1,2 @@ +import { rangeStep } from "../fp"; +export = rangeStep; diff --git a/types/lodash/ts3.1/fp/rangeStepRight.d.ts b/types/lodash/ts3.1/fp/rangeStepRight.d.ts new file mode 100644 index 0000000000..6c7add468d --- /dev/null +++ b/types/lodash/ts3.1/fp/rangeStepRight.d.ts @@ -0,0 +1,2 @@ +import { rangeStepRight } from "../fp"; +export = rangeStepRight; diff --git a/types/lodash/ts3.1/fp/rearg.d.ts b/types/lodash/ts3.1/fp/rearg.d.ts new file mode 100644 index 0000000000..5c407d13a4 --- /dev/null +++ b/types/lodash/ts3.1/fp/rearg.d.ts @@ -0,0 +1,2 @@ +import { rearg } from "../fp"; +export = rearg; diff --git a/types/lodash/ts3.1/fp/reduce.d.ts b/types/lodash/ts3.1/fp/reduce.d.ts new file mode 100644 index 0000000000..e262f39370 --- /dev/null +++ b/types/lodash/ts3.1/fp/reduce.d.ts @@ -0,0 +1,2 @@ +import { reduce } from "../fp"; +export = reduce; diff --git a/types/lodash/ts3.1/fp/reduceRight.d.ts b/types/lodash/ts3.1/fp/reduceRight.d.ts new file mode 100644 index 0000000000..fa54fa3a5e --- /dev/null +++ b/types/lodash/ts3.1/fp/reduceRight.d.ts @@ -0,0 +1,2 @@ +import { reduceRight } from "../fp"; +export = reduceRight; diff --git a/types/lodash/ts3.1/fp/reject.d.ts b/types/lodash/ts3.1/fp/reject.d.ts new file mode 100644 index 0000000000..d0a12af963 --- /dev/null +++ b/types/lodash/ts3.1/fp/reject.d.ts @@ -0,0 +1,2 @@ +import { reject } from "../fp"; +export = reject; diff --git a/types/lodash/ts3.1/fp/remove.d.ts b/types/lodash/ts3.1/fp/remove.d.ts new file mode 100644 index 0000000000..e0da9b147c --- /dev/null +++ b/types/lodash/ts3.1/fp/remove.d.ts @@ -0,0 +1,2 @@ +import { remove } from "../fp"; +export = remove; diff --git a/types/lodash/ts3.1/fp/repeat.d.ts b/types/lodash/ts3.1/fp/repeat.d.ts new file mode 100644 index 0000000000..1f757a2778 --- /dev/null +++ b/types/lodash/ts3.1/fp/repeat.d.ts @@ -0,0 +1,2 @@ +import { repeat } from "../fp"; +export = repeat; diff --git a/types/lodash/ts3.1/fp/replace.d.ts b/types/lodash/ts3.1/fp/replace.d.ts new file mode 100644 index 0000000000..c7a75d1fa1 --- /dev/null +++ b/types/lodash/ts3.1/fp/replace.d.ts @@ -0,0 +1,2 @@ +import { replace } from "../fp"; +export = replace; diff --git a/types/lodash/ts3.1/fp/rest.d.ts b/types/lodash/ts3.1/fp/rest.d.ts new file mode 100644 index 0000000000..b059d673e1 --- /dev/null +++ b/types/lodash/ts3.1/fp/rest.d.ts @@ -0,0 +1,2 @@ +import { rest } from "../fp"; +export = rest; diff --git a/types/lodash/ts3.1/fp/restFrom.d.ts b/types/lodash/ts3.1/fp/restFrom.d.ts new file mode 100644 index 0000000000..218edbd5a3 --- /dev/null +++ b/types/lodash/ts3.1/fp/restFrom.d.ts @@ -0,0 +1,2 @@ +import { restFrom } from "../fp"; +export = restFrom; diff --git a/types/lodash/ts3.1/fp/result.d.ts b/types/lodash/ts3.1/fp/result.d.ts new file mode 100644 index 0000000000..5a919dd455 --- /dev/null +++ b/types/lodash/ts3.1/fp/result.d.ts @@ -0,0 +1,2 @@ +import { result } from "../fp"; +export = result; diff --git a/types/lodash/ts3.1/fp/reverse.d.ts b/types/lodash/ts3.1/fp/reverse.d.ts new file mode 100644 index 0000000000..f754d6aac6 --- /dev/null +++ b/types/lodash/ts3.1/fp/reverse.d.ts @@ -0,0 +1,2 @@ +import { reverse } from "../fp"; +export = reverse; diff --git a/types/lodash/ts3.1/fp/round.d.ts b/types/lodash/ts3.1/fp/round.d.ts new file mode 100644 index 0000000000..02f4e6f300 --- /dev/null +++ b/types/lodash/ts3.1/fp/round.d.ts @@ -0,0 +1,2 @@ +import { round } from "../fp"; +export = round; diff --git a/types/lodash/ts3.1/fp/runInContext.d.ts b/types/lodash/ts3.1/fp/runInContext.d.ts new file mode 100644 index 0000000000..6041db7053 --- /dev/null +++ b/types/lodash/ts3.1/fp/runInContext.d.ts @@ -0,0 +1,2 @@ +import { runInContext } from "../fp"; +export = runInContext; diff --git a/types/lodash/ts3.1/fp/sample.d.ts b/types/lodash/ts3.1/fp/sample.d.ts new file mode 100644 index 0000000000..f2fcf1ac03 --- /dev/null +++ b/types/lodash/ts3.1/fp/sample.d.ts @@ -0,0 +1,2 @@ +import { sample } from "../fp"; +export = sample; diff --git a/types/lodash/ts3.1/fp/sampleSize.d.ts b/types/lodash/ts3.1/fp/sampleSize.d.ts new file mode 100644 index 0000000000..41a3cabf92 --- /dev/null +++ b/types/lodash/ts3.1/fp/sampleSize.d.ts @@ -0,0 +1,2 @@ +import { sampleSize } from "../fp"; +export = sampleSize; diff --git a/types/lodash/ts3.1/fp/set.d.ts b/types/lodash/ts3.1/fp/set.d.ts new file mode 100644 index 0000000000..57960cba78 --- /dev/null +++ b/types/lodash/ts3.1/fp/set.d.ts @@ -0,0 +1,2 @@ +import { set } from "../fp"; +export = set; diff --git a/types/lodash/ts3.1/fp/setWith.d.ts b/types/lodash/ts3.1/fp/setWith.d.ts new file mode 100644 index 0000000000..800a49429c --- /dev/null +++ b/types/lodash/ts3.1/fp/setWith.d.ts @@ -0,0 +1,2 @@ +import { setWith } from "../fp"; +export = setWith; diff --git a/types/lodash/ts3.1/fp/shuffle.d.ts b/types/lodash/ts3.1/fp/shuffle.d.ts new file mode 100644 index 0000000000..7f07282642 --- /dev/null +++ b/types/lodash/ts3.1/fp/shuffle.d.ts @@ -0,0 +1,2 @@ +import { shuffle } from "../fp"; +export = shuffle; diff --git a/types/lodash/ts3.1/fp/size.d.ts b/types/lodash/ts3.1/fp/size.d.ts new file mode 100644 index 0000000000..657c8b7c20 --- /dev/null +++ b/types/lodash/ts3.1/fp/size.d.ts @@ -0,0 +1,2 @@ +import { size } from "../fp"; +export = size; diff --git a/types/lodash/ts3.1/fp/slice.d.ts b/types/lodash/ts3.1/fp/slice.d.ts new file mode 100644 index 0000000000..fabbbe0eeb --- /dev/null +++ b/types/lodash/ts3.1/fp/slice.d.ts @@ -0,0 +1,2 @@ +import { slice } from "../fp"; +export = slice; diff --git a/types/lodash/ts3.1/fp/snakeCase.d.ts b/types/lodash/ts3.1/fp/snakeCase.d.ts new file mode 100644 index 0000000000..a06ac452fe --- /dev/null +++ b/types/lodash/ts3.1/fp/snakeCase.d.ts @@ -0,0 +1,2 @@ +import { snakeCase } from "../fp"; +export = snakeCase; diff --git a/types/lodash/ts3.1/fp/some.d.ts b/types/lodash/ts3.1/fp/some.d.ts new file mode 100644 index 0000000000..870b23160d --- /dev/null +++ b/types/lodash/ts3.1/fp/some.d.ts @@ -0,0 +1,2 @@ +import { some } from "../fp"; +export = some; diff --git a/types/lodash/ts3.1/fp/sortBy.d.ts b/types/lodash/ts3.1/fp/sortBy.d.ts new file mode 100644 index 0000000000..72c5799b36 --- /dev/null +++ b/types/lodash/ts3.1/fp/sortBy.d.ts @@ -0,0 +1,2 @@ +import { sortBy } from "../fp"; +export = sortBy; diff --git a/types/lodash/ts3.1/fp/sortedIndex.d.ts b/types/lodash/ts3.1/fp/sortedIndex.d.ts new file mode 100644 index 0000000000..35b57feed2 --- /dev/null +++ b/types/lodash/ts3.1/fp/sortedIndex.d.ts @@ -0,0 +1,2 @@ +import { sortedIndex } from "../fp"; +export = sortedIndex; diff --git a/types/lodash/ts3.1/fp/sortedIndexBy.d.ts b/types/lodash/ts3.1/fp/sortedIndexBy.d.ts new file mode 100644 index 0000000000..f6968df691 --- /dev/null +++ b/types/lodash/ts3.1/fp/sortedIndexBy.d.ts @@ -0,0 +1,2 @@ +import { sortedIndexBy } from "../fp"; +export = sortedIndexBy; diff --git a/types/lodash/ts3.1/fp/sortedIndexOf.d.ts b/types/lodash/ts3.1/fp/sortedIndexOf.d.ts new file mode 100644 index 0000000000..beeb6db0ca --- /dev/null +++ b/types/lodash/ts3.1/fp/sortedIndexOf.d.ts @@ -0,0 +1,2 @@ +import { sortedIndexOf } from "../fp"; +export = sortedIndexOf; diff --git a/types/lodash/ts3.1/fp/sortedLastIndex.d.ts b/types/lodash/ts3.1/fp/sortedLastIndex.d.ts new file mode 100644 index 0000000000..eea77a0382 --- /dev/null +++ b/types/lodash/ts3.1/fp/sortedLastIndex.d.ts @@ -0,0 +1,2 @@ +import { sortedLastIndex } from "../fp"; +export = sortedLastIndex; diff --git a/types/lodash/ts3.1/fp/sortedLastIndexBy.d.ts b/types/lodash/ts3.1/fp/sortedLastIndexBy.d.ts new file mode 100644 index 0000000000..6c8e4ee545 --- /dev/null +++ b/types/lodash/ts3.1/fp/sortedLastIndexBy.d.ts @@ -0,0 +1,2 @@ +import { sortedLastIndexBy } from "../fp"; +export = sortedLastIndexBy; diff --git a/types/lodash/ts3.1/fp/sortedLastIndexOf.d.ts b/types/lodash/ts3.1/fp/sortedLastIndexOf.d.ts new file mode 100644 index 0000000000..a02caf3ce5 --- /dev/null +++ b/types/lodash/ts3.1/fp/sortedLastIndexOf.d.ts @@ -0,0 +1,2 @@ +import { sortedLastIndexOf } from "../fp"; +export = sortedLastIndexOf; diff --git a/types/lodash/ts3.1/fp/sortedUniq.d.ts b/types/lodash/ts3.1/fp/sortedUniq.d.ts new file mode 100644 index 0000000000..03d8e691e0 --- /dev/null +++ b/types/lodash/ts3.1/fp/sortedUniq.d.ts @@ -0,0 +1,2 @@ +import { sortedUniq } from "../fp"; +export = sortedUniq; diff --git a/types/lodash/ts3.1/fp/sortedUniqBy.d.ts b/types/lodash/ts3.1/fp/sortedUniqBy.d.ts new file mode 100644 index 0000000000..466981a264 --- /dev/null +++ b/types/lodash/ts3.1/fp/sortedUniqBy.d.ts @@ -0,0 +1,2 @@ +import { sortedUniqBy } from "../fp"; +export = sortedUniqBy; diff --git a/types/lodash/ts3.1/fp/split.d.ts b/types/lodash/ts3.1/fp/split.d.ts new file mode 100644 index 0000000000..8274d4081f --- /dev/null +++ b/types/lodash/ts3.1/fp/split.d.ts @@ -0,0 +1,2 @@ +import { split } from "../fp"; +export = split; diff --git a/types/lodash/ts3.1/fp/spread.d.ts b/types/lodash/ts3.1/fp/spread.d.ts new file mode 100644 index 0000000000..44eb90cd21 --- /dev/null +++ b/types/lodash/ts3.1/fp/spread.d.ts @@ -0,0 +1,2 @@ +import { spread } from "../fp"; +export = spread; diff --git a/types/lodash/ts3.1/fp/spreadFrom.d.ts b/types/lodash/ts3.1/fp/spreadFrom.d.ts new file mode 100644 index 0000000000..7eb840b036 --- /dev/null +++ b/types/lodash/ts3.1/fp/spreadFrom.d.ts @@ -0,0 +1,2 @@ +import { spreadFrom } from "../fp"; +export = spreadFrom; diff --git a/types/lodash/ts3.1/fp/startCase.d.ts b/types/lodash/ts3.1/fp/startCase.d.ts new file mode 100644 index 0000000000..4f580aa5d0 --- /dev/null +++ b/types/lodash/ts3.1/fp/startCase.d.ts @@ -0,0 +1,2 @@ +import { startCase } from "../fp"; +export = startCase; diff --git a/types/lodash/ts3.1/fp/startsWith.d.ts b/types/lodash/ts3.1/fp/startsWith.d.ts new file mode 100644 index 0000000000..f84397dc68 --- /dev/null +++ b/types/lodash/ts3.1/fp/startsWith.d.ts @@ -0,0 +1,2 @@ +import { startsWith } from "../fp"; +export = startsWith; diff --git a/types/lodash/ts3.1/fp/stubArray.d.ts b/types/lodash/ts3.1/fp/stubArray.d.ts new file mode 100644 index 0000000000..8ff910e591 --- /dev/null +++ b/types/lodash/ts3.1/fp/stubArray.d.ts @@ -0,0 +1,2 @@ +import { stubArray } from "../fp"; +export = stubArray; diff --git a/types/lodash/ts3.1/fp/stubFalse.d.ts b/types/lodash/ts3.1/fp/stubFalse.d.ts new file mode 100644 index 0000000000..4cc041482d --- /dev/null +++ b/types/lodash/ts3.1/fp/stubFalse.d.ts @@ -0,0 +1,2 @@ +import { stubFalse } from "../fp"; +export = stubFalse; diff --git a/types/lodash/ts3.1/fp/stubObject.d.ts b/types/lodash/ts3.1/fp/stubObject.d.ts new file mode 100644 index 0000000000..d7c826997f --- /dev/null +++ b/types/lodash/ts3.1/fp/stubObject.d.ts @@ -0,0 +1,2 @@ +import { stubObject } from "../fp"; +export = stubObject; diff --git a/types/lodash/ts3.1/fp/stubString.d.ts b/types/lodash/ts3.1/fp/stubString.d.ts new file mode 100644 index 0000000000..cbfa449758 --- /dev/null +++ b/types/lodash/ts3.1/fp/stubString.d.ts @@ -0,0 +1,2 @@ +import { stubString } from "../fp"; +export = stubString; diff --git a/types/lodash/ts3.1/fp/stubTrue.d.ts b/types/lodash/ts3.1/fp/stubTrue.d.ts new file mode 100644 index 0000000000..0ed7e5b927 --- /dev/null +++ b/types/lodash/ts3.1/fp/stubTrue.d.ts @@ -0,0 +1,2 @@ +import { stubTrue } from "../fp"; +export = stubTrue; diff --git a/types/lodash/ts3.1/fp/subtract.d.ts b/types/lodash/ts3.1/fp/subtract.d.ts new file mode 100644 index 0000000000..201301b300 --- /dev/null +++ b/types/lodash/ts3.1/fp/subtract.d.ts @@ -0,0 +1,2 @@ +import { subtract } from "../fp"; +export = subtract; diff --git a/types/lodash/ts3.1/fp/sum.d.ts b/types/lodash/ts3.1/fp/sum.d.ts new file mode 100644 index 0000000000..6d7d02026e --- /dev/null +++ b/types/lodash/ts3.1/fp/sum.d.ts @@ -0,0 +1,2 @@ +import { sum } from "../fp"; +export = sum; diff --git a/types/lodash/ts3.1/fp/sumBy.d.ts b/types/lodash/ts3.1/fp/sumBy.d.ts new file mode 100644 index 0000000000..3f44c3f6c5 --- /dev/null +++ b/types/lodash/ts3.1/fp/sumBy.d.ts @@ -0,0 +1,2 @@ +import { sumBy } from "../fp"; +export = sumBy; diff --git a/types/lodash/ts3.1/fp/symmetricDifference.d.ts b/types/lodash/ts3.1/fp/symmetricDifference.d.ts new file mode 100644 index 0000000000..cba1d1f70d --- /dev/null +++ b/types/lodash/ts3.1/fp/symmetricDifference.d.ts @@ -0,0 +1,2 @@ +import { symmetricDifference } from "../fp"; +export = symmetricDifference; diff --git a/types/lodash/ts3.1/fp/symmetricDifferenceBy.d.ts b/types/lodash/ts3.1/fp/symmetricDifferenceBy.d.ts new file mode 100644 index 0000000000..8e9316cf42 --- /dev/null +++ b/types/lodash/ts3.1/fp/symmetricDifferenceBy.d.ts @@ -0,0 +1,2 @@ +import { symmetricDifferenceBy } from "../fp"; +export = symmetricDifferenceBy; diff --git a/types/lodash/ts3.1/fp/symmetricDifferenceWith.d.ts b/types/lodash/ts3.1/fp/symmetricDifferenceWith.d.ts new file mode 100644 index 0000000000..864ec01b50 --- /dev/null +++ b/types/lodash/ts3.1/fp/symmetricDifferenceWith.d.ts @@ -0,0 +1,2 @@ +import { symmetricDifferenceWith } from "../fp"; +export = symmetricDifferenceWith; diff --git a/types/lodash/ts3.1/fp/tail.d.ts b/types/lodash/ts3.1/fp/tail.d.ts new file mode 100644 index 0000000000..df9bcdcd57 --- /dev/null +++ b/types/lodash/ts3.1/fp/tail.d.ts @@ -0,0 +1,2 @@ +import { tail } from "../fp"; +export = tail; diff --git a/types/lodash/ts3.1/fp/take.d.ts b/types/lodash/ts3.1/fp/take.d.ts new file mode 100644 index 0000000000..ab46aca056 --- /dev/null +++ b/types/lodash/ts3.1/fp/take.d.ts @@ -0,0 +1,2 @@ +import { take } from "../fp"; +export = take; diff --git a/types/lodash/ts3.1/fp/takeLast.d.ts b/types/lodash/ts3.1/fp/takeLast.d.ts new file mode 100644 index 0000000000..027dcda5ee --- /dev/null +++ b/types/lodash/ts3.1/fp/takeLast.d.ts @@ -0,0 +1,2 @@ +import { takeLast } from "../fp"; +export = takeLast; diff --git a/types/lodash/ts3.1/fp/takeLastWhile.d.ts b/types/lodash/ts3.1/fp/takeLastWhile.d.ts new file mode 100644 index 0000000000..c6729c3529 --- /dev/null +++ b/types/lodash/ts3.1/fp/takeLastWhile.d.ts @@ -0,0 +1,2 @@ +import { takeLastWhile } from "../fp"; +export = takeLastWhile; diff --git a/types/lodash/ts3.1/fp/takeRight.d.ts b/types/lodash/ts3.1/fp/takeRight.d.ts new file mode 100644 index 0000000000..162c5166e4 --- /dev/null +++ b/types/lodash/ts3.1/fp/takeRight.d.ts @@ -0,0 +1,2 @@ +import { takeRight } from "../fp"; +export = takeRight; diff --git a/types/lodash/ts3.1/fp/takeRightWhile.d.ts b/types/lodash/ts3.1/fp/takeRightWhile.d.ts new file mode 100644 index 0000000000..b23f7a4608 --- /dev/null +++ b/types/lodash/ts3.1/fp/takeRightWhile.d.ts @@ -0,0 +1,2 @@ +import { takeRightWhile } from "../fp"; +export = takeRightWhile; diff --git a/types/lodash/ts3.1/fp/takeWhile.d.ts b/types/lodash/ts3.1/fp/takeWhile.d.ts new file mode 100644 index 0000000000..b8cb517606 --- /dev/null +++ b/types/lodash/ts3.1/fp/takeWhile.d.ts @@ -0,0 +1,2 @@ +import { takeWhile } from "../fp"; +export = takeWhile; diff --git a/types/lodash/ts3.1/fp/tap.d.ts b/types/lodash/ts3.1/fp/tap.d.ts new file mode 100644 index 0000000000..8ffbbd7f23 --- /dev/null +++ b/types/lodash/ts3.1/fp/tap.d.ts @@ -0,0 +1,2 @@ +import { tap } from "../fp"; +export = tap; diff --git a/types/lodash/ts3.1/fp/template.d.ts b/types/lodash/ts3.1/fp/template.d.ts new file mode 100644 index 0000000000..3a37ed1af7 --- /dev/null +++ b/types/lodash/ts3.1/fp/template.d.ts @@ -0,0 +1,2 @@ +import { template } from "../fp"; +export = template; diff --git a/types/lodash/ts3.1/fp/throttle.d.ts b/types/lodash/ts3.1/fp/throttle.d.ts new file mode 100644 index 0000000000..24d8b7f4ef --- /dev/null +++ b/types/lodash/ts3.1/fp/throttle.d.ts @@ -0,0 +1,2 @@ +import { throttle } from "../fp"; +export = throttle; diff --git a/types/lodash/ts3.1/fp/thru.d.ts b/types/lodash/ts3.1/fp/thru.d.ts new file mode 100644 index 0000000000..b9725820ad --- /dev/null +++ b/types/lodash/ts3.1/fp/thru.d.ts @@ -0,0 +1,2 @@ +import { thru } from "../fp"; +export = thru; diff --git a/types/lodash/ts3.1/fp/times.d.ts b/types/lodash/ts3.1/fp/times.d.ts new file mode 100644 index 0000000000..3d9f0c6077 --- /dev/null +++ b/types/lodash/ts3.1/fp/times.d.ts @@ -0,0 +1,2 @@ +import { times } from "../fp"; +export = times; diff --git a/types/lodash/ts3.1/fp/toArray.d.ts b/types/lodash/ts3.1/fp/toArray.d.ts new file mode 100644 index 0000000000..4b18ce6d55 --- /dev/null +++ b/types/lodash/ts3.1/fp/toArray.d.ts @@ -0,0 +1,2 @@ +import { toArray } from "../fp"; +export = toArray; diff --git a/types/lodash/ts3.1/fp/toFinite.d.ts b/types/lodash/ts3.1/fp/toFinite.d.ts new file mode 100644 index 0000000000..1d41996182 --- /dev/null +++ b/types/lodash/ts3.1/fp/toFinite.d.ts @@ -0,0 +1,2 @@ +import { toFinite } from "../fp"; +export = toFinite; diff --git a/types/lodash/ts3.1/fp/toInteger.d.ts b/types/lodash/ts3.1/fp/toInteger.d.ts new file mode 100644 index 0000000000..46ccaf945b --- /dev/null +++ b/types/lodash/ts3.1/fp/toInteger.d.ts @@ -0,0 +1,2 @@ +import { toInteger } from "../fp"; +export = toInteger; diff --git a/types/lodash/ts3.1/fp/toLength.d.ts b/types/lodash/ts3.1/fp/toLength.d.ts new file mode 100644 index 0000000000..bb62924318 --- /dev/null +++ b/types/lodash/ts3.1/fp/toLength.d.ts @@ -0,0 +1,2 @@ +import { toLength } from "../fp"; +export = toLength; diff --git a/types/lodash/ts3.1/fp/toLower.d.ts b/types/lodash/ts3.1/fp/toLower.d.ts new file mode 100644 index 0000000000..64e6e364d0 --- /dev/null +++ b/types/lodash/ts3.1/fp/toLower.d.ts @@ -0,0 +1,2 @@ +import { toLower } from "../fp"; +export = toLower; diff --git a/types/lodash/ts3.1/fp/toNumber.d.ts b/types/lodash/ts3.1/fp/toNumber.d.ts new file mode 100644 index 0000000000..262b91c52d --- /dev/null +++ b/types/lodash/ts3.1/fp/toNumber.d.ts @@ -0,0 +1,2 @@ +import { toNumber } from "../fp"; +export = toNumber; diff --git a/types/lodash/ts3.1/fp/toPairs.d.ts b/types/lodash/ts3.1/fp/toPairs.d.ts new file mode 100644 index 0000000000..89334fcb5d --- /dev/null +++ b/types/lodash/ts3.1/fp/toPairs.d.ts @@ -0,0 +1,2 @@ +import { toPairs } from "../fp"; +export = toPairs; diff --git a/types/lodash/ts3.1/fp/toPairsIn.d.ts b/types/lodash/ts3.1/fp/toPairsIn.d.ts new file mode 100644 index 0000000000..278ff0b1df --- /dev/null +++ b/types/lodash/ts3.1/fp/toPairsIn.d.ts @@ -0,0 +1,2 @@ +import { toPairsIn } from "../fp"; +export = toPairsIn; diff --git a/types/lodash/ts3.1/fp/toPath.d.ts b/types/lodash/ts3.1/fp/toPath.d.ts new file mode 100644 index 0000000000..9f2287ceae --- /dev/null +++ b/types/lodash/ts3.1/fp/toPath.d.ts @@ -0,0 +1,2 @@ +import { toPath } from "../fp"; +export = toPath; diff --git a/types/lodash/ts3.1/fp/toPlainObject.d.ts b/types/lodash/ts3.1/fp/toPlainObject.d.ts new file mode 100644 index 0000000000..22fa070387 --- /dev/null +++ b/types/lodash/ts3.1/fp/toPlainObject.d.ts @@ -0,0 +1,2 @@ +import { toPlainObject } from "../fp"; +export = toPlainObject; diff --git a/types/lodash/ts3.1/fp/toSafeInteger.d.ts b/types/lodash/ts3.1/fp/toSafeInteger.d.ts new file mode 100644 index 0000000000..2f85078fcb --- /dev/null +++ b/types/lodash/ts3.1/fp/toSafeInteger.d.ts @@ -0,0 +1,2 @@ +import { toSafeInteger } from "../fp"; +export = toSafeInteger; diff --git a/types/lodash/ts3.1/fp/toString.d.ts b/types/lodash/ts3.1/fp/toString.d.ts new file mode 100644 index 0000000000..ee6703c068 --- /dev/null +++ b/types/lodash/ts3.1/fp/toString.d.ts @@ -0,0 +1,2 @@ +import { toString } from "../fp"; +export = toString; diff --git a/types/lodash/ts3.1/fp/toUpper.d.ts b/types/lodash/ts3.1/fp/toUpper.d.ts new file mode 100644 index 0000000000..6bf21c1fce --- /dev/null +++ b/types/lodash/ts3.1/fp/toUpper.d.ts @@ -0,0 +1,2 @@ +import { toUpper } from "../fp"; +export = toUpper; diff --git a/types/lodash/ts3.1/fp/transform.d.ts b/types/lodash/ts3.1/fp/transform.d.ts new file mode 100644 index 0000000000..ab0653cb7c --- /dev/null +++ b/types/lodash/ts3.1/fp/transform.d.ts @@ -0,0 +1,2 @@ +import { transform } from "../fp"; +export = transform; diff --git a/types/lodash/ts3.1/fp/trim.d.ts b/types/lodash/ts3.1/fp/trim.d.ts new file mode 100644 index 0000000000..f0f9b905d0 --- /dev/null +++ b/types/lodash/ts3.1/fp/trim.d.ts @@ -0,0 +1,2 @@ +import { trim } from "../fp"; +export = trim; diff --git a/types/lodash/ts3.1/fp/trimChars.d.ts b/types/lodash/ts3.1/fp/trimChars.d.ts new file mode 100644 index 0000000000..929a49300e --- /dev/null +++ b/types/lodash/ts3.1/fp/trimChars.d.ts @@ -0,0 +1,2 @@ +import { trimChars } from "../fp"; +export = trimChars; diff --git a/types/lodash/ts3.1/fp/trimCharsEnd.d.ts b/types/lodash/ts3.1/fp/trimCharsEnd.d.ts new file mode 100644 index 0000000000..2f5609ae2d --- /dev/null +++ b/types/lodash/ts3.1/fp/trimCharsEnd.d.ts @@ -0,0 +1,2 @@ +import { trimCharsEnd } from "../fp"; +export = trimCharsEnd; diff --git a/types/lodash/ts3.1/fp/trimCharsStart.d.ts b/types/lodash/ts3.1/fp/trimCharsStart.d.ts new file mode 100644 index 0000000000..fb998f7e50 --- /dev/null +++ b/types/lodash/ts3.1/fp/trimCharsStart.d.ts @@ -0,0 +1,2 @@ +import { trimCharsStart } from "../fp"; +export = trimCharsStart; diff --git a/types/lodash/ts3.1/fp/trimEnd.d.ts b/types/lodash/ts3.1/fp/trimEnd.d.ts new file mode 100644 index 0000000000..b666494483 --- /dev/null +++ b/types/lodash/ts3.1/fp/trimEnd.d.ts @@ -0,0 +1,2 @@ +import { trimEnd } from "../fp"; +export = trimEnd; diff --git a/types/lodash/ts3.1/fp/trimStart.d.ts b/types/lodash/ts3.1/fp/trimStart.d.ts new file mode 100644 index 0000000000..988227ca74 --- /dev/null +++ b/types/lodash/ts3.1/fp/trimStart.d.ts @@ -0,0 +1,2 @@ +import { trimStart } from "../fp"; +export = trimStart; diff --git a/types/lodash/ts3.1/fp/truncate.d.ts b/types/lodash/ts3.1/fp/truncate.d.ts new file mode 100644 index 0000000000..d38b7b18b6 --- /dev/null +++ b/types/lodash/ts3.1/fp/truncate.d.ts @@ -0,0 +1,2 @@ +import { truncate } from "../fp"; +export = truncate; diff --git a/types/lodash/ts3.1/fp/unapply.d.ts b/types/lodash/ts3.1/fp/unapply.d.ts new file mode 100644 index 0000000000..c59b6b2a19 --- /dev/null +++ b/types/lodash/ts3.1/fp/unapply.d.ts @@ -0,0 +1,2 @@ +import { unapply } from "../fp"; +export = unapply; diff --git a/types/lodash/ts3.1/fp/unary.d.ts b/types/lodash/ts3.1/fp/unary.d.ts new file mode 100644 index 0000000000..02e319576a --- /dev/null +++ b/types/lodash/ts3.1/fp/unary.d.ts @@ -0,0 +1,2 @@ +import { unary } from "../fp"; +export = unary; diff --git a/types/lodash/ts3.1/fp/unescape.d.ts b/types/lodash/ts3.1/fp/unescape.d.ts new file mode 100644 index 0000000000..efcccf2a51 --- /dev/null +++ b/types/lodash/ts3.1/fp/unescape.d.ts @@ -0,0 +1,2 @@ +import { unescape } from "../fp"; +export = unescape; diff --git a/types/lodash/ts3.1/fp/union.d.ts b/types/lodash/ts3.1/fp/union.d.ts new file mode 100644 index 0000000000..8e098ee7f6 --- /dev/null +++ b/types/lodash/ts3.1/fp/union.d.ts @@ -0,0 +1,2 @@ +import { union } from "../fp"; +export = union; diff --git a/types/lodash/ts3.1/fp/unionBy.d.ts b/types/lodash/ts3.1/fp/unionBy.d.ts new file mode 100644 index 0000000000..f3882c6b4a --- /dev/null +++ b/types/lodash/ts3.1/fp/unionBy.d.ts @@ -0,0 +1,2 @@ +import { unionBy } from "../fp"; +export = unionBy; diff --git a/types/lodash/ts3.1/fp/unionWith.d.ts b/types/lodash/ts3.1/fp/unionWith.d.ts new file mode 100644 index 0000000000..46e19fd176 --- /dev/null +++ b/types/lodash/ts3.1/fp/unionWith.d.ts @@ -0,0 +1,2 @@ +import { unionWith } from "../fp"; +export = unionWith; diff --git a/types/lodash/ts3.1/fp/uniq.d.ts b/types/lodash/ts3.1/fp/uniq.d.ts new file mode 100644 index 0000000000..877d0d94d9 --- /dev/null +++ b/types/lodash/ts3.1/fp/uniq.d.ts @@ -0,0 +1,2 @@ +import { uniq } from "../fp"; +export = uniq; diff --git a/types/lodash/ts3.1/fp/uniqBy.d.ts b/types/lodash/ts3.1/fp/uniqBy.d.ts new file mode 100644 index 0000000000..0e6522d704 --- /dev/null +++ b/types/lodash/ts3.1/fp/uniqBy.d.ts @@ -0,0 +1,2 @@ +import { uniqBy } from "../fp"; +export = uniqBy; diff --git a/types/lodash/ts3.1/fp/uniqWith.d.ts b/types/lodash/ts3.1/fp/uniqWith.d.ts new file mode 100644 index 0000000000..165f45f1e3 --- /dev/null +++ b/types/lodash/ts3.1/fp/uniqWith.d.ts @@ -0,0 +1,2 @@ +import { uniqWith } from "../fp"; +export = uniqWith; diff --git a/types/lodash/ts3.1/fp/uniqueId.d.ts b/types/lodash/ts3.1/fp/uniqueId.d.ts new file mode 100644 index 0000000000..57736d9ccd --- /dev/null +++ b/types/lodash/ts3.1/fp/uniqueId.d.ts @@ -0,0 +1,2 @@ +import { uniqueId } from "../fp"; +export = uniqueId; diff --git a/types/lodash/ts3.1/fp/unnest.d.ts b/types/lodash/ts3.1/fp/unnest.d.ts new file mode 100644 index 0000000000..852e9a1367 --- /dev/null +++ b/types/lodash/ts3.1/fp/unnest.d.ts @@ -0,0 +1,2 @@ +import { unnest } from "../fp"; +export = unnest; diff --git a/types/lodash/ts3.1/fp/unset.d.ts b/types/lodash/ts3.1/fp/unset.d.ts new file mode 100644 index 0000000000..3e99247714 --- /dev/null +++ b/types/lodash/ts3.1/fp/unset.d.ts @@ -0,0 +1,2 @@ +import { unset } from "../fp"; +export = unset; diff --git a/types/lodash/ts3.1/fp/unzip.d.ts b/types/lodash/ts3.1/fp/unzip.d.ts new file mode 100644 index 0000000000..ba9d4cd709 --- /dev/null +++ b/types/lodash/ts3.1/fp/unzip.d.ts @@ -0,0 +1,2 @@ +import { unzip } from "../fp"; +export = unzip; diff --git a/types/lodash/ts3.1/fp/unzipWith.d.ts b/types/lodash/ts3.1/fp/unzipWith.d.ts new file mode 100644 index 0000000000..599eadb355 --- /dev/null +++ b/types/lodash/ts3.1/fp/unzipWith.d.ts @@ -0,0 +1,2 @@ +import { unzipWith } from "../fp"; +export = unzipWith; diff --git a/types/lodash/ts3.1/fp/update.d.ts b/types/lodash/ts3.1/fp/update.d.ts new file mode 100644 index 0000000000..76dfe482f8 --- /dev/null +++ b/types/lodash/ts3.1/fp/update.d.ts @@ -0,0 +1,2 @@ +import { update } from "../fp"; +export = update; diff --git a/types/lodash/ts3.1/fp/updateWith.d.ts b/types/lodash/ts3.1/fp/updateWith.d.ts new file mode 100644 index 0000000000..6d6331d1b5 --- /dev/null +++ b/types/lodash/ts3.1/fp/updateWith.d.ts @@ -0,0 +1,2 @@ +import { updateWith } from "../fp"; +export = updateWith; diff --git a/types/lodash/ts3.1/fp/upperCase.d.ts b/types/lodash/ts3.1/fp/upperCase.d.ts new file mode 100644 index 0000000000..10aadb28ec --- /dev/null +++ b/types/lodash/ts3.1/fp/upperCase.d.ts @@ -0,0 +1,2 @@ +import { upperCase } from "../fp"; +export = upperCase; diff --git a/types/lodash/ts3.1/fp/upperFirst.d.ts b/types/lodash/ts3.1/fp/upperFirst.d.ts new file mode 100644 index 0000000000..e2c9adfd57 --- /dev/null +++ b/types/lodash/ts3.1/fp/upperFirst.d.ts @@ -0,0 +1,2 @@ +import { upperFirst } from "../fp"; +export = upperFirst; diff --git a/types/lodash/ts3.1/fp/useWith.d.ts b/types/lodash/ts3.1/fp/useWith.d.ts new file mode 100644 index 0000000000..991905a402 --- /dev/null +++ b/types/lodash/ts3.1/fp/useWith.d.ts @@ -0,0 +1,2 @@ +import { useWith } from "../fp"; +export = useWith; diff --git a/types/lodash/ts3.1/fp/values.d.ts b/types/lodash/ts3.1/fp/values.d.ts new file mode 100644 index 0000000000..75ec6fb4e5 --- /dev/null +++ b/types/lodash/ts3.1/fp/values.d.ts @@ -0,0 +1,2 @@ +import { values } from "../fp"; +export = values; diff --git a/types/lodash/ts3.1/fp/valuesIn.d.ts b/types/lodash/ts3.1/fp/valuesIn.d.ts new file mode 100644 index 0000000000..6f4f3b43bb --- /dev/null +++ b/types/lodash/ts3.1/fp/valuesIn.d.ts @@ -0,0 +1,2 @@ +import { valuesIn } from "../fp"; +export = valuesIn; diff --git a/types/lodash/ts3.1/fp/where.d.ts b/types/lodash/ts3.1/fp/where.d.ts new file mode 100644 index 0000000000..41e21ec8ac --- /dev/null +++ b/types/lodash/ts3.1/fp/where.d.ts @@ -0,0 +1,2 @@ +import { where } from "../fp"; +export = where; diff --git a/types/lodash/ts3.1/fp/whereEq.d.ts b/types/lodash/ts3.1/fp/whereEq.d.ts new file mode 100644 index 0000000000..893316d625 --- /dev/null +++ b/types/lodash/ts3.1/fp/whereEq.d.ts @@ -0,0 +1,2 @@ +import { whereEq } from "../fp"; +export = whereEq; diff --git a/types/lodash/ts3.1/fp/without.d.ts b/types/lodash/ts3.1/fp/without.d.ts new file mode 100644 index 0000000000..600890a400 --- /dev/null +++ b/types/lodash/ts3.1/fp/without.d.ts @@ -0,0 +1,2 @@ +import { without } from "../fp"; +export = without; diff --git a/types/lodash/ts3.1/fp/words.d.ts b/types/lodash/ts3.1/fp/words.d.ts new file mode 100644 index 0000000000..2b06b26368 --- /dev/null +++ b/types/lodash/ts3.1/fp/words.d.ts @@ -0,0 +1,2 @@ +import { words } from "../fp"; +export = words; diff --git a/types/lodash/ts3.1/fp/wrap.d.ts b/types/lodash/ts3.1/fp/wrap.d.ts new file mode 100644 index 0000000000..d9c2a283e2 --- /dev/null +++ b/types/lodash/ts3.1/fp/wrap.d.ts @@ -0,0 +1,2 @@ +import { wrap } from "../fp"; +export = wrap; diff --git a/types/lodash/ts3.1/fp/xor.d.ts b/types/lodash/ts3.1/fp/xor.d.ts new file mode 100644 index 0000000000..ac69bde236 --- /dev/null +++ b/types/lodash/ts3.1/fp/xor.d.ts @@ -0,0 +1,2 @@ +import { xor } from "../fp"; +export = xor; diff --git a/types/lodash/ts3.1/fp/xorBy.d.ts b/types/lodash/ts3.1/fp/xorBy.d.ts new file mode 100644 index 0000000000..1232972323 --- /dev/null +++ b/types/lodash/ts3.1/fp/xorBy.d.ts @@ -0,0 +1,2 @@ +import { xorBy } from "../fp"; +export = xorBy; diff --git a/types/lodash/ts3.1/fp/xorWith.d.ts b/types/lodash/ts3.1/fp/xorWith.d.ts new file mode 100644 index 0000000000..ec93e40b30 --- /dev/null +++ b/types/lodash/ts3.1/fp/xorWith.d.ts @@ -0,0 +1,2 @@ +import { xorWith } from "../fp"; +export = xorWith; diff --git a/types/lodash/ts3.1/fp/zip.d.ts b/types/lodash/ts3.1/fp/zip.d.ts new file mode 100644 index 0000000000..2a83e733b6 --- /dev/null +++ b/types/lodash/ts3.1/fp/zip.d.ts @@ -0,0 +1,2 @@ +import { zip } from "../fp"; +export = zip; diff --git a/types/lodash/ts3.1/fp/zipAll.d.ts b/types/lodash/ts3.1/fp/zipAll.d.ts new file mode 100644 index 0000000000..af0b3ed3f5 --- /dev/null +++ b/types/lodash/ts3.1/fp/zipAll.d.ts @@ -0,0 +1,2 @@ +import { zipAll } from "../fp"; +export = zipAll; diff --git a/types/lodash/ts3.1/fp/zipObj.d.ts b/types/lodash/ts3.1/fp/zipObj.d.ts new file mode 100644 index 0000000000..4f4c19a87d --- /dev/null +++ b/types/lodash/ts3.1/fp/zipObj.d.ts @@ -0,0 +1,2 @@ +import { zipObj } from "../fp"; +export = zipObj; diff --git a/types/lodash/ts3.1/fp/zipObject.d.ts b/types/lodash/ts3.1/fp/zipObject.d.ts new file mode 100644 index 0000000000..f302d7b155 --- /dev/null +++ b/types/lodash/ts3.1/fp/zipObject.d.ts @@ -0,0 +1,2 @@ +import { zipObject } from "../fp"; +export = zipObject; diff --git a/types/lodash/ts3.1/fp/zipObjectDeep.d.ts b/types/lodash/ts3.1/fp/zipObjectDeep.d.ts new file mode 100644 index 0000000000..601063489d --- /dev/null +++ b/types/lodash/ts3.1/fp/zipObjectDeep.d.ts @@ -0,0 +1,2 @@ +import { zipObjectDeep } from "../fp"; +export = zipObjectDeep; diff --git a/types/lodash/ts3.1/fp/zipWith.d.ts b/types/lodash/ts3.1/fp/zipWith.d.ts new file mode 100644 index 0000000000..9faaf3c589 --- /dev/null +++ b/types/lodash/ts3.1/fp/zipWith.d.ts @@ -0,0 +1,2 @@ +import { zipWith } from "../fp"; +export = zipWith; diff --git a/types/lodash/ts3.1/fromPairs.d.ts b/types/lodash/ts3.1/fromPairs.d.ts new file mode 100644 index 0000000000..1c2006c63d --- /dev/null +++ b/types/lodash/ts3.1/fromPairs.d.ts @@ -0,0 +1,2 @@ +import { fromPairs } from "./index"; +export = fromPairs; diff --git a/types/lodash/ts3.1/functions.d.ts b/types/lodash/ts3.1/functions.d.ts new file mode 100644 index 0000000000..86983361a4 --- /dev/null +++ b/types/lodash/ts3.1/functions.d.ts @@ -0,0 +1,2 @@ +import { functions } from "./index"; +export = functions; diff --git a/types/lodash/ts3.1/functionsIn.d.ts b/types/lodash/ts3.1/functionsIn.d.ts new file mode 100644 index 0000000000..9f72a78382 --- /dev/null +++ b/types/lodash/ts3.1/functionsIn.d.ts @@ -0,0 +1,2 @@ +import { functionsIn } from "./index"; +export = functionsIn; diff --git a/types/lodash/ts3.1/get.d.ts b/types/lodash/ts3.1/get.d.ts new file mode 100644 index 0000000000..5ea7a5a41c --- /dev/null +++ b/types/lodash/ts3.1/get.d.ts @@ -0,0 +1,2 @@ +import { get } from "./index"; +export = get; diff --git a/types/lodash/ts3.1/groupBy.d.ts b/types/lodash/ts3.1/groupBy.d.ts new file mode 100644 index 0000000000..ef49718e57 --- /dev/null +++ b/types/lodash/ts3.1/groupBy.d.ts @@ -0,0 +1,2 @@ +import { groupBy } from "./index"; +export = groupBy; diff --git a/types/lodash/ts3.1/gt.d.ts b/types/lodash/ts3.1/gt.d.ts new file mode 100644 index 0000000000..860134fbea --- /dev/null +++ b/types/lodash/ts3.1/gt.d.ts @@ -0,0 +1,2 @@ +import { gt } from "./index"; +export = gt; diff --git a/types/lodash/ts3.1/gte.d.ts b/types/lodash/ts3.1/gte.d.ts new file mode 100644 index 0000000000..994e882646 --- /dev/null +++ b/types/lodash/ts3.1/gte.d.ts @@ -0,0 +1,2 @@ +import { gte } from "./index"; +export = gte; diff --git a/types/lodash/ts3.1/has.d.ts b/types/lodash/ts3.1/has.d.ts new file mode 100644 index 0000000000..fff1468693 --- /dev/null +++ b/types/lodash/ts3.1/has.d.ts @@ -0,0 +1,2 @@ +import { has } from "./index"; +export = has; diff --git a/types/lodash/ts3.1/hasIn.d.ts b/types/lodash/ts3.1/hasIn.d.ts new file mode 100644 index 0000000000..a898071b16 --- /dev/null +++ b/types/lodash/ts3.1/hasIn.d.ts @@ -0,0 +1,2 @@ +import { hasIn } from "./index"; +export = hasIn; diff --git a/types/lodash/ts3.1/head.d.ts b/types/lodash/ts3.1/head.d.ts new file mode 100644 index 0000000000..0e16da1711 --- /dev/null +++ b/types/lodash/ts3.1/head.d.ts @@ -0,0 +1,2 @@ +import { head } from "./index"; +export = head; diff --git a/types/lodash/ts3.1/identity.d.ts b/types/lodash/ts3.1/identity.d.ts new file mode 100644 index 0000000000..6814a16538 --- /dev/null +++ b/types/lodash/ts3.1/identity.d.ts @@ -0,0 +1,2 @@ +import { identity } from "./index"; +export = identity; diff --git a/types/lodash/ts3.1/inRange.d.ts b/types/lodash/ts3.1/inRange.d.ts new file mode 100644 index 0000000000..d9c57c0e8f --- /dev/null +++ b/types/lodash/ts3.1/inRange.d.ts @@ -0,0 +1,2 @@ +import { inRange } from "./index"; +export = inRange; diff --git a/types/lodash/ts3.1/includes.d.ts b/types/lodash/ts3.1/includes.d.ts new file mode 100644 index 0000000000..4edd22619f --- /dev/null +++ b/types/lodash/ts3.1/includes.d.ts @@ -0,0 +1,2 @@ +import { includes } from "./index"; +export = includes; diff --git a/types/lodash/ts3.1/index.d.ts b/types/lodash/ts3.1/index.d.ts new file mode 100644 index 0000000000..c7e8a09ea9 --- /dev/null +++ b/types/lodash/ts3.1/index.d.ts @@ -0,0 +1,33 @@ +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// + +export = _; +export as namespace _; + +declare const _: _.LoDashStatic; +declare namespace _ { + // tslint:disable-next-line no-empty-interface (This will be augmented) + interface LoDashStatic {} +} + +// Backward compatibility with --target es5 +declare global { + // tslint:disable-next-line:no-empty-interface + interface Set { } + // tslint:disable-next-line:no-empty-interface + interface Map { } + // tslint:disable-next-line:no-empty-interface + interface WeakSet { } + // tslint:disable-next-line:no-empty-interface + interface WeakMap { } +} diff --git a/types/lodash/ts3.1/indexOf.d.ts b/types/lodash/ts3.1/indexOf.d.ts new file mode 100644 index 0000000000..50b8f702c9 --- /dev/null +++ b/types/lodash/ts3.1/indexOf.d.ts @@ -0,0 +1,2 @@ +import { indexOf } from "./index"; +export = indexOf; diff --git a/types/lodash/ts3.1/initial.d.ts b/types/lodash/ts3.1/initial.d.ts new file mode 100644 index 0000000000..3ce64ebc02 --- /dev/null +++ b/types/lodash/ts3.1/initial.d.ts @@ -0,0 +1,2 @@ +import { initial } from "./index"; +export = initial; diff --git a/types/lodash/ts3.1/intersection.d.ts b/types/lodash/ts3.1/intersection.d.ts new file mode 100644 index 0000000000..1fbe4e5965 --- /dev/null +++ b/types/lodash/ts3.1/intersection.d.ts @@ -0,0 +1,2 @@ +import { intersection } from "./index"; +export = intersection; diff --git a/types/lodash/ts3.1/intersectionBy.d.ts b/types/lodash/ts3.1/intersectionBy.d.ts new file mode 100644 index 0000000000..b4885da5e1 --- /dev/null +++ b/types/lodash/ts3.1/intersectionBy.d.ts @@ -0,0 +1,2 @@ +import { intersectionBy } from "./index"; +export = intersectionBy; diff --git a/types/lodash/ts3.1/intersectionWith.d.ts b/types/lodash/ts3.1/intersectionWith.d.ts new file mode 100644 index 0000000000..bacccd045a --- /dev/null +++ b/types/lodash/ts3.1/intersectionWith.d.ts @@ -0,0 +1,2 @@ +import { intersectionWith } from "./index"; +export = intersectionWith; diff --git a/types/lodash/ts3.1/invert.d.ts b/types/lodash/ts3.1/invert.d.ts new file mode 100644 index 0000000000..2287ea1f93 --- /dev/null +++ b/types/lodash/ts3.1/invert.d.ts @@ -0,0 +1,2 @@ +import { invert } from "./index"; +export = invert; diff --git a/types/lodash/ts3.1/invertBy.d.ts b/types/lodash/ts3.1/invertBy.d.ts new file mode 100644 index 0000000000..5951600e23 --- /dev/null +++ b/types/lodash/ts3.1/invertBy.d.ts @@ -0,0 +1,2 @@ +import { invertBy } from "./index"; +export = invertBy; diff --git a/types/lodash/ts3.1/invoke.d.ts b/types/lodash/ts3.1/invoke.d.ts new file mode 100644 index 0000000000..eea6b3888f --- /dev/null +++ b/types/lodash/ts3.1/invoke.d.ts @@ -0,0 +1,2 @@ +import { invoke } from "./index"; +export = invoke; diff --git a/types/lodash/ts3.1/invokeMap.d.ts b/types/lodash/ts3.1/invokeMap.d.ts new file mode 100644 index 0000000000..814cf05fdd --- /dev/null +++ b/types/lodash/ts3.1/invokeMap.d.ts @@ -0,0 +1,2 @@ +import { invokeMap } from "./index"; +export = invokeMap; diff --git a/types/lodash/ts3.1/isArguments.d.ts b/types/lodash/ts3.1/isArguments.d.ts new file mode 100644 index 0000000000..5b22572313 --- /dev/null +++ b/types/lodash/ts3.1/isArguments.d.ts @@ -0,0 +1,2 @@ +import { isArguments } from "./index"; +export = isArguments; diff --git a/types/lodash/ts3.1/isArray.d.ts b/types/lodash/ts3.1/isArray.d.ts new file mode 100644 index 0000000000..a35ab5a629 --- /dev/null +++ b/types/lodash/ts3.1/isArray.d.ts @@ -0,0 +1,2 @@ +import { isArray } from "./index"; +export = isArray; diff --git a/types/lodash/ts3.1/isArrayBuffer.d.ts b/types/lodash/ts3.1/isArrayBuffer.d.ts new file mode 100644 index 0000000000..ec7c68ce2c --- /dev/null +++ b/types/lodash/ts3.1/isArrayBuffer.d.ts @@ -0,0 +1,2 @@ +import { isArrayBuffer } from "./index"; +export = isArrayBuffer; diff --git a/types/lodash/ts3.1/isArrayLike.d.ts b/types/lodash/ts3.1/isArrayLike.d.ts new file mode 100644 index 0000000000..aa95c77006 --- /dev/null +++ b/types/lodash/ts3.1/isArrayLike.d.ts @@ -0,0 +1,2 @@ +import { isArrayLike } from "./index"; +export = isArrayLike; diff --git a/types/lodash/ts3.1/isArrayLikeObject.d.ts b/types/lodash/ts3.1/isArrayLikeObject.d.ts new file mode 100644 index 0000000000..736c91db1d --- /dev/null +++ b/types/lodash/ts3.1/isArrayLikeObject.d.ts @@ -0,0 +1,2 @@ +import { isArrayLikeObject } from "./index"; +export = isArrayLikeObject; diff --git a/types/lodash/ts3.1/isBoolean.d.ts b/types/lodash/ts3.1/isBoolean.d.ts new file mode 100644 index 0000000000..96c306d9cc --- /dev/null +++ b/types/lodash/ts3.1/isBoolean.d.ts @@ -0,0 +1,2 @@ +import { isBoolean } from "./index"; +export = isBoolean; diff --git a/types/lodash/ts3.1/isBuffer.d.ts b/types/lodash/ts3.1/isBuffer.d.ts new file mode 100644 index 0000000000..b22d78244b --- /dev/null +++ b/types/lodash/ts3.1/isBuffer.d.ts @@ -0,0 +1,2 @@ +import { isBuffer } from "./index"; +export = isBuffer; diff --git a/types/lodash/ts3.1/isDate.d.ts b/types/lodash/ts3.1/isDate.d.ts new file mode 100644 index 0000000000..1269a69d43 --- /dev/null +++ b/types/lodash/ts3.1/isDate.d.ts @@ -0,0 +1,2 @@ +import { isDate } from "./index"; +export = isDate; diff --git a/types/lodash/ts3.1/isElement.d.ts b/types/lodash/ts3.1/isElement.d.ts new file mode 100644 index 0000000000..e4510cd9ce --- /dev/null +++ b/types/lodash/ts3.1/isElement.d.ts @@ -0,0 +1,2 @@ +import { isElement } from "./index"; +export = isElement; diff --git a/types/lodash/ts3.1/isEmpty.d.ts b/types/lodash/ts3.1/isEmpty.d.ts new file mode 100644 index 0000000000..9e71bfa96b --- /dev/null +++ b/types/lodash/ts3.1/isEmpty.d.ts @@ -0,0 +1,2 @@ +import { isEmpty } from "./index"; +export = isEmpty; diff --git a/types/lodash/ts3.1/isEqual.d.ts b/types/lodash/ts3.1/isEqual.d.ts new file mode 100644 index 0000000000..1e065fa839 --- /dev/null +++ b/types/lodash/ts3.1/isEqual.d.ts @@ -0,0 +1,2 @@ +import { isEqual } from "./index"; +export = isEqual; diff --git a/types/lodash/ts3.1/isEqualWith.d.ts b/types/lodash/ts3.1/isEqualWith.d.ts new file mode 100644 index 0000000000..e14d005c42 --- /dev/null +++ b/types/lodash/ts3.1/isEqualWith.d.ts @@ -0,0 +1,2 @@ +import { isEqualWith } from "./index"; +export = isEqualWith; diff --git a/types/lodash/ts3.1/isError.d.ts b/types/lodash/ts3.1/isError.d.ts new file mode 100644 index 0000000000..d9d5785777 --- /dev/null +++ b/types/lodash/ts3.1/isError.d.ts @@ -0,0 +1,2 @@ +import { isError } from "./index"; +export = isError; diff --git a/types/lodash/ts3.1/isFinite.d.ts b/types/lodash/ts3.1/isFinite.d.ts new file mode 100644 index 0000000000..7aba1dc6fb --- /dev/null +++ b/types/lodash/ts3.1/isFinite.d.ts @@ -0,0 +1,2 @@ +import { isFinite } from "./index"; +export = isFinite; diff --git a/types/lodash/ts3.1/isFunction.d.ts b/types/lodash/ts3.1/isFunction.d.ts new file mode 100644 index 0000000000..0a22d6cc76 --- /dev/null +++ b/types/lodash/ts3.1/isFunction.d.ts @@ -0,0 +1,2 @@ +import { isFunction } from "./index"; +export = isFunction; diff --git a/types/lodash/ts3.1/isInteger.d.ts b/types/lodash/ts3.1/isInteger.d.ts new file mode 100644 index 0000000000..40d33d39e9 --- /dev/null +++ b/types/lodash/ts3.1/isInteger.d.ts @@ -0,0 +1,2 @@ +import { isInteger } from "./index"; +export = isInteger; diff --git a/types/lodash/ts3.1/isLength.d.ts b/types/lodash/ts3.1/isLength.d.ts new file mode 100644 index 0000000000..ee5a93304d --- /dev/null +++ b/types/lodash/ts3.1/isLength.d.ts @@ -0,0 +1,2 @@ +import { isLength } from "./index"; +export = isLength; diff --git a/types/lodash/ts3.1/isMap.d.ts b/types/lodash/ts3.1/isMap.d.ts new file mode 100644 index 0000000000..441c5388cb --- /dev/null +++ b/types/lodash/ts3.1/isMap.d.ts @@ -0,0 +1,2 @@ +import { isMap } from "./index"; +export = isMap; diff --git a/types/lodash/ts3.1/isMatch.d.ts b/types/lodash/ts3.1/isMatch.d.ts new file mode 100644 index 0000000000..69d194a285 --- /dev/null +++ b/types/lodash/ts3.1/isMatch.d.ts @@ -0,0 +1,2 @@ +import { isMatch } from "./index"; +export = isMatch; diff --git a/types/lodash/ts3.1/isMatchWith.d.ts b/types/lodash/ts3.1/isMatchWith.d.ts new file mode 100644 index 0000000000..932310af41 --- /dev/null +++ b/types/lodash/ts3.1/isMatchWith.d.ts @@ -0,0 +1,2 @@ +import { isMatchWith } from "./index"; +export = isMatchWith; diff --git a/types/lodash/ts3.1/isNaN.d.ts b/types/lodash/ts3.1/isNaN.d.ts new file mode 100644 index 0000000000..970702b50c --- /dev/null +++ b/types/lodash/ts3.1/isNaN.d.ts @@ -0,0 +1,2 @@ +import { isNaN } from "./index"; +export = isNaN; diff --git a/types/lodash/ts3.1/isNative.d.ts b/types/lodash/ts3.1/isNative.d.ts new file mode 100644 index 0000000000..3174f8a8c2 --- /dev/null +++ b/types/lodash/ts3.1/isNative.d.ts @@ -0,0 +1,2 @@ +import { isNative } from "./index"; +export = isNative; diff --git a/types/lodash/ts3.1/isNil.d.ts b/types/lodash/ts3.1/isNil.d.ts new file mode 100644 index 0000000000..9e1581976c --- /dev/null +++ b/types/lodash/ts3.1/isNil.d.ts @@ -0,0 +1,2 @@ +import { isNil } from "./index"; +export = isNil; diff --git a/types/lodash/ts3.1/isNull.d.ts b/types/lodash/ts3.1/isNull.d.ts new file mode 100644 index 0000000000..e572c456ed --- /dev/null +++ b/types/lodash/ts3.1/isNull.d.ts @@ -0,0 +1,2 @@ +import { isNull } from "./index"; +export = isNull; diff --git a/types/lodash/ts3.1/isNumber.d.ts b/types/lodash/ts3.1/isNumber.d.ts new file mode 100644 index 0000000000..91c83598c8 --- /dev/null +++ b/types/lodash/ts3.1/isNumber.d.ts @@ -0,0 +1,2 @@ +import { isNumber } from "./index"; +export = isNumber; diff --git a/types/lodash/ts3.1/isObject.d.ts b/types/lodash/ts3.1/isObject.d.ts new file mode 100644 index 0000000000..9a43544c28 --- /dev/null +++ b/types/lodash/ts3.1/isObject.d.ts @@ -0,0 +1,2 @@ +import { isObject } from "./index"; +export = isObject; diff --git a/types/lodash/ts3.1/isObjectLike.d.ts b/types/lodash/ts3.1/isObjectLike.d.ts new file mode 100644 index 0000000000..a17d39c4e9 --- /dev/null +++ b/types/lodash/ts3.1/isObjectLike.d.ts @@ -0,0 +1,2 @@ +import { isObjectLike } from "./index"; +export = isObjectLike; diff --git a/types/lodash/ts3.1/isPlainObject.d.ts b/types/lodash/ts3.1/isPlainObject.d.ts new file mode 100644 index 0000000000..4df85e28b8 --- /dev/null +++ b/types/lodash/ts3.1/isPlainObject.d.ts @@ -0,0 +1,2 @@ +import { isPlainObject } from "./index"; +export = isPlainObject; diff --git a/types/lodash/ts3.1/isRegExp.d.ts b/types/lodash/ts3.1/isRegExp.d.ts new file mode 100644 index 0000000000..ed206d9728 --- /dev/null +++ b/types/lodash/ts3.1/isRegExp.d.ts @@ -0,0 +1,2 @@ +import { isRegExp } from "./index"; +export = isRegExp; diff --git a/types/lodash/ts3.1/isSafeInteger.d.ts b/types/lodash/ts3.1/isSafeInteger.d.ts new file mode 100644 index 0000000000..6bc6083319 --- /dev/null +++ b/types/lodash/ts3.1/isSafeInteger.d.ts @@ -0,0 +1,2 @@ +import { isSafeInteger } from "./index"; +export = isSafeInteger; diff --git a/types/lodash/ts3.1/isSet.d.ts b/types/lodash/ts3.1/isSet.d.ts new file mode 100644 index 0000000000..7967b50d29 --- /dev/null +++ b/types/lodash/ts3.1/isSet.d.ts @@ -0,0 +1,2 @@ +import { isSet } from "./index"; +export = isSet; diff --git a/types/lodash/ts3.1/isString.d.ts b/types/lodash/ts3.1/isString.d.ts new file mode 100644 index 0000000000..757802e178 --- /dev/null +++ b/types/lodash/ts3.1/isString.d.ts @@ -0,0 +1,2 @@ +import { isString } from "./index"; +export = isString; diff --git a/types/lodash/ts3.1/isSymbol.d.ts b/types/lodash/ts3.1/isSymbol.d.ts new file mode 100644 index 0000000000..e28b2b0c73 --- /dev/null +++ b/types/lodash/ts3.1/isSymbol.d.ts @@ -0,0 +1,2 @@ +import { isSymbol } from "./index"; +export = isSymbol; diff --git a/types/lodash/ts3.1/isTypedArray.d.ts b/types/lodash/ts3.1/isTypedArray.d.ts new file mode 100644 index 0000000000..7f32601225 --- /dev/null +++ b/types/lodash/ts3.1/isTypedArray.d.ts @@ -0,0 +1,2 @@ +import { isTypedArray } from "./index"; +export = isTypedArray; diff --git a/types/lodash/ts3.1/isUndefined.d.ts b/types/lodash/ts3.1/isUndefined.d.ts new file mode 100644 index 0000000000..7a5c64ff74 --- /dev/null +++ b/types/lodash/ts3.1/isUndefined.d.ts @@ -0,0 +1,2 @@ +import { isUndefined } from "./index"; +export = isUndefined; diff --git a/types/lodash/ts3.1/isWeakMap.d.ts b/types/lodash/ts3.1/isWeakMap.d.ts new file mode 100644 index 0000000000..b0609daab5 --- /dev/null +++ b/types/lodash/ts3.1/isWeakMap.d.ts @@ -0,0 +1,2 @@ +import { isWeakMap } from "./index"; +export = isWeakMap; diff --git a/types/lodash/ts3.1/isWeakSet.d.ts b/types/lodash/ts3.1/isWeakSet.d.ts new file mode 100644 index 0000000000..6beda3d0fa --- /dev/null +++ b/types/lodash/ts3.1/isWeakSet.d.ts @@ -0,0 +1,2 @@ +import { isWeakSet } from "./index"; +export = isWeakSet; diff --git a/types/lodash/ts3.1/iteratee.d.ts b/types/lodash/ts3.1/iteratee.d.ts new file mode 100644 index 0000000000..493b39c4ba --- /dev/null +++ b/types/lodash/ts3.1/iteratee.d.ts @@ -0,0 +1,2 @@ +import { iteratee } from "./index"; +export = iteratee; diff --git a/types/lodash/ts3.1/join.d.ts b/types/lodash/ts3.1/join.d.ts new file mode 100644 index 0000000000..b2c5fb4012 --- /dev/null +++ b/types/lodash/ts3.1/join.d.ts @@ -0,0 +1,2 @@ +import { join } from "./index"; +export = join; diff --git a/types/lodash/ts3.1/kebabCase.d.ts b/types/lodash/ts3.1/kebabCase.d.ts new file mode 100644 index 0000000000..c088ef7c24 --- /dev/null +++ b/types/lodash/ts3.1/kebabCase.d.ts @@ -0,0 +1,2 @@ +import { kebabCase } from "./index"; +export = kebabCase; diff --git a/types/lodash/ts3.1/keyBy.d.ts b/types/lodash/ts3.1/keyBy.d.ts new file mode 100644 index 0000000000..664a7229a1 --- /dev/null +++ b/types/lodash/ts3.1/keyBy.d.ts @@ -0,0 +1,2 @@ +import { keyBy } from "./index"; +export = keyBy; diff --git a/types/lodash/ts3.1/keys.d.ts b/types/lodash/ts3.1/keys.d.ts new file mode 100644 index 0000000000..7eb29a0b91 --- /dev/null +++ b/types/lodash/ts3.1/keys.d.ts @@ -0,0 +1,2 @@ +import { keys } from "./index"; +export = keys; diff --git a/types/lodash/ts3.1/keysIn.d.ts b/types/lodash/ts3.1/keysIn.d.ts new file mode 100644 index 0000000000..c9eeee6c27 --- /dev/null +++ b/types/lodash/ts3.1/keysIn.d.ts @@ -0,0 +1,2 @@ +import { keysIn } from "./index"; +export = keysIn; diff --git a/types/lodash/ts3.1/last.d.ts b/types/lodash/ts3.1/last.d.ts new file mode 100644 index 0000000000..cfdeb757ee --- /dev/null +++ b/types/lodash/ts3.1/last.d.ts @@ -0,0 +1,2 @@ +import { last } from "./index"; +export = last; diff --git a/types/lodash/ts3.1/lastIndexOf.d.ts b/types/lodash/ts3.1/lastIndexOf.d.ts new file mode 100644 index 0000000000..979d80dd9e --- /dev/null +++ b/types/lodash/ts3.1/lastIndexOf.d.ts @@ -0,0 +1,2 @@ +import { lastIndexOf } from "./index"; +export = lastIndexOf; diff --git a/types/lodash/ts3.1/lodash-tests.ts b/types/lodash/ts3.1/lodash-tests.ts new file mode 100644 index 0000000000..317a2a6de4 --- /dev/null +++ b/types/lodash/ts3.1/lodash-tests.ts @@ -0,0 +1,7046 @@ +// tslint:disable-next-line:no-relative-import-in-test +import fp = require("./fp"); +import _ = require("lodash"); + +declare const anything: any; + +interface AbcObject { + a: number; + b: string; + c: boolean; +} + +const abcObject: AbcObject = anything; +const array: AbcObject[] | null | undefined = anything; +const list: _.List | null | undefined = anything; +const dictionary: _.Dictionary | null | undefined = anything; +const numericDictionary: _.NumericDictionary | null | undefined = anything; +const arrayParam: AbcObject[] = []; +const listParam: _.List = []; +const comparator = (a: AbcObject, b: AbcObject) => true; +const listIterator = (value: AbcObject, index: number, collection: _.List) => true; +const dictionaryIterator = (value: AbcObject, key: string, collection: _.Dictionary) => true; +const numericDictionaryIterator = (value: AbcObject, key: string, collection: _.NumericDictionary) => true; +const valueIterator = (value: AbcObject) => true; +const stringIterator = (value: string) => ""; + +// Wrapped array shortcut methods +_([1, 2, 3, 4]).pop(); // $ExpectType number | undefined +_([1, 2, 3, 4]).push(5, 6, 7); // $ExpectType Collection +_([1, 2, 3, 4]).shift(); // $ExpectType number | undefined +_([1, 2, 3, 4]).sort((a, b) => 1); // $ExpectType Collection +_([1, 2, 3, 4]).splice(1); // $ExpectType Collection +_([1, 2, 3, 4]).splice(1, 2, 5, 6); // $ExpectType Collection +_([1, 2, 3, 4]).unshift(5, 6); // $ExpectType Collection + +_.chain([1, 2, 3, 4]).pop(); // $ExpectType PrimitiveChain | PrimitiveChain +_.chain([1, 2, 3, 4]).push(5, 6, 7); // $ExpectType CollectionChain +_.chain([1, 2, 3, 4]).shift(); // $ExpectType PrimitiveChain | PrimitiveChain +_.chain([1, 2, 3, 4]).sort((a, b) => 1); // $ExpectType CollectionChain +_.chain([1, 2, 3, 4]).splice(1); // $ExpectType CollectionChain +_.chain([1, 2, 3, 4]).splice(1, 2, 5, 6); // $ExpectType CollectionChain +_.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain + +/********* + * Array * + *********/ + +// _.chunk +{ + _.chunk(list); // $ExpectType AbcObject[][] + _.chunk(list, 42); // $ExpectType AbcObject[][] + + _(list).chunk(); // $ExpectType Collection + _(list).chunk(42); // $ExpectType Collection + + _.chain(list).chunk(); // $ExpectType CollectionChain + _.chain(list).chunk(42); // $ExpectType CollectionChain + + fp.chunk(42, list); // $ExpectType AbcObject[][] + fp.chunk(42)(list); // $ExpectType AbcObject[][] + fp.chunk(fp.__, list)(42); // $ExpectType AbcObject[][] +} + +// _.compact +{ + const list: _.List | null | undefined = anything; + + _.compact(list); // $ExpectType AbcObject[] + _(list).compact(); // $ExpectType Collection + _.chain(list).compact(); // $ExpectType CollectionChain + fp.compact(list); // $ExpectType AbcObject[] +} + +// _.difference +{ + _.difference(list); // $ExpectType AbcObject[] + _.difference(list, listParam); // $ExpectType AbcObject[] + _.difference(list, listParam, arrayParam, listParam); // $ExpectType AbcObject[] + + _(list).difference(); // $ExpectType Collection + _(list).difference(listParam); // $ExpectType Collection + _(list).difference(listParam, arrayParam, listParam); // $ExpectType Collection + + _.chain(list).difference(); // $ExpectType CollectionChain + _.chain(list).difference(listParam); // $ExpectType CollectionChain + _.chain(list).difference(listParam, arrayParam, listParam); // $ExpectType CollectionChain + + fp.difference(list, arrayParam); // $ExpectType AbcObject[] + fp.difference(list)(arrayParam); // $ExpectType AbcObject[] +} + +// _.differenceBy +{ + _.differenceBy(list); // $ExpectType AbcObject[] + _.differenceBy(list, listParam); // $ExpectType AbcObject[] + _.differenceBy(list, arrayParam, listParam, arrayParam, listParam, arrayParam, listParam); // $ExpectType AbcObject[] + + _.differenceBy(list, listParam, valueIterator); // $ExpectType AbcObject[] + _.differenceBy(list, listParam, arrayParam, listParam, arrayParam, listParam, valueIterator); // $ExpectType AbcObject[] + // $ExpectType AbcObject[] + _.differenceBy(list, arrayParam, listParam, arrayParam, listParam, arrayParam, listParam, valueIterator); + + _.differenceBy(list, listParam, "a"); // $ExpectType AbcObject[] + _.differenceBy(list, listParam, arrayParam, listParam, arrayParam, listParam, "a"); // $ExpectType AbcObject[] + // $ExpectType AbcObject[] + _.differenceBy(list, arrayParam, listParam, arrayParam, listParam, arrayParam, listParam, "a"); + + _.differenceBy(list, listParam, {a: 1}); // $ExpectType AbcObject[] + _.differenceBy(list, listParam, arrayParam, listParam, arrayParam, listParam, {a: 1}); // $ExpectType AbcObject[] + // $ExpectType AbcObject[] + _.differenceBy(list, arrayParam, listParam, arrayParam, listParam, arrayParam, listParam, {a: 1}); + + _(list).differenceBy(listParam); // $ExpectType Collection + _(list).differenceBy(arrayParam, listParam, arrayParam, listParam, arrayParam, listParam); // $ExpectType Collection + + _(list).differenceBy(listParam, valueIterator); // $ExpectType Collection + _(list).differenceBy(listParam, arrayParam, listParam, arrayParam, listParam, valueIterator); // $ExpectType Collection + // $ExpectType Collection + _(list).differenceBy(arrayParam, listParam, arrayParam, listParam, arrayParam, listParam, valueIterator); + + _(list).differenceBy(listParam, "a"); // $ExpectType Collection + _(list).differenceBy(listParam, arrayParam, listParam, arrayParam, listParam, "a"); // $ExpectType Collection + // $ExpectType Collection + _(list).differenceBy(arrayParam, listParam, arrayParam, listParam, arrayParam, listParam, "a"); + + _(list).differenceBy(listParam, {a: 1}); // $ExpectType Collection + _(list).differenceBy(listParam, arrayParam, listParam, arrayParam, listParam, {a: 1}); // $ExpectType Collection + // $ExpectType Collection + _(list).differenceBy(arrayParam, listParam, arrayParam, listParam, arrayParam, listParam, {a: 1}); + + _.chain(list).differenceBy(arrayParam); // $ExpectType CollectionChain + _.chain(list).differenceBy(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam); // $ExpectType CollectionChain + + _.chain(list).differenceBy(arrayParam, valueIterator); // $ExpectType CollectionChain + _.chain(list).differenceBy(arrayParam, listParam, arrayParam, listParam, arrayParam, valueIterator); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(list).differenceBy(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam, valueIterator); + + _.chain(list).differenceBy(arrayParam, "a"); // $ExpectType CollectionChain + _.chain(list).differenceBy(arrayParam, listParam, arrayParam, listParam, arrayParam, "a"); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(list).differenceBy(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam, "a"); + + _.chain(list).differenceBy(arrayParam, {a: 1}); // $ExpectType CollectionChain + _.chain(list).differenceBy(arrayParam, listParam, arrayParam, listParam, arrayParam, 'a'); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(list).differenceBy(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam, {a: 1}); + + fp.differenceBy(valueIterator, list, arrayParam); // $ExpectType AbcObject[] + fp.differenceBy(valueIterator)(list)(listParam); // $ExpectType AbcObject[] + fp.differenceBy("a", list, arrayParam); // $ExpectType AbcObject[] + fp.differenceBy({a: 1}, list, arrayParam); // $ExpectType AbcObject[] + + { + interface T1 { + a: string; + b: string; + } + interface T2 { + a: string; + b: number; + } + interface T3 { + a: string; + b: boolean; + } + interface T4 { + a: string; + b: any[]; + } + + const t1: T1 = { a: "a", b: "b" }; + const t2: T2 = { a: "a", b: 30 }; + const t3: T3 = { a: "a", b: true }; + const t4: T4 = { a: "a", b: [] }; + + // $ExpectType T1[] + _.differenceBy([t1], [t2], "name"); + // $ExpectType T1[] + _.differenceBy([t1], [t2], (value) => { + value; // $ExpectType T1 | T2 + return 0; + }); + // $ExpectType T1[] + _.differenceBy([t1], [t2, t3], (value) => { + value; // $ExpectType T1 | T2 | T3 + return 0; + }); + // $ExpectType (T1 | T2)[] + _.differenceBy([t1, t2], [t3], (value) => { + value; // $ExpectType T1 | T2 | T3 + return 0; + }); + // $ExpectType T1[] + _.differenceBy([t1], [t2], [t3], [t4], [""], [42], (value) => { + value; // $ExpectType string | number | T1 | T2 | T3 | T4 + return 0; + }); + + // $ExpectType Collection + _([t1]).differenceBy([t2], "name"); + // $ExpectType Collection + _([t1]).differenceBy([t2], (value) => { + value; // $ExpectType T1 | T2 + return 0; + }); + // $ExpectType Collection + _([t1]).differenceBy([t2, t3], (value) => { + value; // $ExpectType T1 | T2 | T3 + return 0; + }); + // $ExpectType Collection + _([t1, t2]).differenceBy([t3], (value) => { + value; // $ExpectType T1 | T2 | T3 + return 0; + }); + // $ExpectType Collection + _([t1]).differenceBy([t2], [t3], [t4], [""], [42], (value) => { + value; // $ExpectType T1 + return 0; + }); + + // $ExpectType CollectionChain + _.chain([t1]).differenceBy([t2], "name"); + // $ExpectType CollectionChain + _.chain([t1]).differenceBy([t2], (value) => { + value; // $ExpectType T1 | T2 + return 0; + }); + // $ExpectType CollectionChain + _.chain([t1]).differenceBy([t2, t3], (value) => { + value; // $ExpectType T1 | T2 | T3 + return 0; + }); + // $ExpectType CollectionChain + _.chain([t1, t2]).differenceBy([t3], (value) => { + value; // $ExpectType T1 | T2 | T3 + return 0; + }); + // $ExpectType CollectionChain + _.chain([t1]).differenceBy([t2], [t3], [t4], [""], [42], (value) => { + value; // $ExpectType T1 + return 0; + }); + + fp.differenceBy("name", [t1], [t2]); // $ExpectType T1[] + fp.differenceBy((value: T1 | T2) => 0, [t1], [t2]); // $ExpectType T1[] + fp.differenceBy((value: T1 | T2 | T3) => 0, [t1], [t2, t3]); // $ExpectType T1[] + } +} + +// _.differenceWith +{ + _.differenceWith(list); // $ExpectType AbcObject[] + _.differenceWith(list, arrayParam, comparator); // $ExpectType AbcObject[] + _.differenceWith(list, listParam, arrayParam, listParam, arrayParam, listParam, arrayParam, comparator); // $ExpectType AbcObject[] + + _(list).differenceWith(arrayParam, comparator); // $ExpectType Collection + _(list).differenceWith(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam, comparator); // $ExpectType Collection + + _.chain(list).differenceWith(arrayParam, comparator); // $ExpectType CollectionChain + _.chain(list).differenceWith(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam, comparator); // $ExpectType CollectionChain + + fp.differenceWith(comparator, list, arrayParam); // $ExpectType AbcObject[] + fp.differenceWith(comparator)(list)(arrayParam); // $ExpectType AbcObject[] + fp.differenceWith(comparator)(list, arrayParam); // $ExpectType AbcObject[] + fp.differenceWith(comparator, list)(arrayParam); // $ExpectType AbcObject[] + + { + interface T1 { + a: string; + b: string; + } + interface T2 { + a: string; + b: number; + } + + const t1: T1 = { a: "a", b: "b" }; + const t2: T2 | undefined = anything; + + // $ExpectType T1[] + _.differenceWith([t1], [t2], (a, b) => { + a; // $ExpectType T1 + b; // $ExpectType T2 | undefined + return true; + }); + + // $ExpectType Collection + _([t1]).differenceWith([t2], (a, b) => { + a; // $ExpectType T1 + b; // $ExpectType T2 | undefined + return true; + }); + + // $ExpectType CollectionChain + _.chain([t1]).differenceWith([t2], (a, b) => { + a; // $ExpectType T1 + b; // $ExpectType T2 | undefined + return true; + }); + + fp.differenceWith((a: T1, b: T2 | undefined) => true, [t1], [t2]); // $ExpectType T1[] + } +} + +// _.drop +// _.dropRight +{ + _.drop(list); // $ExpectType AbcObject[] + _.drop(list, 42); // $ExpectType AbcObject[] + _(list).drop(42); // $ExpectType Collection + _.chain(list).drop(42); // $ExpectType CollectionChain + + fp.drop(42, list); // $ExpectType AbcObject[] + fp.drop(42)(list); // $ExpectType AbcObject[] + + _.dropRight(list); // $ExpectType AbcObject[] + _.dropRight(list, 42); // $ExpectType AbcObject[] + _(list).dropRight(42); // $ExpectType Collection + _.chain(list).dropRight(42); // $ExpectType CollectionChain + + fp.dropRight(42, list); // $ExpectType AbcObject[] + fp.dropRight(42)(list); // $ExpectType AbcObject[] +} + +// _.dropWhile +// _.dropRightWhile +{ + _.dropWhile(list); // $ExpectType AbcObject[] + _.dropWhile(list, listIterator); // $ExpectType AbcObject[] + _.dropWhile(list, ""); // $ExpectType AbcObject[] + _.dropWhile(list, {a: 42}); // $ExpectType AbcObject[] + + _(list).dropWhile(); // $ExpectType Collection + _(list).dropWhile(listIterator); // $ExpectType Collection + _(list).dropWhile(""); // $ExpectType Collection + _(list).dropWhile({a: 42}); // $ExpectType Collection + + _.chain(list).dropWhile(); // $ExpectType CollectionChain + _.chain(list).dropWhile(listIterator); // $ExpectType CollectionChain + _.chain(list).dropWhile(""); // $ExpectType CollectionChain + _.chain(list).dropWhile({a: 42}); // $ExpectType CollectionChain + + fp.dropWhile(valueIterator, list); // $ExpectType AbcObject[] + fp.dropWhile(valueIterator)(list); // $ExpectType AbcObject[] + fp.dropWhile("", list); // $ExpectType AbcObject[] + fp.dropWhile({ a: 42 }, list); // $ExpectType AbcObject[] + + _.dropRightWhile(list); // $ExpectType AbcObject[] + _.dropRightWhile(list, listIterator); // $ExpectType AbcObject[] + _.dropRightWhile(list, ""); // $ExpectType AbcObject[] + _.dropRightWhile(list, {a: 42}); // $ExpectType AbcObject[] + + _(list).dropRightWhile(); // $ExpectType Collection + _(list).dropRightWhile(listIterator); // $ExpectType Collection + _(list).dropRightWhile(""); // $ExpectType Collection + _(list).dropRightWhile({a: 42}); // $ExpectType Collection + + _.chain(list).dropRightWhile(); // $ExpectType CollectionChain + _.chain(list).dropRightWhile(listIterator); // $ExpectType CollectionChain + _.chain(list).dropRightWhile(""); // $ExpectType CollectionChain + _.chain(list).dropRightWhile({a: 42}); // $ExpectType CollectionChain + + fp.dropRightWhile(valueIterator, list); // $ExpectType AbcObject[] + fp.dropRightWhile(valueIterator)(list); // $ExpectType AbcObject[] + fp.dropRightWhile("", list); // $ExpectType AbcObject[] + fp.dropRightWhile({ a: 42 }, list); // $ExpectType AbcObject[] +} + +// _.fill +{ + _.fill(array, abcObject); // $ExpectType AbcObject[] + _.fill(array, abcObject, 0); // $ExpectType AbcObject[] + _.fill(array, abcObject, 0, 10); // $ExpectType AbcObject[] + + _.fill(list, abcObject); // $ExpectType ArrayLike + _.fill(list, abcObject, 0); // $ExpectType ArrayLike + _.fill(list, abcObject, 0, 10); // $ExpectType ArrayLike + + _(list).fill(abcObject); // $ExpectType Collection + _(list).fill(abcObject, 0); // $ExpectType Collection + _(list).fill(abcObject, 0, 10); // $ExpectType Collection + + _.chain(list).fill(abcObject); // $ExpectType CollectionChain + _.chain(list).fill(abcObject, 0); // $ExpectType CollectionChain + _.chain(list).fill(abcObject, 0, 10); // $ExpectType CollectionChain + + fp.fill(0, 10, abcObject, array); // $ExpectType AbcObject[] + fp.fill(0)(10)(abcObject)(array); // $ExpectType AbcObject[] + fp.fill(0, 10, abcObject, list); // $ExpectType ArrayLike +} + +// _.findIndex +// _.findLastIndex +{ + _.findIndex(list); // $ExpectType number + _.findIndex(list, listIterator); // $ExpectType number + _.findIndex(list, ""); // $ExpectType number + _.findIndex(list, {a: 42}); // $ExpectType number + _.findIndex(list, listIterator, 1); // $ExpectType number + + _(list).findIndex(); // $ExpectType number + _(list).findIndex(listIterator); // $ExpectType number + _(list).findIndex(""); // $ExpectType number + _(list).findIndex({a: 42}); // $ExpectType number + _(list).findIndex(listIterator, 1); // $ExpectType number + + _.chain(list).findIndex(); // $ExpectType PrimitiveChain + _.chain(list).findIndex(listIterator); // $ExpectType PrimitiveChain + _.chain(list).findIndex(""); // $ExpectType PrimitiveChain + _.chain(list).findIndex({a: 42}); // $ExpectType PrimitiveChain + _.chain(list).findIndex(listIterator, 1); // $ExpectType PrimitiveChain + + fp.findIndex(valueIterator, list); // $ExpectType number + fp.findIndex(valueIterator)(list); // $ExpectType number + fp.findIndex("", list); // $ExpectType number + fp.findIndex({ a: 42 }, list); // $ExpectType number + + fp.findIndexFrom(valueIterator, 1, list); // $ExpectType number + fp.findIndexFrom(valueIterator)(1)(list); // $ExpectType number + fp.findIndexFrom("", 1, list); // $ExpectType number + fp.findIndexFrom({ a: 42 }, 1, list); // $ExpectType number + + _.findLastIndex(list); // $ExpectType number + _.findLastIndex(list, listIterator); // $ExpectType number + _.findLastIndex(list, ""); // $ExpectType number + _.findLastIndex(list, {a: 42}); // $ExpectType number + _.findLastIndex(list, listIterator, 1); // $ExpectType number + + _(list).findLastIndex(); // $ExpectType number + _(list).findLastIndex(listIterator); // $ExpectType number + _(list).findLastIndex(""); // $ExpectType number + _(list).findLastIndex({a: 42}); // $ExpectType number + _(list).findLastIndex(listIterator, 1); // $ExpectType number + + _.chain(list).findLastIndex(); // $ExpectType PrimitiveChain + _.chain(list).findLastIndex(listIterator); // $ExpectType PrimitiveChain + _.chain(list).findLastIndex(""); // $ExpectType PrimitiveChain + _.chain(list).findLastIndex({a: 42}); // $ExpectType PrimitiveChain + _.chain(list).findLastIndex(listIterator, 1); // $ExpectType PrimitiveChain + + fp.findLastIndex(valueIterator, list); // $ExpectType number + fp.findLastIndex(valueIterator)(list); // $ExpectType number + fp.findLastIndex("", list); // $ExpectType number + fp.findLastIndex({ a: 42 }, list); // $ExpectType number + + fp.findLastIndexFrom(valueIterator, 1, list); // $ExpectType number + fp.findLastIndexFrom(valueIterator)(1)(list); // $ExpectType number + fp.findLastIndexFrom("", 1, list); // $ExpectType number + fp.findLastIndexFrom({ a: 42 }, 1, list); // $ExpectType number +} + +// _.first +{ + _.first("abc"); // $ExpectType string | undefined + _.first(list); // $ExpectType AbcObject | undefined + + _("abc").first(); // $ExpectType string | undefined + _(list).first(); // $ExpectType AbcObject | undefined + + _.chain("abc").first(); // $ExpectType StringNullableChain + _.chain(list).first(); // $ExpectType PrimitiveChain | ObjectChain + + fp.first("abc"); // $ExpectType string | undefined + fp.first(list); // $ExpectType AbcObject | undefined +} + +// _.flatten +{ + _.flatten("abc"); // $ExpectType string[] + _.flatten([1, 2, 3]); // $ExpectType number[] + _.flatten([1, [2, 3]]); // $ExpectType number[] + _.flatten({0: 1, 1: [2, 3], length: 2}); // $ExpectType number[] + + _("abc").flatten(); // $ExpectType Collection + _([1, 2, 3]).flatten(); // $ExpectType Collection + _([1, [2, 3]]).flatten(); // $ExpectType Collection + _({0: 1, 1: [2, 3], length: 2}).flatten(); // $ExpectType Collection + + _.chain("abc").flatten(); // $ExpectType CollectionChain + _.chain([1, 2, 3]).flatten(); // $ExpectType CollectionChain + _.chain([1, [2, 3]]).flatten(); // $ExpectType CollectionChain + _.chain({0: 1, 1: [2, 3], length: 2}).flatten(); // $ExpectType CollectionChain + + fp.flatten("abc"); // $ExpectType string[] + fp.flatten([1, 2, 3]); // $ExpectType number[] + fp.flatten([1, [2, 3]]); // $ExpectType number[] + fp.flatten({0: 1, 1: [2, 3], length: 2}); // $ExpectType number[] + fp.unnest([1, [2, 3]]); // $ExpectType number[] +} + +// _.flattenDeep +{ + _.flattenDeep([1, 2, 3]); // $ExpectType number[] + _.flattenDeep([1, [2, [3, [4, 5]]]]); // $ExpectType number[] + _.flattenDeep({0: 1, 1: [2, [3, [4, 5]]], length: 2}); // $ExpectType number[] + + _([1, 2, 3]).flattenDeep(); // $ExpectType Collection + _([1, [2, [3, [4, 5]]]]).flattenDeep(); // $ExpectType Collection + _({0: 1, 1: [2, [3, [4, 5]]], length: 2}).flattenDeep(); // $ExpectType Collection + + _.chain([1, 2, 3]).flattenDeep(); // $ExpectType CollectionChain + _.chain([1, [2, [3, [4, 5]]]]).flattenDeep(); // $ExpectType CollectionChain + _.chain({0: 1, 1: [2, [3, [4, 5]]], length: 2}).flattenDeep(); // $ExpectType CollectionChain + + fp.flattenDeep([1, 2, 3]); // $ExpectType number[] + fp.flattenDeep([1, [2, [3, [4, 5]]]]); // $ExpectType number[] + fp.flattenDeep({0: 1, 1: [2, [3, [4, 5]]], length: 2}); // $ExpectType number[] +} + +// _.fromPairs +{ + const twoDimensionalArray: string[][] | null | undefined = anything; + const numberTupleArray: Array<[string, number]> | null | undefined = anything; + + _.fromPairs(twoDimensionalArray); // $ExpectType Dictionary + _.fromPairs(numberTupleArray); // $ExpectType Dictionary + _(twoDimensionalArray).fromPairs(); // $ExpectType Object> + _.chain(twoDimensionalArray).fromPairs(); // $ExpectType ObjectChain> + fp.fromPairs(numberTupleArray); // $ExpectType Dictionary +} + +// _.head +{ + _.head("abc"); // $ExpectType string | undefined + _.head(list); // $ExpectType AbcObject | undefined + + _("abc").head(); // $ExpectType string | undefined + _(list).head(); // $ExpectType AbcObject | undefined + + _.chain("abc").head(); // $ExpectType StringNullableChain + _.chain(list).head(); // $ExpectType PrimitiveChain | ObjectChain + + fp.head("abc"); // $ExpectType string | undefined + fp.head(list); // $ExpectType AbcObject | undefined +} + +// _.indexOf +// _.lastIndexOf +// _.sortedIndexOf +// _.sortedLastIndexOf +{ + _.indexOf(list, abcObject); // $ExpectType number + _.indexOf(list, abcObject, 42); // $ExpectType number + _(list).indexOf(abcObject); // $ExpectType number + _(list).indexOf(abcObject, 42); // $ExpectType number + _.chain(list).indexOf(abcObject); // $ExpectType PrimitiveChain + _.chain(list).indexOf(abcObject, 42); // $ExpectType PrimitiveChain + fp.indexOf(abcObject, list); // $ExpectType number + fp.indexOf(abcObject)(list); // $ExpectType number + fp.indexOfFrom(abcObject)(42)(list); // $ExpectType number + + _.lastIndexOf(list, abcObject); // $ExpectType number + _.lastIndexOf(list, abcObject, 42); // $ExpectType number + _(list).lastIndexOf(abcObject); // $ExpectType number + _(list).lastIndexOf(abcObject, 42); // $ExpectType number + _.chain(list).lastIndexOf(abcObject); // $ExpectType PrimitiveChain + _.chain(list).lastIndexOf(abcObject, 42); // $ExpectType PrimitiveChain + fp.lastIndexOf(abcObject, list); // $ExpectType number + fp.lastIndexOf(abcObject)(list); // $ExpectType number + fp.lastIndexOfFrom(abcObject)(42)(list); // $ExpectType number + + _.sortedIndexOf(list, abcObject); // $ExpectType number + _(list).sortedIndexOf(abcObject); // $ExpectType number + _.chain(list).indexOf(abcObject); // $ExpectType PrimitiveChain + fp.sortedIndexOf(abcObject, list); // $ExpectType number + fp.sortedIndexOf(abcObject)(list); // $ExpectType number + + _.sortedLastIndexOf(list, abcObject); // $ExpectType number + _(list).sortedLastIndexOf(abcObject); // $ExpectType number + _.chain(list).sortedLastIndexOf(abcObject); // $ExpectType PrimitiveChain + fp.sortedLastIndexOf(abcObject, list); // $ExpectType number + fp.sortedLastIndexOf(abcObject)(list); // $ExpectType number +} + +// _.initial +{ + _.initial(list); // $ExpectType AbcObject[] + _(list).initial(); // $ExpectType Collection + _.chain(list).initial(); // $ExpectType CollectionChain + fp.initial(list); // $ExpectType AbcObject[] +} + +// _.intersection +{ + const list: _.List = anything; + + _.intersection(list, list); // $ExpectType AbcObject[] + _.intersection(list, list, list); // $ExpectType AbcObject[] + _(list).intersection(list); // $ExpectType Collection + _(list).intersection(list, list); // $ExpectType Collection + _.chain(list).intersection(list); // $ExpectType CollectionChain + _.chain(list).intersection(list, list); // $ExpectType CollectionChain + fp.intersection(list, list); // $ExpectType AbcObject[] + fp.intersection(list)(list); // $ExpectType AbcObject[] +} + +// _.intersectionBy +{ + const list: _.List = anything; + + _.intersectionBy(list, list); // $ExpectType AbcObject[] + _.intersectionBy(list, list, list); // $ExpectType AbcObject[] + _.intersectionBy(list, list, "a"); // $ExpectType AbcObject[] + _.intersectionBy(list, list, list, { a: 42 }); // $ExpectType AbcObject[] + _.intersectionBy(list, list, ["a", 42]); // $ExpectType AbcObject[] + // $ExpectType AbcObject[] + _.intersectionBy(list, list, (value) => { + value; // $ExpectType AbcObject + return 0; + }); + // $ExpectType AbcObject[] + _.intersectionBy(list, list, list, (value) => { + value; // $ExpectType AbcObject + return 0; + }); + + _(list).intersectionBy(list); // $ExpectType Collection + _(list).intersectionBy(list, "a"); // $ExpectType Collection + _(list).intersectionBy(list, list, { a: 42 }); // $ExpectType Collection + _(list).intersectionBy(list, ["a", 42]); // $ExpectType Collection + // $ExpectType Collection + _(list).intersectionBy(list, (value) => { + value; // $ExpectType AbcObject + return 1; + }); + + _.chain(list).intersectionBy(list); // $ExpectType CollectionChain + _.chain(list).intersectionBy(list, "a"); // $ExpectType CollectionChain + _.chain(list).intersectionBy(list, list, { a: 42 }); // $ExpectType CollectionChain + _.chain(list).intersectionBy(list, ["a", 42]); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(list).intersectionBy(list, (value) => { + value; // $ExpectType AbcObject + return null; + }); + + fp.intersectionBy("a", list, list); // $ExpectType AbcObject[] + fp.intersectionBy("a", list, list); // $ExpectType AbcObject[] + fp.intersectionBy({ a: 42 }, list, list); // $ExpectType AbcObject[] + fp.intersectionBy(["a", 42], list, list); // $ExpectType AbcObject[] + fp.intersectionBy((value: AbcObject) => 0, list, list); // $ExpectType AbcObject[] + + interface T1 { + a: string; + b: string; + } + interface T2 { + a: string; + b: number; + } + const t1: T1 = { a: "a", b: "b" }; + const t2: T2 = { a: "a", b: 1 }; + // $ExpectType T1[] + _.intersectionBy([t1], [t2], (value) => { + value; // $ExpectType T1 | T2 + return undefined; + }); + // $ExpectType Collection + _([t1]).intersectionBy([t2], (value) => { + value; // $ExpectType T1 | T2 + return {}; + }); + // $ExpectType CollectionChain + _.chain([t1]).intersectionBy([t2], (value) => { + value; // $ExpectType T1 | T2 + return {}; + }); +} + +// _.intersectionWith +{ + const list: _.List = anything; + + _.intersectionWith(list, list); // $ExpectType AbcObject[] + _.intersectionWith(list, list, list); // $ExpectType AbcObject[] + // $ExpectType AbcObject[] + _.intersectionWith(list, list, (a, b) => { + a; // $ExpectType AbcObject + b; // $ExpectType AbcObject + return true; + }); + // $ExpectType AbcObject[] + _.intersectionWith(list, list, list, (a, b) => { + a; // $ExpectType AbcObject + b; // $ExpectType AbcObject + return true; + }); + + _(list).intersectionWith(list); // $ExpectType Collection + _(list).intersectionWith(list, list); // $ExpectType Collection + // $ExpectType Collection + _(list).intersectionWith(list, (a, b) => { + a; // $ExpectType AbcObject + b; // $ExpectType AbcObject + return true; + }); + + _.chain(list).intersectionWith(list); // $ExpectType CollectionChain + _.chain(list).intersectionWith(list, list); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(list).intersectionWith(list, (a, b) => { + a; // $ExpectType AbcObject + b; // $ExpectType AbcObject + return true; + }); + + fp.intersectionWith((a: AbcObject, b: AbcObject) => true, list, list); // $ExpectType AbcObject[] + fp.intersectionWith((a: AbcObject, b: AbcObject) => true)(list)(list); // $ExpectType AbcObject[] + + interface T1 { + a: string; + b: string; + } + interface T2 { + a: string; + b: number; + } + const t1: T1 = { a: "a", b: "b" }; + const t2: T2 = { a: "a", b: 1 }; + // $ExpectType T1[] + _.intersectionWith([t1], [t2], (a, b) => { + a; // $ExpectType T1 + b; // $ExpectType T2 + return true; + }); + // $ExpectType Collection + _([t1]).intersectionWith([t2], (a, b) => { + a; // $ExpectType T1 + b; // $ExpectType T2 + return true; + }); + // $ExpectType CollectionChain + _.chain([t1]).intersectionWith([t2], (a, b) => { + a; // $ExpectType T1 + b; // $ExpectType T2 + return true; + }); + + fp.intersectionWith((a: T1, b: T2) => true)([t1])([t2]); // $ExpectType T1[] +} + +// _.join +{ + const list: _.List | null | undefined = anything; + + _.join("abc"); // $ExpectType string + _.join("abc", "_"); // $ExpectType string + _.join(list); // $ExpectType string + _.join(list, "_"); // $ExpectType string + + _("abc").join(); // $ExpectType string + _("abc").join("_"); // $ExpectType string + _(list).join(); // $ExpectType string + _(list).join("_"); // $ExpectType string + + _.chain("abc").join(); // $ExpectType StringChain + _.chain("abc").join("_"); // $ExpectType StringChain + _.chain(list).join(); // $ExpectType StringChain + _.chain(list).join("_"); // $ExpectType StringChain + + fp.join("_", "abc"); // $ExpectType string + fp.join("_")(list); // $ExpectType string +} + +// _.last +{ + _.last("abc"); // $ExpectType string | undefined + _.last(list); // $ExpectType AbcObject | undefined + + _("abc").last(); // $ExpectType string | undefined + _(list).last(); // $ExpectType AbcObject | undefined + + _.chain("abc").last(); // $ExpectType StringNullableChain + _.chain(list).last(); // $ExpectType PrimitiveChain | ObjectChain + + fp.last("abc"); // $ExpectType string | undefined + fp.last(list); // $ExpectType AbcObject | undefined +} + +// _.nth +{ + _.nth(list, 42); // $ExpectType AbcObject | undefined + _(list).nth(42); // $ExpectType AbcObject | undefined + _.chain(list).nth(42); // $ExpectType PrimitiveChain | ObjectChain + + fp.nth(42, list); // $ExpectType AbcObject | undefined + fp.nth(42)(list); // $ExpectType AbcObject | undefined +} + +// _.pull +{ + const array: AbcObject[] = []; + const list: _.List = []; + + _.pull(array); // $ExpectType AbcObject[] + _.pull(array, abcObject); // $ExpectType AbcObject[] + _.pull(array, abcObject, abcObject, abcObject); // $ExpectType AbcObject[] + _.pull(list); // $ExpectType ArrayLike + _.pull(list, abcObject); // $ExpectType ArrayLike + _.pull(list, abcObject, abcObject, abcObject); // $ExpectType ArrayLike + + _(array).pull(); // $ExpectType Collection + _(array).pull(abcObject); // $ExpectType Collection + _(array).pull(abcObject, abcObject, abcObject); // $ExpectType Collection + _(list).pull(); // $ExpectType Collection + _(list).pull(abcObject); // $ExpectType Collection + _(list).pull(abcObject, abcObject, abcObject); // $ExpectType Collection + + _.chain(array).pull(); // $ExpectType CollectionChain + _.chain(array).pull(abcObject); // $ExpectType CollectionChain + _.chain(array).pull(abcObject, abcObject, abcObject); // $ExpectType CollectionChain + _.chain(list).pull(); // $ExpectType CollectionChain + _.chain(list).pull(abcObject); // $ExpectType CollectionChain + _.chain(list).pull(abcObject, abcObject, abcObject); // $ExpectType CollectionChain + + fp.pull(abcObject, array); // $ExpectType AbcObject[] + fp.pull(abcObject)(list); // $ExpectType ArrayLike +} + +// _.pullAt +{ + const array: AbcObject[] = []; + const list: _.List = []; + + _.pullAt(array); // $ExpectType AbcObject[] + _.pullAt(array, 1); // $ExpectType AbcObject[] + _.pullAt(array, [2, 3], 4); // $ExpectType AbcObject[] + _.pullAt(list); // $ExpectType ArrayLike + _.pullAt(list, 1); // $ExpectType ArrayLike + _.pullAt(list, [2, 3], 4); // $ExpectType ArrayLike + + _(array).pullAt(); // $ExpectType Collection + _(array).pullAt(1); // $ExpectType Collection + _(array).pullAt([2, 3], 4); // $ExpectType Collection + _(list).pullAt(); // $ExpectType Collection + _(list).pullAt(1); // $ExpectType Collection + _(list).pullAt([2, 3], 4); // $ExpectType Collection + + _.chain(array).pullAt(); // $ExpectType CollectionChain + _.chain(array).pullAt(1); // $ExpectType CollectionChain + _.chain(array).pullAt([2, 3], 4); // $ExpectType CollectionChain + _.chain(list).pullAt(); // $ExpectType CollectionChain + _.chain(list).pullAt(1); // $ExpectType CollectionChain + _.chain(list).pullAt([2, 3], 4); // $ExpectType CollectionChain + + fp.pullAt(1, array); // $ExpectType AbcObject[] + fp.pullAt([2, 3], array); // $ExpectType AbcObject[] + fp.pullAt(1, list); // $ExpectType ArrayLike + fp.pullAt([2, 3], list); // $ExpectType ArrayLike + fp.pullAt(1)(list); // $ExpectType ArrayLike +} + +// _.pullAll +{ + const array: AbcObject[] = anything; + const list: _.List = anything; + const values: _.List = anything; + + _.pullAll(array); // $ExpectType AbcObject[] + _.pullAll(array, values); // $ExpectType AbcObject[] + _.pullAll(list); // $ExpectType ArrayLike + _.pullAll(list, values); // $ExpectType ArrayLike + + _(array).pullAll(); // $ExpectType Collection + _(array).pullAll(values); // $ExpectType Collection + _(list).pullAll(); // $ExpectType Collection + _(list).pullAll(values); // $ExpectType Collection + + _.chain(array).pullAll(); // $ExpectType CollectionChain + _.chain(array).pullAll(values); // $ExpectType CollectionChain + _.chain(list).pullAll(); // $ExpectType CollectionChain + _.chain(list).pullAll(values); // $ExpectType CollectionChain + + fp.pullAll(values, array); // $ExpectType AbcObject[] + fp.pullAll(values, list); // $ExpectType ArrayLike + fp.pullAll(values)(list); // $ExpectType ArrayLike +} + +// _.pullAllBy +// _.pullAllWith +{ + const array: AbcObject[] = anything; + const list: _.List = anything; + const values: _.List = anything; + + _.pullAllBy(array); // $ExpectType AbcObject[] + _.pullAllBy(array, values, "a"); // $ExpectType AbcObject[] + // $ExpectType AbcObject[] + _.pullAllBy(array, values, (value) => { + value; // $ExpectType AbcObject + return []; + }); + + _.pullAllBy(list); // $ExpectType ArrayLike + _.pullAllBy(list, values); // $ExpectType ArrayLike + _.pullAllBy(list, values, "a"); // $ExpectType ArrayLike + _.pullAllBy(list, values, { a: 42 }); // $ExpectType ArrayLike + _.pullAllBy(list, values, ["a", 42]); // $ExpectType ArrayLike + // $ExpectType ArrayLike + _.pullAllBy(list, values, (value) => { + value; // $ExpectType AbcObject + return () => {}; + }); + + _(array).pullAllBy(); // $ExpectType Collection + _(array).pullAllBy(values, "a"); // $ExpectType Collection + // $ExpectType Collection + _(array).pullAllBy(values, (value) => { + value; // $ExpectType AbcObject + return 0; + }); + _(list).pullAllBy(); // $ExpectType Collection + _(list).pullAllBy(values, "a"); // $ExpectType Collection + // $ExpectType Collection + _(list).pullAllBy(values, (value) => { + value; // $ExpectType AbcObject + return 0; + }); + + _.chain(array).pullAllBy(); // $ExpectType CollectionChain + _.chain(array).pullAllBy(values, "a"); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(array).pullAllBy(values, (value) => { + value; // $ExpectType AbcObject + return 0; + }); + _.chain(list).pullAllBy(); // $ExpectType CollectionChain + _.chain(list).pullAllBy(values, "a"); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(list).pullAllBy(values, (value) => { + value; // $ExpectType AbcObject + return 0; + }); + + fp.pullAllBy("a", values, array); // $ExpectType AbcObject[] + fp.pullAllBy({ a: 42 }, values, array); // $ExpectType AbcObject[] + fp.pullAllBy(["a", 42], values, array); // $ExpectType AbcObject[] + fp.pullAllBy((value: AbcObject) => true, values, array); // $ExpectType AbcObject[] + fp.pullAllBy((value: AbcObject) => true)(values, array); // $ExpectType AbcObject[] + fp.pullAllBy((value: AbcObject) => true, values)(array); // $ExpectType AbcObject[] + fp.pullAllBy((value: AbcObject) => true)(values)(array); // $ExpectType AbcObject[] + fp.pullAllBy("a", values, list); // $ExpectType ArrayLike + fp.pullAllBy({ a: 42 }, values, list); // $ExpectType ArrayLike + fp.pullAllBy(["a", 42], values, list); // $ExpectType ArrayLike + fp.pullAllBy((value: AbcObject) => true, values, list); // $ExpectType ArrayLike + fp.pullAllBy((value: AbcObject) => true)(values, list); // $ExpectType ArrayLike + fp.pullAllBy((value: AbcObject) => true, values)(list); // $ExpectType ArrayLike + fp.pullAllBy((value: AbcObject) => true)(values)(list); // $ExpectType ArrayLike + + interface T1 { + a: string; + b: string; + } + interface T2 { + a: string; + b: number; + } + const t1: T1 = { a: "a", b: "b" }; + const t2: T2 = { a: "a", b: 1 }; + // $ExpectType T1[] + _.pullAllBy([t1], [t2], (value) => { + value; // $ExpectType T1 | T2 + return ""; + }); + // $ExpectType Collection + _([t1]).pullAllBy([t2], (value) => { + value; // $ExpectType T1 | T2 + return ""; + }); + // $ExpectType CollectionChain + _.chain([t1]).pullAllBy([t2], (value) => { + value; // $ExpectType T1 | T2 + return ""; + }); + + fp.pullAllBy((value: T1 | T2) => value.a, [t2], [t1]); // $ExpectType T1[] + fp.pullAllBy((value: T1 | T2) => value.a)([t2])([t1]); // $ExpectType (T1 | T2)[] + + _.pullAllWith(array); // $ExpectType AbcObject[] + _.pullAllWith(array, values); // $ExpectType AbcObject[] + // $ExpectType AbcObject[] + _.pullAllWith(array, values, (a, b) => { + a; // $ExpectType AbcObject + b; // $ExpectType AbcObject + return true; + }); + _.pullAllWith(list); // $ExpectType ArrayLike + // $ExpectType ArrayLike + _.pullAllWith(list, values, (a, b) => { + a; // $ExpectType AbcObject + b; // $ExpectType AbcObject + return true; + }); + + _(array).pullAllWith(); // $ExpectType Collection + _(array).pullAllWith(values); // $ExpectType Collection + // $ExpectType Collection + _(array).pullAllWith(values, (a, b) => { + a; // $ExpectType AbcObject + b; // $ExpectType AbcObject + return true; + }); + _(list).pullAllWith(); // $ExpectType Collection + // $ExpectType Collection + _(list).pullAllWith(values, (a, b) => { + a; // $ExpectType AbcObject + b; // $ExpectType AbcObject + return true; + }); + + _.chain(array).pullAllWith(); // $ExpectType CollectionChain + _.chain(array).pullAllWith(values); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(array).pullAllWith(values, (a, b) => { + a; // $ExpectType AbcObject + b; // $ExpectType AbcObject + return true; + }); + _.chain(list).pullAllWith(); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(list).pullAllWith(values, (a, b) => { + a; // $ExpectType AbcObject + b; // $ExpectType AbcObject + return true; + }); + + fp.pullAllWith((a, b) => true, values, array); // $ExpectType AbcObject[] + fp.pullAllWith((a: AbcObject, b: AbcObject) => true)(values, array); // $ExpectType AbcObject[] + fp.pullAllWith((a, b) => true, values, list); // $ExpectType ArrayLike + fp.pullAllWith((a: AbcObject, b: AbcObject) => true)(values, list); // $ExpectType ArrayLike + + // $ExpectType T1[] + _.pullAllWith([t1], [t2], (a, b) => { + a; // $ExpectType T1 + b; // $ExpectType T2 + return true; + }); + // $ExpectType Collection + _([t1]).pullAllWith([t2], (a, b) => { + a; // $ExpectType T1 + b; // $ExpectType T2 + return true; + }); + // $ExpectType CollectionChain + _.chain([t1]).pullAllWith([t2], (a, b) => { + a; // $ExpectType T1 + b; // $ExpectType T2 + return true; + }); + + fp.pullAllWith((a, b) => a.a === b.a, [t2], [t1]); // $ExpectType T1[] + fp.pullAllWith((a: T1, b: T2) => a.a === b.a)([t2], [t1]); // $ExpectType T1[] +} + +// _.remove +{ + const list: _.List = []; + + _.remove(list); // $ExpectType AbcObject[] + _.remove(list, listIterator); // $ExpectType AbcObject[] + _.remove(list, ""); // $ExpectType AbcObject[] + _.remove(list, { a: 42 }); // $ExpectType AbcObject[] + + _(list).remove(); // $ExpectType Collection + _(list).remove(listIterator); // $ExpectType Collection + _(list).remove(""); // $ExpectType Collection + _(list).remove({ a: 42 }); // $ExpectType Collection + + _.chain(list).remove(); // $ExpectType CollectionChain + _.chain(list).remove(listIterator); // $ExpectType CollectionChain + _.chain(list).remove(""); // $ExpectType CollectionChain + _.chain(list).remove({ a: 42 }); // $ExpectType CollectionChain + + fp.remove(valueIterator, list); // $ExpectType AbcObject[] + fp.remove(valueIterator)(list); // $ExpectType AbcObject[] + fp.remove("", list); // $ExpectType AbcObject[] + fp.remove({ a: 42 }, list); // $ExpectType AbcObject[] +} + +// _.tail +{ + _.tail(list); // $ExpectType AbcObject[] + _(list).tail(); // $ExpectType Collection + _.chain(list).tail(); // $ExpectType CollectionChain + fp.tail(list); // $ExpectType AbcObject[] +} + +// _.slice +{ + _.slice(array); // $ExpectType AbcObject[] + _.slice(array, 42); // $ExpectType AbcObject[] + _.slice(array, 42, 42); // $ExpectType AbcObject[] + _(array).slice(); // $ExpectType Collection + _(array).slice(42, 42); // $ExpectType Collection + _.chain(array).slice(); // $ExpectType CollectionChain + _.chain(array).slice(42, 42); // $ExpectType CollectionChain + fp.slice(0, 10, array); // $ExpectType AbcObject[] + fp.slice(0)(10, array); // $ExpectType AbcObject[] + fp.slice(0)(10)(array); // $ExpectType AbcObject[] +} + +// _.sortedIndexBy +// _.sortedLastIndexBy +{ + _.sortedIndexBy(list, abcObject, valueIterator); // $ExpectType number + _.sortedIndexBy(list, abcObject, ""); // $ExpectType number + _.sortedIndexBy(list, abcObject, { a: 42 }); // $ExpectType number + _(list).sortedIndexBy(abcObject, valueIterator); // $ExpectType number + _(list).sortedIndexBy(abcObject, ""); // $ExpectType number + _(list).sortedIndexBy(abcObject, { a: 42 }); // $ExpectType number + _.chain(list).sortedIndexBy(abcObject, valueIterator); // $ExpectType PrimitiveChain + _.chain(list).sortedIndexBy(abcObject, ""); // $ExpectType PrimitiveChain + _.chain(list).sortedIndexBy(abcObject, { a: 42 }); // $ExpectType PrimitiveChain + fp.sortedIndexBy(valueIterator, abcObject, list); // $ExpectType number + fp.sortedIndexBy(valueIterator)(abcObject)(list); // $ExpectType number + fp.sortedIndexBy("a", abcObject, list); // $ExpectType number + fp.sortedIndexBy({ a: 42 }, abcObject, list); // $ExpectType number + + _.sortedLastIndexBy(list, abcObject, valueIterator); // $ExpectType number + _.sortedLastIndexBy(list, abcObject, ""); // $ExpectType number + _.sortedLastIndexBy(list, abcObject, { a: 42 }); // $ExpectType number + _(list).sortedLastIndexBy(abcObject, valueIterator); // $ExpectType number + _(list).sortedLastIndexBy(abcObject, ""); // $ExpectType number + _(list).sortedLastIndexBy(abcObject, { a: 42 }); // $ExpectType number + _.chain(list).sortedLastIndexBy(abcObject, valueIterator); // $ExpectType PrimitiveChain + _.chain(list).sortedLastIndexBy(abcObject, ""); // $ExpectType PrimitiveChain + _.chain(list).sortedLastIndexBy(abcObject, { a: 42 }); // $ExpectType PrimitiveChain + fp.sortedLastIndexBy(valueIterator, abcObject, list); // $ExpectType number + fp.sortedLastIndexBy(valueIterator)(abcObject)(list); // $ExpectType number + fp.sortedLastIndexBy("a", abcObject, list); // $ExpectType number + fp.sortedLastIndexBy({ a: 42 }, abcObject, list); // $ExpectType number +} + +// _.sortedIndex +// _.sortedLastIndex +{ + _.sortedIndex(list, abcObject); // $ExpectType number + _(list).sortedIndex(abcObject); // $ExpectType number + _.chain(list).sortedIndex(abcObject); // $ExpectType PrimitiveChain + fp.sortedIndex(abcObject, list); // $ExpectType number + fp.sortedIndex(abcObject)(list); // $ExpectType number + + _.sortedLastIndex(list, abcObject); // $ExpectType number + _(list).sortedLastIndex(abcObject); // $ExpectType number + _.chain(list).sortedLastIndex(abcObject); // $ExpectType PrimitiveChain + fp.sortedLastIndex(abcObject, list); // $ExpectType number + fp.sortedLastIndex(abcObject)(list); // $ExpectType number +} + +// _.take +// _.takeRight +{ + _.take(list); // $ExpectType AbcObject[] + _.take(list, 42); // $ExpectType AbcObject[] + _(list).take(); // $ExpectType Collection + _(list).take(42); // $ExpectType Collection + _.chain(list).take(); // $ExpectType CollectionChain + _.chain(list).take(42); // $ExpectType CollectionChain + fp.take(42, list); // $ExpectType AbcObject[] + fp.take(42)(list); // $ExpectType AbcObject[] + + _.takeRight(list); // $ExpectType AbcObject[] + _.takeRight(list, 42); // $ExpectType AbcObject[] + _(list).takeRight(); // $ExpectType Collection + _(list).takeRight(42); // $ExpectType Collection + _.chain(list).takeRight(); // $ExpectType CollectionChain + _.chain(list).takeRight(42); // $ExpectType CollectionChain + fp.takeRight(42, list); // $ExpectType AbcObject[] + fp.takeRight(42)(list); // $ExpectType AbcObject[] +} + +// _.takeWhile +// _.takeRightWhile +{ + _.takeWhile(list); // $ExpectType AbcObject[] + _.takeWhile(list, listIterator); // $ExpectType AbcObject[] + _.takeWhile(list, ""); // $ExpectType AbcObject[] + _.takeWhile(list, { a: 42 }); // $ExpectType AbcObject[] + + _(list).takeWhile(); // $ExpectType Collection + _(list).takeWhile(listIterator); // $ExpectType Collection + _(list).takeWhile(""); // $ExpectType Collection + _(list).takeWhile({ a: 42 }); // $ExpectType Collection + + _.chain(list).takeWhile(); // $ExpectType CollectionChain + _.chain(list).takeWhile(listIterator); // $ExpectType CollectionChain + _.chain(list).takeWhile(""); // $ExpectType CollectionChain + _.chain(list).takeWhile({ a: 42 }); // $ExpectType CollectionChain + + fp.takeWhile(valueIterator, list); // $ExpectType AbcObject[] + fp.takeWhile(valueIterator)(list); // $ExpectType AbcObject[] + fp.takeWhile("a", list); // $ExpectType AbcObject[] + fp.takeWhile({ a: 42 }, list); // $ExpectType AbcObject[] + + _.takeRightWhile(list); // $ExpectType AbcObject[] + _.takeRightWhile(list, listIterator); // $ExpectType AbcObject[] + _.takeRightWhile(list, ""); // $ExpectType AbcObject[] + _.takeRightWhile(list, { a: 42 }); // $ExpectType AbcObject[] + + _(list).takeRightWhile(); // $ExpectType Collection + _(list).takeRightWhile(listIterator); // $ExpectType Collection + _(list).takeRightWhile(""); // $ExpectType Collection + _(list).takeRightWhile({ a: 42 }); // $ExpectType Collection + + _.chain(list).takeRightWhile(); // $ExpectType CollectionChain + _.chain(list).takeRightWhile(listIterator); // $ExpectType CollectionChain + _.chain(list).takeRightWhile(""); // $ExpectType CollectionChain + _.chain(list).takeRightWhile({ a: 42 }); // $ExpectType CollectionChain + + fp.takeRightWhile(valueIterator, list); // $ExpectType AbcObject[] + fp.takeRightWhile(valueIterator)(list); // $ExpectType AbcObject[] + fp.takeRightWhile("a", list); // $ExpectType AbcObject[] + fp.takeRightWhile({ a: 42 }, list); // $ExpectType AbcObject[] +} + +// _.union +{ + _.union(list); // $ExpectType AbcObject[] + _.union(list, list); // $ExpectType AbcObject[] + _.union(list, list, list); // $ExpectType AbcObject[] + + _(list).union(); // $ExpectType Collection + _(list).union(list); // $ExpectType Collection + _(list).union(list, list); // $ExpectType Collection + + _.chain(list).union(); // $ExpectType CollectionChain + _.chain(list).union(list); // $ExpectType CollectionChain + _.chain(list).union(list, list); // $ExpectType CollectionChain + + fp.union(list, list); // $ExpectType AbcObject[] + fp.union(list)(list); // $ExpectType AbcObject[] +} + +// _.unionBy +{ + _.unionBy(list, list); // $ExpectType AbcObject[] + _.unionBy(list, list, valueIterator); // $ExpectType AbcObject[] + _.unionBy(list, list, list, list, list, list, valueIterator); // $ExpectType AbcObject[] + _.unionBy(list, list, "a"); // $ExpectType AbcObject[] + _.unionBy(list, list, list, list, list, list, "a"); // $ExpectType AbcObject[] + _.unionBy(list, list, {a: 1}); // $ExpectType AbcObject[] + _.unionBy(list, list, list, list, list, list, {a: 1}); // $ExpectType AbcObject[] + + _(list).unionBy(list); // $ExpectType Collection + _(list).unionBy(list, valueIterator); // $ExpectType Collection + _(list).unionBy(list, list, list, list, list, valueIterator); // $ExpectType Collection + _(list).unionBy(list, "a"); // $ExpectType Collection + _(list).unionBy(list, list, list, list, list, "a"); // $ExpectType Collection + _(list).unionBy(list, {a: 1}); // $ExpectType Collection + _(list).unionBy(list, list, list, list, list, {a: 1}); // $ExpectType Collection + + _.chain(list).unionBy(list); // $ExpectType CollectionChain + _.chain(list).unionBy(list, valueIterator); // $ExpectType CollectionChain + _.chain(list).unionBy(list, list, list, list, list, valueIterator); // $ExpectType CollectionChain + _.chain(list).unionBy(list, "a"); // $ExpectType CollectionChain + _.chain(list).unionBy(list, list, list, list, list, "a"); // $ExpectType CollectionChain + _.chain(list).unionBy(list, {a: 1}); // $ExpectType CollectionChain + _.chain(list).unionBy(list, list, list, list, list, {a: 1}); // $ExpectType CollectionChain + + fp.unionBy(valueIterator, list, list); // $ExpectType AbcObject[] + fp.unionBy(valueIterator)(list)(list); // $ExpectType AbcObject[] + fp.unionBy("a", list, list); // $ExpectType AbcObject[] + fp.unionBy({ a: 1 }, list, list); // $ExpectType AbcObject[] +} + +// _.uniq +// _.sortedUniq +{ + _.uniq("abc"); // $ExpectType string[] + _.uniq(list); // $ExpectType AbcObject[] + _(list).uniq(); // $ExpectType Collection + _.chain(list).uniq(); // $ExpectType CollectionChain + fp.uniq("abc"); // $ExpectType string[] + fp.uniq(list); // $ExpectType AbcObject[] + + _.sortedUniq("abc"); // $ExpectType string[] + _.sortedUniq(list); // $ExpectType AbcObject[] + _(list).sortedUniq(); // $ExpectType Collection + _.chain(list).sortedUniq(); // $ExpectType CollectionChain + fp.sortedUniq("abc"); // $ExpectType string[] + fp.sortedUniq(list); // $ExpectType AbcObject[] +} + +// _.uniqBy +// _.sortedUniqBy +{ + _.uniqBy("abc", stringIterator); // $ExpectType string[] + _.uniqBy(list, valueIterator); // $ExpectType AbcObject[] + _.uniqBy(list, "a"); // $ExpectType AbcObject[] + _(list).uniqBy(valueIterator); // $ExpectType Collection + _(list).uniqBy("a"); // $ExpectType Collection + _.chain(list).uniqBy(valueIterator); // $ExpectType CollectionChain + _.chain(list).uniqBy("a"); // $ExpectType CollectionChain + + fp.uniqBy(stringIterator, "abc"); // $ExpectType string[] + fp.uniqBy(valueIterator, list); // $ExpectType AbcObject[] + fp.uniqBy(valueIterator)(list); // $ExpectType AbcObject[] + fp.uniqBy("a", list); // $ExpectType AbcObject[] + + _.sortedUniqBy("abc", stringIterator); // $ExpectType string[] + _.sortedUniqBy(list, valueIterator); // $ExpectType AbcObject[] + _.sortedUniqBy(list, "a"); // $ExpectType AbcObject[] + _(list).sortedUniqBy(valueIterator); // $ExpectType Collection + _(list).sortedUniqBy("a"); // $ExpectType Collection + _.chain(list).sortedUniqBy(valueIterator); // $ExpectType CollectionChain + _.chain(list).sortedUniqBy("a"); // $ExpectType CollectionChain + + fp.sortedUniqBy(stringIterator, "abc"); // $ExpectType string[] + fp.sortedUniqBy(valueIterator, list); // $ExpectType AbcObject[] + fp.sortedUniqBy(valueIterator)(list); // $ExpectType AbcObject[] + fp.sortedUniqBy("a", list); // $ExpectType AbcObject[] +} + +// _.unzip +{ + const list: _.List<_.List> | null | undefined = anything; + + _.unzip(list); // $ExpectType AbcObject[][] + _(list).unzip(); // $ExpectType Collection + _.chain(list).unzip(); // $ExpectType CollectionChain + fp.unzip(list); // $ExpectType AbcObject[][] +} + +// _.unzipWith +{ + const list: _.List<_.List> | null | undefined = anything; + + _.unzipWith(list); // $ExpectType AbcObject[][] + // $ExpectType number[] + _.unzipWith(list, (...group) => { + group; // $ExpectType AbcObject[] + return 1; + }); + // $ExpectType boolean[] + _.unzipWith(list, (value1, value2, value3) => { + value1; // $ExpectType AbcObject + value2; // $ExpectType AbcObject + value3; // $ExpectType AbcObject + return true; + }); + _(list).unzipWith(); // $ExpectType Collection + // $ExpectType Collection + _(list).unzipWith((...group) => { + group; // $ExpectType AbcObject[] + return 1; + }); + _.chain(list).unzipWith(); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(list).unzipWith((...group) => { + group; // $ExpectType AbcObject[] + return 1; + }); + + fp.unzipWith((...group: AbcObject[]) => 1, list); // $ExpectType number[] + fp.unzipWith((...group: AbcObject[]) => 1)(list); // $ExpectType number[] +} + +// _.without +{ + const list: _.List | null | undefined = anything; + + _.without(list); // $ExpectType number[] + _.without(list, 1); // $ExpectType number[] + _.without(list, 1, 2, 3); // $ExpectType number[] + + _(list).without(); // $ExpectType Collection + _(list).without(1); // $ExpectType Collection + _(list).without(1, 2, 3); // $ExpectType Collection + + _.chain(list).without(); // $ExpectType CollectionChain + _.chain(list).without(1); // $ExpectType CollectionChain + _.chain(list).without(1, 2, 3); // $ExpectType CollectionChain + + fp.without([1, 2], list); + fp.without([1, 2])(list); +} + +// _.xor +{ + _.xor(list); // $ExpectType AbcObject[] + _.xor(list, list); // $ExpectType AbcObject[] + _.xor(list, list, list); // $ExpectType AbcObject[] + + _(list).xor(); // $ExpectType Collection + _(list).xor(list); // $ExpectType Collection + _(list).xor(list, list); // $ExpectType Collection + + _.chain(list).xor(); // $ExpectType CollectionChain + _.chain(list).xor(list); // $ExpectType CollectionChain + _.chain(list).xor(list, list); // $ExpectType CollectionChain + + fp.xor(list, list); // $ExpectType AbcObject[] + fp.xor(list)(list); // $ExpectType AbcObject[] +} + +// _.xorBy +{ + _.xorBy(list, list); // $ExpectType AbcObject[] + _.xorBy(list, list, valueIterator); // $ExpectType AbcObject[] + _.xorBy(list, list, list, list, list, list, valueIterator); // $ExpectType AbcObject[] + _.xorBy(list, list, "a"); // $ExpectType AbcObject[] + _.xorBy(list, list, list, list, list, list, "a"); // $ExpectType AbcObject[] + _.xorBy(list, list, {a: 1}); // $ExpectType AbcObject[] + _.xorBy(list, list, list, list, list, list, {a: 1}); // $ExpectType AbcObject[] + + _(list).xorBy(list); // $ExpectType Collection + _(list).xorBy(list, valueIterator); // $ExpectType Collection + _(list).xorBy(list, list, list, list, list, valueIterator); // $ExpectType Collection + _(list).xorBy(list, "a"); // $ExpectType Collection + _(list).xorBy(list, list, list, list, list, "a"); // $ExpectType Collection + _(list).xorBy(list, {a: 1}); // $ExpectType Collection + _(list).xorBy(list, list, list, list, list, {a: 1}); // $ExpectType Collection + + _.chain(list).xorBy(list); // $ExpectType CollectionChain + _.chain(list).xorBy(list, valueIterator); // $ExpectType CollectionChain + _.chain(list).xorBy(list, list, list, list, list, valueIterator); // $ExpectType CollectionChain + _.chain(list).xorBy(list, "a"); // $ExpectType CollectionChain + _.chain(list).xorBy(list, list, list, list, list, "a"); // $ExpectType CollectionChain + _.chain(list).xorBy(list, {a: 1}); // $ExpectType CollectionChain + _.chain(list).xorBy(list, list, list, list, list, {a: 1}); // $ExpectType CollectionChain + + fp.xorBy(valueIterator, list, list); // $ExpectType AbcObject[] + fp.xorBy(valueIterator)(list)(list); // $ExpectType AbcObject[] + fp.xorBy("a", list, list); // $ExpectType AbcObject[] + fp.xorBy({ a: 1 }, list, list); // $ExpectType AbcObject[] +} + +// _.zip +{ + _.zip(list); // $ExpectType (AbcObject | undefined)[][] + _.zip(list, list); // $ExpectType (AbcObject | undefined)[][] + _.zip(list, list, list, list, list, list); // $ExpectType (AbcObject | undefined)[][] + _.zip([1, 2], [3, 4]); // $ExpectType [number | undefined, number | undefined][] + _.zip([1, 2], ["a", "b"]); // $ExpectType [number | undefined, string | undefined][] + _.zip([1, 2], ["a", "b"], [true, false]); // $ExpectType [number | undefined, string | undefined, boolean | undefined][] + + _(list).zip(list); // $ExpectType Collection<(AbcObject | undefined)[]> + _(list).zip(list, list, list, list, list); // $ExpectType Collection<(AbcObject | undefined)[]> + + _.chain(list).zip(list); // $ExpectType CollectionChain<(AbcObject | undefined)[]> + _.chain(list).zip(list, list, list, list, list); // $ExpectType CollectionChain<(AbcObject | undefined)[]> + + const list2: _.List = anything; + fp.zip(list2, list2); // $ExpectType [AbcObject | undefined, AbcObject | undefined][] + fp.zip(list2)(list2); // $ExpectType [AbcObject | undefined, AbcObject | undefined][] + fp.zip(["a", "b"], [1, 2]); // $ExpectType [string | undefined, number | undefined][] + fp.zipAll([list2, list2, list2]); // $ExpectType (AbcObject | undefined)[][] + fp.zipAll([[1, 2], ["a", "b"], [true, false]]); // $ExpectType (string | number | boolean | undefined)[][] +} + +// _.zipObject +// _.zipObjectDeep +{ + const listOfKeys: _.List = anything; + const listOfValues: _.List = anything; + + _.zipObject(["a", "b"], [1, 2]); // $ExpectType Dictionary + _.zipObject(listOfKeys, listOfValues); // $ExpectType Dictionary + _(listOfKeys).zipObject(listOfValues); // $ExpectType Object> + _.chain(listOfKeys).zipObject(listOfValues); // $ExpectType ObjectChain> + fp.zipObject(["a", "b"], [1, 2]); // $ExpectType Dictionary + fp.zipObject(listOfKeys)(listOfValues); // $ExpectType Dictionary + + _.zipObjectDeep(["a.b[0].c", "a.b[1].d"], [1, 2]); // $ExpectType object + _.zipObjectDeep(listOfKeys, listOfValues); // $ExpectType object + _(listOfKeys).zipObjectDeep(listOfValues); // $ExpectType Object + _.chain(listOfKeys).zipObjectDeep(listOfValues); // $ExpectType ObjectChain + fp.zipObjectDeep(["a.b[0].c", "a.b[1].d"], [1, 2]); // $ExpectType object + fp.zipObjectDeep(listOfKeys)(listOfValues); // $ExpectType object +} + +// _.zipWith +{ + // $ExpectType string[] + _.zipWith([1, 2], (value1) => { + value1; // $ExpectType number + return ""; + }); + // $ExpectType string[] + _.zipWith([1, 2], [1, 2], (value1, value2) => { + value1; // $ExpectType number + value2; // $ExpectType number + return ""; + }); + // $ExpectType string[] + _.zipWith([1, 2], [1, 2], [1, 2], [1, 2], [1, 2], [1, 2], (value1, value2, value3, value4, value5, value6) => { + value1; // $ExpectType number + value2; // $ExpectType number + value3; // $ExpectType number + value4; // $ExpectType number + value5; // $ExpectType number + value6; // $ExpectType number + return ""; + }); + // $ExpectType string[] + _.zipWith([1, 2], [1, 2], [1, 2], [1, 2], [1, 2], [1, 2], (...group) => { + group; // $ExpectType number[] + return ""; + }); + // $ExpectType string[] + _.zipWith([1, 2], ["a", "b"], [true, false], (value1, value2, value3) => { + value1; // $ExpectType number + value2; // $ExpectType string + value3; // $ExpectType boolean + return ""; + }); + + const values = [[1, 2], [1, 2], [1, 2]]; + _.zipWith(...values, (...group: number[]) => ""); // $ExpectType string[] + + // $ExpectType Collection + _([1, 2]).zipWith((value1) => { + value1; // $ExpectType number + return ""; + }); + // $ExpectType Collection + _([1, 2]).zipWith([1, 2], (value1, value2) => { + value1; // $ExpectType number + value2; // $ExpectType number + return ""; + }); + // $ExpectType Collection + _([1, 2]).zipWith([1, 2], [1, 2], [1, 2], [1, 2], [1, 2], (...group) => { + group; // $ExpectType number[] + return ""; + }); + // $ExpectType Collection + _([1, 2]).zipWith(["a", "b"], [true, false], (value1, value2, value3) => { + value1; // $ExpectType number + value2; // $ExpectType string + value3; // $ExpectType boolean + return ""; + }); + + // $ExpectType CollectionChain + _.chain([1, 2]).zipWith((value1) => { + value1; // $ExpectType number + return ""; + }); + // $ExpectType CollectionChain + _.chain([1, 2]).zipWith([1, 2], [1, 2], [1, 2], [1, 2], [1, 2], (...group) => { + group; // $ExpectType number[] + return ""; + }); + // $ExpectType CollectionChain + _.chain([1, 2]).zipWith(["a", "b"], [true, false], (value1, value2, value3) => { + value1; // $ExpectType number + value2; // $ExpectType string + value3; // $ExpectType boolean + return ""; + }); + + fp.zipWith((value1, value2) => "a", [1, 2], [1, 2]); // $ExpectType string[] + fp.zipWith((value1: number, value2: number) => "a")([1, 2])([1, 2]); // $ExpectType string[] +} + +/************** + * Collection * + **************/ + +// _.at +{ + const abcObject: AbcObject | null | undefined = anything; + + _.at(list, 0, "1", [2], ["3"], [4, "5"]); // $ExpectType AbcObject[] + _.at(numericDictionary, 0, "1", [2], ["3"], [4, "5"]); // $ExpectType AbcObject[] + _.at(dictionary, "a", ["b", "c"]); // $ExpectType AbcObject[] + _.at(abcObject, "a", ["b", "c"]); // $ExpectType (string | number | boolean)[] + + _(list).at(0, "1", [2], ["3"], [4, "5"]); // $ExpectType Collection + _(numericDictionary).at(0, 1, [2], [3], [4, 5]); // $ExpectType Collection + _(dictionary).at("a", ["b", "c"]); // $ExpectType Collection + _(abcObject).at("a", ["b", "c"]); // $ExpectType Collection + + _.chain(list).at(0, "1", [2], ["3"], [4, "5"]); // $ExpectType CollectionChain + _.chain(numericDictionary).at(0, 1, [2], [3], [4, 5]); // $ExpectType CollectionChain + _.chain(dictionary).at("a", ["b", "c"]); // $ExpectType CollectionChain + _.chain(abcObject).at("a", ["b", "c"]); // $ExpectType CollectionChain + + fp.at(0, list); // $ExpectType AbcObject[] + fp.at(0)(list); // $ExpectType AbcObject[] + fp.at([0, "1"], list); // $ExpectType AbcObject[] + fp.at("a", abcObject); // $ExpectType (string | number | boolean)[] +} + +// _.countBy +{ + _.countBy(""); // $ExpectType Dictionary + _.countBy("", stringIterator); // $ExpectType Dictionary + + _.countBy(list); // $ExpectType Dictionary + _.countBy(list, valueIterator); // $ExpectType Dictionary + _.countBy(list, ""); // $ExpectType Dictionary + _.countBy(list, { a: 42 }); // $ExpectType Dictionary + + _.countBy(dictionary); // $ExpectType Dictionary + _.countBy(dictionary, valueIterator); // $ExpectType Dictionary + _.countBy(dictionary, ""); // $ExpectType Dictionary + _.countBy(dictionary, { a: 42 }); // $ExpectType Dictionary + + _.countBy(numericDictionary); // $ExpectType Dictionary + _.countBy(numericDictionary, valueIterator); // $ExpectType Dictionary + _.countBy(numericDictionary, ""); // $ExpectType Dictionary + _.countBy(numericDictionary, { a: 42 }); // $ExpectType Dictionary + + _("").countBy(); // $ExpectType Object> + _("").countBy(stringIterator); // $ExpectType Object> + + _(list).countBy(); // $ExpectType Object> + _(list).countBy(valueIterator); // $ExpectType Object> + _(list).countBy(""); // $ExpectType Object> + _(list).countBy({ a: 42 }); // $ExpectType Object> + + _(dictionary).countBy(); // $ExpectType Object> + _(dictionary).countBy(valueIterator); // $ExpectType Object> + _(dictionary).countBy(""); // $ExpectType Object> + _(dictionary).countBy({ a: 42 }); // $ExpectType Object> + + _(numericDictionary).countBy(); // $ExpectType Object> + _(numericDictionary).countBy(valueIterator); // $ExpectType Object> + _(numericDictionary).countBy(""); // $ExpectType Object> + _(numericDictionary).countBy({ a: 42 }); // $ExpectType Object> + + _.chain("").countBy(); // $ExpectType ObjectChain> + _.chain("").countBy(stringIterator); // $ExpectType ObjectChain> + + _.chain(list).countBy(); // $ExpectType ObjectChain> + _.chain(list).countBy(valueIterator); // $ExpectType ObjectChain> + _.chain(list).countBy(""); // $ExpectType ObjectChain> + _.chain(list).countBy({ a: 42 }); // $ExpectType ObjectChain> + + _.chain(dictionary).countBy(); // $ExpectType ObjectChain> + _.chain(dictionary).countBy(valueIterator); // $ExpectType ObjectChain> + _.chain(dictionary).countBy(""); // $ExpectType ObjectChain> + _.chain(dictionary).countBy({ a: 42 }); // $ExpectType ObjectChain> + + _.chain(numericDictionary).countBy(); // $ExpectType ObjectChain> + _.chain(numericDictionary).countBy(valueIterator); // $ExpectType ObjectChain> + _.chain(numericDictionary).countBy(""); // $ExpectType ObjectChain> + _.chain(numericDictionary).countBy({ a: 42 }); // $ExpectType ObjectChain> + + fp.countBy(stringIterator, ""); // $ExpectType Dictionary + fp.countBy(stringIterator)(""); // $ExpectType Dictionary + fp.countBy(valueIterator, list); // $ExpectType Dictionary + fp.countBy("", list); // $ExpectType Dictionary + fp.countBy({ a: 42 }, list); // $ExpectType Dictionary + fp.countBy(valueIterator, dictionary); // $ExpectType Dictionary + fp.countBy({ a: 42 }, dictionary); // $ExpectType Dictionary + fp.countBy(valueIterator, numericDictionary); // $ExpectType Dictionary + fp.countBy({ a: 42 }, numericDictionary); // $ExpectType Dictionary +} + +// _.every +{ + _.every(list); // $ExpectType boolean + _.every(list, listIterator); // $ExpectType boolean + _.every(list, "a"); // $ExpectType boolean + _.every(list, ["a", 42]); // $ExpectType boolean + _.every(list, { a: 42 }); // $ExpectType boolean + + _.every(dictionary); // $ExpectType boolean + _.every(dictionary, dictionaryIterator); // $ExpectType boolean + _.every(dictionary, "a"); // $ExpectType boolean + _.every(dictionary, ["a", 42]); // $ExpectType boolean + _.every(dictionary, { a: 42 }); // $ExpectType boolean + + _.every(numericDictionary); // $ExpectType boolean + _.every(numericDictionary, numericDictionaryIterator); // $ExpectType boolean + _.every(numericDictionary, "a"); // $ExpectType boolean + _.every(numericDictionary, ["a", 42]); // $ExpectType boolean + _.every(numericDictionary, { a: 42 }); // $ExpectType boolean + + _(list).every(); // $ExpectType boolean + _(list).every(listIterator); // $ExpectType boolean + _(list).every("a"); // $ExpectType boolean + _(list).every(["a", 42]); // $ExpectType boolean + _(list).every({ a: 42 }); // $ExpectType boolean + + _(dictionary).every(); // $ExpectType boolean + _(dictionary).every(dictionaryIterator); // $ExpectType boolean + _(dictionary).every("a"); // $ExpectType boolean + _(dictionary).every(["a", 42]); // $ExpectType boolean + _(dictionary).every({ a: 42 }); // $ExpectType boolean + + _(numericDictionary).every(); // $ExpectType boolean + _(numericDictionary).every(numericDictionaryIterator); // $ExpectType boolean + _(numericDictionary).every("a"); // $ExpectType boolean + _(numericDictionary).every(["a", 42]); // $ExpectType boolean + _(numericDictionary).every({ a: 42 }); // $ExpectType boolean + + _.chain(list).every(); // $ExpectType PrimitiveChain + _.chain(list).every(listIterator); // $ExpectType PrimitiveChain + _.chain(list).every("a"); // $ExpectType PrimitiveChain + _.chain(list).every(["a", 42]); // $ExpectType PrimitiveChain + _.chain(list).every({ a: 42 }); // $ExpectType PrimitiveChain + + _.chain(dictionary).every(); // $ExpectType PrimitiveChain + _.chain(dictionary).every(dictionaryIterator); // $ExpectType PrimitiveChain + _.chain(dictionary).every("a"); // $ExpectType PrimitiveChain + _.chain(dictionary).every(["a", 42]); // $ExpectType PrimitiveChain + _.chain(dictionary).every({ a: 42 }); // $ExpectType PrimitiveChain + + _.chain(numericDictionary).every(); // $ExpectType PrimitiveChain + _.chain(numericDictionary).every(numericDictionaryIterator); // $ExpectType PrimitiveChain + _.chain(numericDictionary).every("a"); // $ExpectType PrimitiveChain + _.chain(numericDictionary).every(["a", 42]); // $ExpectType PrimitiveChain + _.chain(numericDictionary).every({ a: 42 }); // $ExpectType PrimitiveChain + + fp.every(valueIterator, list); // $ExpectType boolean + fp.every("a")(list); // $ExpectType boolean + fp.every({ a: 42 }, list); // $ExpectType boolean + fp.every(["a", 42], list); // $ExpectType boolean + + fp.every(valueIterator, dictionary); // $ExpectType boolean + fp.every("a")(dictionary); // $ExpectType boolean + fp.every({ a: 42 })(dictionary); // $ExpectType boolean + fp.every(["a", 42])(dictionary); // $ExpectType boolean + + fp.every(valueIterator, numericDictionary); // $ExpectType boolean + fp.every("a")(numericDictionary); // $ExpectType boolean + fp.every({ a: 42 })(numericDictionary); // $ExpectType boolean + fp.every(["a", 42])(numericDictionary); // $ExpectType boolean +} + +// _.filter +{ + const stringIterator = (char: string, index: number, string: string) => true; + + _.filter("", stringIterator); // $ExpectType string[] + _.filter(list, listIterator); // $ExpectType AbcObject[] + _.filter(list, ""); // $ExpectType AbcObject[] + _.filter(list, { a: 42 }); // $ExpectType AbcObject[] + _.filter(list, ["a", 42]); // $ExpectType AbcObject[] + _.filter(dictionary, dictionaryIterator); // $ExpectType AbcObject[] + _.filter(dictionary, ""); // $ExpectType AbcObject[] + _.filter(dictionary, { a: 42 }); // $ExpectType AbcObject[] + _.filter(dictionary, ["a", 42]); // $ExpectType AbcObject[] + + _("").filter(stringIterator); // $ExpectType Collection + _(list).filter(listIterator); // $ExpectType Collection + _(list).filter(""); // $ExpectType Collection + _(list).filter({ a: 42 }); // $ExpectType Collection + _(list).filter(["a", 42]); // $ExpectType Collection + _(dictionary).filter(dictionaryIterator); // $ExpectType Collection + _(dictionary).filter(""); // $ExpectType Collection + _(dictionary).filter({ a: 42 }); // $ExpectType Collection + _(dictionary).filter(["a", 42]); // $ExpectType Collection + + _.chain("").filter(stringIterator); // $ExpectType CollectionChain + _.chain(list).filter(listIterator); // $ExpectType CollectionChain + _.chain(list).filter(""); // $ExpectType CollectionChain + _.chain(list).filter({ a: 42 }); // $ExpectType CollectionChain + _.chain(list).filter(["a", 42]); // $ExpectType CollectionChain + _.chain(dictionary).filter(dictionaryIterator); // $ExpectType CollectionChain + _.chain(dictionary).filter(""); // $ExpectType CollectionChain + _.chain(dictionary).filter({ a: 42 }); // $ExpectType CollectionChain + _.chain(dictionary).filter(["a", 42]); // $ExpectType CollectionChain + + fp.filter(valueIterator, list); // $ExpectType AbcObject[] + fp.filter(valueIterator)(list); // $ExpectType AbcObject[] + fp.filter("", list); // $ExpectType AbcObject[] + fp.filter({ a: 42 }, list); // $ExpectType AbcObject[] + fp.filter(["a", 42], list); // $ExpectType AbcObject[] + fp.filter(valueIterator, dictionary); // $ExpectType AbcObject[] + fp.filter("", dictionary); // $ExpectType AbcObject[] + fp.filter({ a: 42 }, dictionary); // $ExpectType AbcObject[] + fp.filter(["a", 42], dictionary); // $ExpectType AbcObject[] + fp.filter((s: string) => s === "a")(["a", "b"]); // $ExpectType string[] + fp.filter((s: string) => s === "a")("ab"); // $ExpectType string[] + + // Test filtering with type guard + const a2: Array | null | undefined = anything; + const d2: _.Dictionary | null | undefined = anything; + + _.filter(a2, (item: string | number): item is number => typeof item === "number"); // $ExpectType number[] + _.filter(d2, (item: string | number): item is number => typeof item === "number"); // $ExpectType number[] + + _(a2).filter((item: string | number): item is number => typeof item === "number"); // $ExpectType Collection + _(d2).filter((item: string | number): item is number => typeof item === "number"); // $ExpectType Collection + + _.chain(a2).filter((item: string | number): item is number => typeof item === "number"); // $ExpectType CollectionChain + _.chain(d2).filter((item: string | number): item is number => typeof item === "number"); // $ExpectType CollectionChain + + fp.filter((item: string | number): item is number => typeof item === "number", a2); // $ExpectType number[] + fp.filter((item: string | number): item is number => typeof item === "number", d2); // $ExpectType number[] +} + +// _.find +// _.findLast +{ + _.find(list); // $ExpectType AbcObject | undefined + _.find(list, listIterator); // $ExpectType AbcObject | undefined + _.find(list, listIterator, 1); // $ExpectType AbcObject | undefined + _.find(list, "a"); // $ExpectType AbcObject | undefined + _.find(list, "a", 1); // $ExpectType AbcObject | undefined + _.find(list, { a: 42 }); // $ExpectType AbcObject | undefined + _.find(list, { a: 42 }, 1); // $ExpectType AbcObject | undefined + _.find(list, ["a", 5]); // $ExpectType AbcObject | undefined + _.find(list, ["a", 5], 1); // $ExpectType AbcObject | undefined + _.find(dictionary); // $ExpectType AbcObject | undefined + _.find(dictionary, dictionaryIterator); // $ExpectType AbcObject | undefined + _.find(dictionary, dictionaryIterator, 1); // $ExpectType AbcObject | undefined + _.find(dictionary, "a"); // $ExpectType AbcObject | undefined + _.find(dictionary, { a: 42 }); // $ExpectType AbcObject | undefined + _.find(dictionary, ["a", 5]); // $ExpectType AbcObject | undefined + _.find([anything as AbcObject, null, undefined], (value: AbcObject | null | undefined): value is AbcObject | undefined => value !== null); // $ExpectType AbcObject | undefined + + _(list).find(); // $ExpectType AbcObject | undefined + _(list).find(listIterator); // $ExpectType AbcObject | undefined + _(list).find(listIterator, 1); // $ExpectType AbcObject | undefined + _(list).find("a"); // $ExpectType AbcObject | undefined + _(list).find({ a: 42 }); // $ExpectType AbcObject | undefined + _(list).find(["a", 5]); // $ExpectType AbcObject | undefined + _(dictionary).find(); // $ExpectType AbcObject | undefined + _(dictionary).find(dictionaryIterator); // $ExpectType AbcObject | undefined + _(dictionary).find(dictionaryIterator, 1); // $ExpectType AbcObject | undefined + _(dictionary).find("a"); // $ExpectType AbcObject | undefined + _(dictionary).find({ a: 42 }); // $ExpectType AbcObject | undefined + _(dictionary).find(["a", 5]); // $ExpectType AbcObject | undefined + _([anything as AbcObject, null, undefined]).find((value: AbcObject | null | undefined): value is AbcObject | undefined => value !== null); // $ExpectType AbcObject | undefined + + _.chain(list).find(); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).find(listIterator); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).find(listIterator, 1); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).find("a"); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).find({ a: 42 }); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).find(["a", 5]); // $ExpectType PrimitiveChain | ObjectChain + _.chain(dictionary).find(); // $ExpectType PrimitiveChain | ObjectChain + _.chain(dictionary).find(dictionaryIterator); // $ExpectType PrimitiveChain | ObjectChain + _.chain(dictionary).find(dictionaryIterator, 1); // $ExpectType PrimitiveChain | ObjectChain + _.chain(dictionary).find(""); // $ExpectType PrimitiveChain | ObjectChain + _.chain(dictionary).find({ a: 42 }); // $ExpectType PrimitiveChain | ObjectChain + _.chain(dictionary).find(["a", 5]); // $ExpectType PrimitiveChain | ObjectChain + // $ExpectType PrimitiveChain | ObjectChain + _.chain([anything as AbcObject, null, undefined]).find((value: AbcObject | null | undefined): value is AbcObject | undefined => value !== null); + + fp.find(valueIterator, list); // $ExpectType AbcObject | undefined + fp.find(valueIterator)(list); // $ExpectType AbcObject | undefined + fp.find("a", list); // $ExpectType AbcObject | undefined + fp.find({ a: 42 }, list); // $ExpectType AbcObject | undefined + fp.find(["a", 42], list); // $ExpectType AbcObject | undefined + fp.find(valueIterator, dictionary); // $ExpectType AbcObject | undefined + fp.find(valueIterator)(dictionary); // $ExpectType AbcObject | undefined + fp.find({ a: 42 }, dictionary); // $ExpectType AbcObject | undefined + fp.find(["a", 42], dictionary); // $ExpectType AbcObject | undefined + fp.find((value: AbcObject | null | undefined): value is AbcObject | undefined => value !== null, [anything as AbcObject, null, undefined]); // $ExpectType AbcObject | undefined + fp.findFrom(valueIterator, 1, list); // $ExpectType AbcObject | undefined + fp.findFrom(valueIterator)(1)(list); // $ExpectType AbcObject | undefined + + _.findLast(list); // $ExpectType AbcObject | undefined + _.findLast(list, listIterator); // $ExpectType AbcObject | undefined + _.findLast(list, listIterator, 1); // $ExpectType AbcObject | undefined + _.findLast(list, "a"); // $ExpectType AbcObject | undefined + _.findLast(list, "a", 1); // $ExpectType AbcObject | undefined + _.findLast(list, { a: 42 }); // $ExpectType AbcObject | undefined + _.findLast(list, { a: 42 }, 1); // $ExpectType AbcObject | undefined + _.findLast(list, ["a", 5]); // $ExpectType AbcObject | undefined + _.findLast(list, ["a", 5], 1); // $ExpectType AbcObject | undefined + _.findLast(dictionary); // $ExpectType AbcObject | undefined + _.findLast(dictionary, dictionaryIterator); // $ExpectType AbcObject | undefined + _.findLast(dictionary, dictionaryIterator, 1); // $ExpectType AbcObject | undefined + _.findLast(dictionary, "a"); // $ExpectType AbcObject | undefined + _.findLast(dictionary, { a: 42 }); // $ExpectType AbcObject | undefined + _.findLast(dictionary, ["a", 5]); // $ExpectType AbcObject | undefined + _.findLast([anything as AbcObject, null, undefined], (value: AbcObject | null | undefined): value is AbcObject | undefined => value !== null); // $ExpectType AbcObject | undefined + + _(list).findLast(); // $ExpectType AbcObject | undefined + _(list).findLast(listIterator); // $ExpectType AbcObject | undefined + _(list).findLast(listIterator, 1); // $ExpectType AbcObject | undefined + _(list).findLast("a"); // $ExpectType AbcObject | undefined + _(list).findLast({ a: 42 }); // $ExpectType AbcObject | undefined + _(list).findLast(["a", 5]); // $ExpectType AbcObject | undefined + _(dictionary).findLast(); // $ExpectType AbcObject | undefined + _(dictionary).findLast(dictionaryIterator); // $ExpectType AbcObject | undefined + _(dictionary).findLast(dictionaryIterator, 1); // $ExpectType AbcObject | undefined + _(dictionary).findLast("a"); // $ExpectType AbcObject | undefined + _(dictionary).findLast({ a: 42 }); // $ExpectType AbcObject | undefined + _(dictionary).findLast(["a", 5]); // $ExpectType AbcObject | undefined + _([anything as AbcObject, null, undefined]).findLast((value: AbcObject | null | undefined): value is AbcObject | undefined => value !== null); // $ExpectType AbcObject | undefined + + _.chain(list).findLast(); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).findLast(listIterator); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).findLast(listIterator, 1); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).findLast("a"); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).findLast({ a: 42 }); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).findLast(["a", 5]); // $ExpectType PrimitiveChain | ObjectChain + _.chain(dictionary).findLast(); // $ExpectType PrimitiveChain | ObjectChain + _.chain(dictionary).findLast(dictionaryIterator); // $ExpectType PrimitiveChain | ObjectChain + _.chain(dictionary).findLast(dictionaryIterator, 1); // $ExpectType PrimitiveChain | ObjectChain + _.chain(dictionary).findLast(""); // $ExpectType PrimitiveChain | ObjectChain + _.chain(dictionary).findLast({ a: 42 }); // $ExpectType PrimitiveChain | ObjectChain + _.chain(dictionary).findLast(["a", 5]); // $ExpectType PrimitiveChain | ObjectChain + // $ExpectType PrimitiveChain | ObjectChain + _.chain([anything as AbcObject, null, undefined]).findLast((value: AbcObject | null | undefined): value is AbcObject | undefined => value !== null); + + fp.findLast(valueIterator, list); // $ExpectType AbcObject | undefined + fp.findLast(valueIterator)(list); // $ExpectType AbcObject | undefined + fp.findLast("a", list); // $ExpectType AbcObject | undefined + fp.findLast({ a: 42 }, list); // $ExpectType AbcObject | undefined + fp.findLast(["a", 42], list); // $ExpectType AbcObject | undefined + fp.findLast(valueIterator, dictionary); // $ExpectType AbcObject | undefined + fp.findLast(valueIterator)(dictionary); // $ExpectType AbcObject | undefined + fp.findLast({ a: 42 }, dictionary); // $ExpectType AbcObject | undefined + fp.findLast(["a", 42], dictionary); // $ExpectType AbcObject | undefined + fp.findLast((value: AbcObject | null | undefined): value is AbcObject | undefined => value !== null, [anything as AbcObject, null, undefined]); // $ExpectType AbcObject | undefined + fp.findLastFrom(valueIterator, 1, list); // $ExpectType AbcObject | undefined + fp.findLastFrom(valueIterator)(1)(list); // $ExpectType AbcObject | undefined +} + +// _.flatMap +{ + const numList: _.List | null | undefined = anything; + const objList: _.List<{a: number}|Array<{a: number}>> | null | undefined = anything; + const numDictionary: _.Dictionary | null | undefined = anything; + const objDictionary: _.Dictionary<{a: number}|Array<{a: number}>> | null | undefined = anything; + const numNumericDictionary: _.NumericDictionary | null | undefined = anything; + const objNumericDictionary: _.NumericDictionary<{a: number}|Array<{a: number}>> | null | undefined = anything; + + const stringIterator = (value: string, index: number, collection: _.List): string | string[] => ""; + const listIterator = (value: number | number[], index: number, collection: _.List): number | number[] => 1; + const dictionaryIterator = (value: number | number[], key: string, collection: _.Dictionary): number | number[] => 1; + const numericDictionaryIterator = (value: number | number[], key: string, collection: _.NumericDictionary): number | number[] => 1; + const valueIterator = (value: number | number[]): number | number[] => 1; + + _.flatMap("abc"); // $ExpectType string[] + _.flatMap("abc", stringIterator); // $ExpectType string[] + _.flatMap(numList); // $ExpectType number[] + _.flatMap(numList, listIterator); // $ExpectType number[] + _.flatMap(objList, "a"); // $ExpectType any[] + _.flatMap(objList, ["a", 42]); // $ExpectType boolean[] + _.flatMap(objList, { a: 42 }); // $ExpectType boolean[] + _.flatMap(numDictionary); // $ExpectType number[] + _.flatMap(numDictionary, dictionaryIterator); // $ExpectType number[] + _.flatMap(objDictionary, "a"); // $ExpectType any[] + _.flatMap(objDictionary, ["a", 42]); // $ExpectType boolean[] + _.flatMap(objDictionary, { a: 42 }); // $ExpectType boolean[] + _.flatMap(numNumericDictionary); // $ExpectType number[] + _.flatMap(numNumericDictionary, numericDictionaryIterator); // $ExpectType number[] + _.flatMap(objNumericDictionary, "a"); // $ExpectType any[] + _.flatMap(objNumericDictionary, ["a", 42]); // $ExpectType boolean[] + _.flatMap(objNumericDictionary, { a: 42 }); // $ExpectType boolean[] + + _("abc").flatMap(stringIterator); // $ExpectType Collection + _(numList).flatMap(); // $ExpectType Collection + _(numList).flatMap(listIterator); // $ExpectType Collection + _(objList).flatMap("a"); // $ExpectType Collection + _(objList).flatMap(["a", 42]); // $ExpectType Collection + _(objList).flatMap({ a: 42 }); // $ExpectType Collection + _(numDictionary).flatMap(dictionaryIterator); // $ExpectType Collection + _(objDictionary).flatMap("a"); // $ExpectType Collection + _(numNumericDictionary).flatMap(numericDictionaryIterator); // $ExpectType Collection + _(objNumericDictionary).flatMap("a"); // $ExpectType Collection + + _.chain("abc").flatMap(stringIterator); // $ExpectType CollectionChain + _.chain(numList).flatMap(); // $ExpectType CollectionChain + _.chain(numList).flatMap(listIterator); // $ExpectType CollectionChain + _.chain(objList).flatMap("a"); // $ExpectType CollectionChain + _.chain(objList).flatMap(["a", 42]); // $ExpectType CollectionChain + _.chain(objList).flatMap({ a: 42 }); // $ExpectType CollectionChain + _.chain(numDictionary).flatMap(dictionaryIterator); // $ExpectType CollectionChain + _.chain(objDictionary).flatMap("a"); // $ExpectType CollectionChain + _.chain(numNumericDictionary).flatMap(numericDictionaryIterator); // $ExpectType CollectionChain + _.chain(objNumericDictionary).flatMap("a"); // $ExpectType CollectionChain + + fp.flatMap(valueIterator, numList); // $ExpectType number[] + fp.flatMap(valueIterator)(numList); // $ExpectType number[] + fp.flatMap("a", objList); // $ExpectType any[] + fp.flatMap({ a: 42 }, objList); // $ExpectType boolean[] + fp.flatMap(["a", 42], objList); // $ExpectType boolean[] + fp.flatMap(valueIterator, numDictionary); // $ExpectType number[] + fp.flatMap("a", objDictionary); // $ExpectType any[] + fp.flatMap({ a: 42 }, objDictionary); // $ExpectType boolean[] + fp.flatMap(["a", 42], objDictionary); // $ExpectType boolean[] + fp.flatMap(valueIterator, numNumericDictionary); // $ExpectType number[] + fp.flatMap("a", objNumericDictionary); // $ExpectType any[] + fp.flatMap({ a: 42 }, objNumericDictionary); // $ExpectType boolean[] + fp.flatMap(["a", 42], objNumericDictionary); // $ExpectType boolean[] +} + +// _.flatMapDeep, _.flatMapDepth +{ + const numList: _.List | null | undefined = anything; + const objList: _.List<{a: number}|Array<{a: number}>> | null | undefined = anything; + const numDictionary: _.Dictionary | null | undefined = anything; + const objDictionary: _.Dictionary<{a: number}|Array<{a: number}>> | null | undefined = anything; + const numNumericDictionary: _.NumericDictionary | null | undefined = anything; + const objNumericDictionary: _.NumericDictionary<{a: number}|Array<{a: number}>> | null | undefined = anything; + + const stringIterator = (value: string, index: number, collection: _.List): _.ListOfRecursiveArraysOrValues | string => ""; + const listIterator = (value: number | number[], index: number, collection: _.List): _.ListOfRecursiveArraysOrValues | number => 1; + const dictionaryIterator = (value: number | number[], key: string, collection: _.Dictionary): _.ListOfRecursiveArraysOrValues | number => 1; + const numericDictionaryIterator = (value: number | number[], key: string, collection: _.NumericDictionary): _.ListOfRecursiveArraysOrValues | number => 1; + const valueIterator = (value: number | number[]): _.ListOfRecursiveArraysOrValues | number => 1; + + _.flatMapDeep("abc"); // $ExpectType string[] + _.flatMapDeep("abc", stringIterator); // $ExpectType string[] + _.flatMapDeep(numList); // $ExpectType number[] + _.flatMapDeep(numList, listIterator); // $ExpectType number[] + _.flatMapDeep(objList, "a"); // $ExpectType any[] + _.flatMapDeep(objList, ["a", 42]); // $ExpectType boolean[] + _.flatMapDeep(objList, { a: 42 }); // $ExpectType boolean[] + _.flatMapDeep(numDictionary); // $ExpectType number[] + _.flatMapDeep(numDictionary, dictionaryIterator); // $ExpectType number[] + _.flatMapDeep(objDictionary, "a"); // $ExpectType any[] + _.flatMapDeep(objDictionary, ["a", 42]); // $ExpectType boolean[] + _.flatMapDeep(objDictionary, { a: 42 }); // $ExpectType boolean[] + _.flatMapDeep(numNumericDictionary); // $ExpectType number[] + _.flatMapDeep(numNumericDictionary, numericDictionaryIterator); // $ExpectType number[] + _.flatMapDeep(objNumericDictionary, "a"); // $ExpectType any[] + _.flatMapDeep(objNumericDictionary, ["a", 42]); // $ExpectType boolean[] + _.flatMapDeep(objNumericDictionary, { a: 42 }); // $ExpectType boolean[] + + _("abc").flatMapDeep(stringIterator); // $ExpectType Collection + _(numList).flatMapDeep(); // $ExpectType Collection + _(numList).flatMapDeep(listIterator); // $ExpectType Collection + _(objList).flatMapDeep("a"); // $ExpectType Collection + _(objList).flatMapDeep(["a", 42]); // $ExpectType Collection + _(objList).flatMapDeep({ a: 42 }); // $ExpectType Collection + _(numDictionary).flatMapDeep(dictionaryIterator); // $ExpectType Collection + _(objDictionary).flatMapDeep("a"); // $ExpectType Collection + _(numNumericDictionary).flatMapDeep(numericDictionaryIterator); // $ExpectType Collection + _(objNumericDictionary).flatMapDeep("a"); // $ExpectType Collection + + _.chain("abc").flatMapDeep(stringIterator); // $ExpectType CollectionChain + _.chain(numList).flatMapDeep(); // $ExpectType CollectionChain + _.chain(numList).flatMapDeep(listIterator); // $ExpectType CollectionChain + _.chain(objList).flatMapDeep("a"); // $ExpectType CollectionChain + _.chain(objList).flatMapDeep(["a", 42]); // $ExpectType CollectionChain + _.chain(objList).flatMapDeep({ a: 42 }); // $ExpectType CollectionChain + _.chain(numDictionary).flatMapDeep(dictionaryIterator); // $ExpectType CollectionChain + _.chain(objDictionary).flatMapDeep("a"); // $ExpectType CollectionChain + _.chain(numNumericDictionary).flatMapDeep(numericDictionaryIterator); // $ExpectType CollectionChain + _.chain(objNumericDictionary).flatMapDeep("a"); // $ExpectType CollectionChain + + fp.flatMapDeep(valueIterator, numList); // $ExpectType number[] + fp.flatMapDeep(valueIterator)(numList); // $ExpectType number[] + fp.flatMapDeep("a", objList); // $ExpectType any[] + fp.flatMapDeep({ a: 42 }, objList); // $ExpectType boolean[] + fp.flatMapDeep(["a", 42], objList); // $ExpectType boolean[] + fp.flatMapDeep(valueIterator, numDictionary); // $ExpectType number[] + fp.flatMapDeep("a", objDictionary); // $ExpectType any[] + fp.flatMapDeep({ a: 42 }, objDictionary); // $ExpectType boolean[] + fp.flatMapDeep(["a", 42], objDictionary); // $ExpectType boolean[] + fp.flatMapDeep(valueIterator, numNumericDictionary); // $ExpectType number[] + fp.flatMapDeep("a", objNumericDictionary); // $ExpectType any[] + fp.flatMapDeep({ a: 42 }, objNumericDictionary); // $ExpectType boolean[] + fp.flatMapDeep(["a", 42], objNumericDictionary); // $ExpectType boolean[] + + _.flatMapDepth("abc"); // $ExpectType string[] + _.flatMapDepth("abc", stringIterator); // $ExpectType string[] + _.flatMapDepth("abc", stringIterator, 3); // $ExpectType string[] + _.flatMapDepth(numList, listIterator, 3); // $ExpectType number[] + _.flatMapDepth(objList, "a", 3); // $ExpectType any[] + _.flatMapDepth(objList, ["a", 42], 3); // $ExpectType boolean[] + _.flatMapDepth(objList, { a: 42 }, 3); // $ExpectType boolean[] + _.flatMapDepth(numDictionary, dictionaryIterator, 3); // $ExpectType number[] + _.flatMapDepth(objDictionary, "a", 3); // $ExpectType any[] + _.flatMapDepth(objDictionary, ["a", 42], 3); // $ExpectType boolean[] + _.flatMapDepth(objDictionary, { a: 42 }, 3); // $ExpectType boolean[] + _.flatMapDepth(numNumericDictionary, numericDictionaryIterator, 3); // $ExpectType number[] + _.flatMapDepth(objNumericDictionary, "a", 3); // $ExpectType any[] + _.flatMapDepth(objNumericDictionary, ["a", 42], 3); // $ExpectType boolean[] + _.flatMapDepth(objNumericDictionary, { a: 42 }, 3); // $ExpectType boolean[] + + _("abc").flatMapDepth(stringIterator, 3); // $ExpectType Collection + _(numList).flatMapDepth(listIterator, 3); // $ExpectType Collection + _(objList).flatMapDepth("a", 3); // $ExpectType Collection + _(objList).flatMapDepth(["a", 42], 3); // $ExpectType Collection + _(objList).flatMapDepth({ a: 42 }, 3); // $ExpectType Collection + _(numDictionary).flatMapDepth(dictionaryIterator, 3); // $ExpectType Collection + _(objDictionary).flatMapDepth("a", 3); // $ExpectType Collection + _(numNumericDictionary).flatMapDepth(numericDictionaryIterator, 3); // $ExpectType Collection + _(objNumericDictionary).flatMapDepth("a", 3); // $ExpectType Collection + + _.chain("abc").flatMapDepth(stringIterator, 3); // $ExpectType CollectionChain + _.chain(numList).flatMapDepth(listIterator, 3); // $ExpectType CollectionChain + _.chain(objList).flatMapDepth("a", 3); // $ExpectType CollectionChain + _.chain(objList).flatMapDepth(["a", 42], 3); // $ExpectType CollectionChain + _.chain(objList).flatMapDepth({ a: 42 }, 3); // $ExpectType CollectionChain + _.chain(numDictionary).flatMapDepth(dictionaryIterator, 3); // $ExpectType CollectionChain + _.chain(objDictionary).flatMapDepth("a", 3); // $ExpectType CollectionChain + _.chain(numNumericDictionary).flatMapDepth(numericDictionaryIterator, 3); // $ExpectType CollectionChain + _.chain(objNumericDictionary).flatMapDepth("a", 3); // $ExpectType CollectionChain + + fp.flatMapDepth(valueIterator, 3, numList); // $ExpectType number[] + fp.flatMapDepth(valueIterator)(3)(numList); // $ExpectType number[] + fp.flatMapDepth("a", 3, objList); // $ExpectType any[] + fp.flatMapDepth({ a: 42 }, 3, objList); // $ExpectType boolean[] + fp.flatMapDepth(["a", 42], 3, objList); // $ExpectType boolean[] + fp.flatMapDepth(valueIterator, 3, numDictionary); // $ExpectType number[] + fp.flatMapDepth("a", 3, objDictionary); // $ExpectType any[] + fp.flatMapDepth({ a: 42 }, 3, objDictionary); // $ExpectType boolean[] + fp.flatMapDepth(["a", 42], 3, objDictionary); // $ExpectType boolean[] + fp.flatMapDepth(valueIterator, 3, numNumericDictionary); // $ExpectType number[] + fp.flatMapDepth("a", 3, objNumericDictionary); // $ExpectType any[] + fp.flatMapDepth({ a: 42 }, 3, objNumericDictionary); // $ExpectType boolean[] + fp.flatMapDepth(["a", 42], 3, objNumericDictionary); // $ExpectType boolean[] +} + +// _.forEach +// _.forEachRight +// _.each +// _.eachRight +{ + const str: string = anything; + const nilStr: string | null | undefined = anything; + const array: AbcObject[] = anything; + const list: _.List = anything; + const dictionary: _.Dictionary = anything; + const numericDictionary: _.NumericDictionary = anything; + const nilArray: AbcObject[] | null | undefined = anything; + const nilList: _.List | null | undefined = anything; + const nilDictionary: _.Dictionary | null | undefined = anything; + const nilNumericDictionary: _.NumericDictionary | null | undefined = anything; + const nilAbcObject: AbcObject | null | undefined = anything; + + // $ExpectType string + _.forEach(str, (value, index, collection) => { + value; // $ExpectType string + index; // $ExpectType number + collection; // $ExpectType string + }); + + // $ExpectType string | null | undefined + _.forEach(nilStr, (value, index, collection) => { + value; // $ExpectType string + index; // $ExpectType number + collection; // $ExpectType string + }); + + // $ExpectType AbcObject[] + _.forEach(array, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType AbcObject[] + }); + + // $ExpectType AbcObject[] | null | undefined + _.forEach(nilArray, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType AbcObject[] + }); + + // $ExpectType ArrayLike + _.forEach(list, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + + // $ExpectType ArrayLike | null | undefined + _.forEach(nilList, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + + // $ExpectType Dictionary + _.forEach(dictionary, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType string + collection; // $ExpectType Dictionary + }); + + // $ExpectType Dictionary | null | undefined + _.forEach(nilDictionary, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType string + collection; // $ExpectType Dictionary + }); + + // $ExpectType NumericDictionary + _.forEach(numericDictionary, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType string + collection; // $ExpectType NumericDictionary + }); + + // $ExpectType NumericDictionary | null | undefined + _.forEach(nilNumericDictionary, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType string + collection; // $ExpectType NumericDictionary + }); + + // $ExpectType AbcObject + _.forEach(abcObject, (value, index, collection) => { + value; // $ExpectType string | number | boolean + index; // $ExpectType string + collection; // $ExpectType AbcObject + }); + + // $ExpectType AbcObject | null | undefined + _.forEach(nilAbcObject, (value, index, collection) => { + value; // $ExpectType string | number | boolean + index; // $ExpectType string + collection; // $ExpectType AbcObject + }); + + // $ExpectType String + _(str).forEach((value, index, collection) => { + value; // $ExpectType string + index; // $ExpectType number + collection; // $ExpectType string + }); + + // $ExpectType String + _(nilStr).forEach((value, index, collection) => { + value; // $ExpectType string + index; // $ExpectType number + collection; // $ExpectType string + }); + + // $ExpectType Collection + _(array).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + + // $ExpectType Collection + _(nilArray).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + + // $ExpectType Collection + _(list).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + + // $ExpectType Collection + _(nilList).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + + // $ExpectType Object> + _(dictionary).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType string + collection; // $ExpectType Dictionary + }); + + // $ExpectType Object> + _(nilDictionary).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType string + collection; // $ExpectType Dictionary + }); + + // $ExpectType Object> + _(numericDictionary).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType string + collection; // $ExpectType NumericDictionary + }); + + // $ExpectType Object> + _(nilNumericDictionary).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType string + collection; // $ExpectType NumericDictionary + }); + + // $ExpectType StringChain + _.chain(str).forEach((value, index, collection) => { + value; // $ExpectType string + index; // $ExpectType number + collection; // $ExpectType string + }); + + // $ExpectType StringNullableChain + _.chain(nilStr).forEach((value, index, collection) => { + value; // $ExpectType string + index; // $ExpectType number + collection; // $ExpectType string + }); + + // $ExpectType CollectionChain + _.chain(array).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + + // $ExpectType CollectionChain + _.chain(nilArray).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + + // $ExpectType CollectionChain + _.chain(list).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + + // $ExpectType CollectionChain + _.chain(nilList).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + + // $ExpectType ObjectChain> + _.chain(dictionary).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType string + collection; // $ExpectType Dictionary + }); + + // $ExpectType ObjectChain> + _.chain(nilDictionary).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType string + collection; // $ExpectType Dictionary + }); + + // $ExpectType ObjectChain> + _.chain(numericDictionary).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType string + collection; // $ExpectType NumericDictionary + }); + + // $ExpectType ObjectChain> + _.chain(nilNumericDictionary).forEach((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType string + collection; // $ExpectType NumericDictionary + }); + + fp.forEach(stringIterator, ""); // $ExpectType ArrayLike + fp.forEach(valueIterator, array); // $ExpectType AbcObject[] + fp.forEach(valueIterator)(array); // $ExpectType AbcObject[] + fp.forEach(valueIterator, list); // $ExpectType ArrayLike + fp.forEach(valueIterator, dictionary); // $ExpectType Dictionary + fp.forEach(valueIterator, nilArray); // $ExpectType AbcObject[] | null | undefined + fp.forEach(valueIterator, nilList); // $ExpectType ArrayLike | null | undefined + fp.forEach(valueIterator, nilDictionary); // $ExpectType Dictionary | null | undefined + + // $ExpectType AbcObject[] + _.forEachRight(array, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType AbcObject[] + }); + // $ExpectType ArrayLike | null | undefined + _.forEachRight(nilList, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + // $ExpectType Collection + _(array).forEachRight((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + // $ExpectType Collection + _(nilList).forEachRight((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + // $ExpectType CollectionChain + _.chain(array).forEachRight((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + // $ExpectType CollectionChain + _.chain(nilList).forEachRight((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + fp.forEachRight(valueIterator, array); // $ExpectType AbcObject[] + fp.forEachRight(valueIterator)(array); // $ExpectType AbcObject[] + + // $ExpectType AbcObject[] + _.each(array, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType AbcObject[] + }); + // $ExpectType ArrayLike | null | undefined + _.each(nilList, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + // $ExpectType Collection + _(array).each((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + // $ExpectType Collection + _(nilList).each((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + // $ExpectType CollectionChain + _.chain(array).each((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + // $ExpectType CollectionChain + _.chain(nilList).each((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + fp.each(valueIterator, array); // $ExpectType AbcObject[] + fp.each(valueIterator)(array); // $ExpectType AbcObject[] + + // $ExpectType AbcObject[] + _.eachRight(array, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType AbcObject[] + }); + // $ExpectType ArrayLike | null | undefined + _.eachRight(nilList, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + // $ExpectType Collection + _(array).eachRight((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + // $ExpectType Collection + _(nilList).eachRight((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + // $ExpectType CollectionChain + _.chain(array).eachRight((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + // $ExpectType CollectionChain + _.chain(nilList).eachRight((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + }); + fp.eachRight(valueIterator, array); // $ExpectType AbcObject[] + fp.eachRight(valueIterator)(array); // $ExpectType AbcObject[] +} + +// _.groupBy +{ + _.groupBy(""); // $ExpectType Dictionary + _.groupBy("", stringIterator); // $ExpectType Dictionary + _.groupBy(list); // $ExpectType Dictionary + _.groupBy(list, valueIterator); // $ExpectType Dictionary + _.groupBy(list, "a"); // $ExpectType Dictionary + _.groupBy(list, { a: 42 }); // $ExpectType Dictionary + _.groupBy(dictionary); // $ExpectType Dictionary + _.groupBy(dictionary, valueIterator); // $ExpectType Dictionary + _.groupBy(dictionary, ""); // $ExpectType Dictionary + _.groupBy(dictionary, { a: 42 }); // $ExpectType Dictionary + + _("").groupBy(); // $ExpectType Object> + _("").groupBy(stringIterator); // $ExpectType Object> + _(list).groupBy(); // $ExpectType Object> + _(list).groupBy(valueIterator); // $ExpectType Object> + _(list).groupBy(""); // $ExpectType Object> + _(list).groupBy({ a: 42 }); // $ExpectType Object> + _(dictionary).groupBy(); // $ExpectType Object> + _(dictionary).groupBy(valueIterator); // $ExpectType Object> + _(dictionary).groupBy(""); // $ExpectType Object> + _(dictionary).groupBy({ a: 42 }); // $ExpectType Object> + + _.chain("").groupBy(); // $ExpectType ObjectChain> + _.chain("").groupBy(stringIterator); // $ExpectType ObjectChain> + _.chain(list).groupBy(); // $ExpectType ObjectChain> + _.chain(list).groupBy(valueIterator); // $ExpectType ObjectChain> + _.chain(list).groupBy(""); // $ExpectType ObjectChain> + _.chain(list).groupBy({ a: 42 }); // $ExpectType ObjectChain> + _.chain(dictionary).groupBy(); // $ExpectType ObjectChain> + _.chain(dictionary).groupBy(valueIterator); // $ExpectType ObjectChain> + _.chain(dictionary).groupBy(""); // $ExpectType ObjectChain> + _.chain(dictionary).groupBy({ a: 42 }); // $ExpectType ObjectChain> + + fp.groupBy(valueIterator, list); // $ExpectType Dictionary + fp.groupBy(valueIterator)(list); // $ExpectType Dictionary + fp.groupBy("a", list); // $ExpectType Dictionary + fp.groupBy({ a: 42 }, list); // $ExpectType Dictionary + fp.groupBy(["a", 42], list); // $ExpectType Dictionary + fp.groupBy(valueIterator, dictionary); // $ExpectType Dictionary + fp.groupBy("a", dictionary); // $ExpectType Dictionary + fp.groupBy({ a: 42 }, dictionary); // $ExpectType Dictionary + fp.groupBy(["a", 42], dictionary); // $ExpectType Dictionary +} + +// _.includes +{ + _.includes(list, abcObject); // $ExpectType boolean + _.includes(list, abcObject, 42); // $ExpectType boolean + _.includes(dictionary, abcObject); // $ExpectType boolean + _.includes(dictionary, abcObject, 42); // $ExpectType boolean + + _(list).includes(abcObject); // $ExpectType boolean + _(list).includes(abcObject, 42); // $ExpectType boolean + _(dictionary).includes(abcObject); // $ExpectType boolean + _(dictionary).includes(abcObject, 42); // $ExpectType boolean + + _.chain(list).includes(abcObject); // $ExpectType PrimitiveChain + _.chain(list).includes(abcObject, 42); // $ExpectType PrimitiveChain + _.chain(dictionary).includes(abcObject); // $ExpectType PrimitiveChain + _.chain(dictionary).includes(abcObject, 42); // $ExpectType PrimitiveChain + + fp.includes(abcObject, list); // $ExpectType boolean + fp.includes(abcObject)(list); // $ExpectType boolean + fp.includes(abcObject, dictionary); // $ExpectType boolean + + fp.includesFrom(abcObject, 42, list); // $ExpectType boolean + fp.includesFrom(abcObject)(42)(list); // $ExpectType boolean + fp.includesFrom(abcObject, 42, dictionary); // $ExpectType boolean +} + +// _.keyBy +{ + const valueIterator = (value: AbcObject) => ""; + const subKey: string | number | symbol = anything; + + _.keyBy("abcd"); // $ExpectType Dictionary + _.keyBy("abcd", stringIterator); // $ExpectType Dictionary + _.keyBy(list); // $ExpectType Dictionary + _.keyBy(list, valueIterator); // $ExpectType Dictionary + _.keyBy(list, subKey); // $ExpectType Dictionary + _.keyBy(list, { a: 42 }); // $ExpectType Dictionary + _.keyBy(dictionary); // $ExpectType Dictionary + _.keyBy(dictionary, valueIterator); // $ExpectType Dictionary + _.keyBy(dictionary, subKey); // $ExpectType Dictionary + _.keyBy(dictionary, { a: 42 }); // $ExpectType Dictionary + _.keyBy(numericDictionary); // $ExpectType Dictionary + _.keyBy(numericDictionary, valueIterator); // $ExpectType Dictionary + _.keyBy(numericDictionary, "a"); // $ExpectType Dictionary + _.keyBy(numericDictionary, subKey); // $ExpectType Dictionary + _.keyBy(numericDictionary, { a: 42 }); // $ExpectType Dictionary + + _("abcd").keyBy(); // $ExpectType Object> + _("abcd").keyBy(stringIterator); // $ExpectType Object> + _(list).keyBy(); // $ExpectType Object> + _(list).keyBy(valueIterator); // $ExpectType Object> + _(list).keyBy(subKey); // $ExpectType Object> + _(list).keyBy({ a: 42 }); // $ExpectType Object> + _(dictionary).keyBy(); // $ExpectType Object> + _(dictionary).keyBy(valueIterator); // $ExpectType Object> + _(dictionary).keyBy(subKey); // $ExpectType Object> + _(dictionary).keyBy({ a: 42 }); // $ExpectType Object> + _(numericDictionary).keyBy(); // $ExpectType Object> + _(numericDictionary).keyBy(valueIterator); // $ExpectType Object> + _(numericDictionary).keyBy(subKey); // $ExpectType Object> + _(numericDictionary).keyBy({ a: 42 }); // $ExpectType Object> + + _.chain("abcd").keyBy(); // $ExpectType ObjectChain> + _.chain("abcd").keyBy(stringIterator); // $ExpectType ObjectChain> + _.chain(list).keyBy(); // $ExpectType ObjectChain> + _.chain(list).keyBy(valueIterator); // $ExpectType ObjectChain> + _.chain(list).keyBy(subKey); // $ExpectType ObjectChain> + _.chain(list).keyBy({ a: 42 }); // $ExpectType ObjectChain> + _.chain(dictionary).keyBy(); // $ExpectType ObjectChain> + _.chain(dictionary).keyBy(valueIterator); // $ExpectType ObjectChain> + _.chain(dictionary).keyBy(subKey); // $ExpectType ObjectChain> + _.chain(dictionary).keyBy({ a: 42 }); // $ExpectType ObjectChain> + _.chain(numericDictionary).keyBy(); // $ExpectType ObjectChain> + _.chain(numericDictionary).keyBy(valueIterator); // $ExpectType ObjectChain> + _.chain(numericDictionary).keyBy(subKey); // $ExpectType ObjectChain> + _.chain(numericDictionary).keyBy({ a: 42 }); // $ExpectType ObjectChain> + + fp.keyBy(valueIterator, list); // $ExpectType Dictionary + fp.keyBy(valueIterator)(list); // $ExpectType Dictionary + fp.keyBy(subKey, list); // $ExpectType Dictionary + fp.keyBy({ a: 42 }, list); // $ExpectType Dictionary + fp.keyBy([subKey, 42], list); // $ExpectType Dictionary + fp.keyBy(valueIterator, dictionary); // $ExpectType Dictionary + fp.keyBy(subKey, dictionary); // $ExpectType Dictionary + fp.keyBy({ a: 42 }, dictionary); // $ExpectType Dictionary + fp.keyBy([subKey, 42], dictionary); // $ExpectType Dictionary + fp.keyBy(valueIterator, numericDictionary); // $ExpectType Dictionary + fp.keyBy(subKey, numericDictionary); // $ExpectType Dictionary + fp.keyBy({ a: 42 }, numericDictionary); // $ExpectType Dictionary + fp.keyBy([subKey, 42], numericDictionary); // $ExpectType Dictionary +} + +// _.invoke +{ + const array = [(n?: number) => {}]; + const nestedDict = { a: [(n?: number) => {}] }; + + _.invoke(array, "[0]"); // $ExpectType any + _.invoke(array, "[0]", 2); // $ExpectType any + _.invoke(array, [0, "call"]); // $ExpectType any + _.invoke(array, [0, "call"], 2); // $ExpectType any + + _.invoke(nestedDict, ["a[0].toString"]); // $ExpectType any + _.invoke(nestedDict, ["a[0].toString"], 2); // $ExpectType any + _.invoke(nestedDict, ["a", 0, "toString"]); // $ExpectType any + _.invoke(nestedDict, ["a", 0, "toString"], 2); // $ExpectType any + + _(array).invoke("[0]"); // $ExpectType any + _(array).invoke("[0]", 2); // $ExpectType any + _(array).invoke([0, "call"]); // $ExpectType any + _(array).invoke([0, "call"], 2); // $ExpectType any + + _(nestedDict).invoke(["a[0].toString"]); // $ExpectType any + _(nestedDict).invoke(["a[0].toString"], 2); // $ExpectType any + _(nestedDict).invoke(["a", 0, "toString"]); // $ExpectType any + _(nestedDict).invoke(["a", 0, "toString"], 2); // $ExpectType any + + _.chain(array).invoke("[0]"); // $ExpectType LoDashExplicitWrapper + _.chain(array).invoke("[0]", 2); // $ExpectType LoDashExplicitWrapper + _.chain(array).invoke([0, "call"]); // $ExpectType LoDashExplicitWrapper + _.chain(array).invoke([0, "call"], 2); // $ExpectType LoDashExplicitWrapper + + _.chain(nestedDict).invoke(["a[0].toString"]); // $ExpectType LoDashExplicitWrapper + _.chain(nestedDict).invoke(["a[0].toString"], 2); // $ExpectType LoDashExplicitWrapper + _.chain(nestedDict).invoke(["a", 0, "toString"]); // $ExpectType LoDashExplicitWrapper + _.chain(nestedDict).invoke(["a", 0, "toString"], 2); // $ExpectType LoDashExplicitWrapper + + fp.invoke("[0]", array); // $ExpectType any + fp.invoke("[0]")(array); // $ExpectType any + fp.invoke(["[0]", 2], array); // $ExpectType any + + fp.invoke("a[0].toString", nestedDict); // $ExpectType any + fp.invoke(["a", 0, "toString"], nestedDict); // $ExpectType any +} + +// _.invokeMap +{ + const numArray: number[] | null | undefined = anything; + const numDict: _.Dictionary | null | undefined = anything; + + _.invokeMap(numArray, "toString"); // $ExpectType any[] + _.invokeMap(numArray, "toString", 2); // $ExpectType any[] + _.invokeMap(numArray, Number.prototype.toString); // $ExpectType string[] + _.invokeMap(numDict, "toString"); // $ExpectType any[] + + _(numArray).invokeMap("toString"); // $ExpectType Collection + _(numArray).invokeMap("toString", 2); // $ExpectType Collection + _(numArray).invokeMap(Number.prototype.toString); // $ExpectType Collection + _(numDict).invokeMap("toString"); // $ExpectType Collection + + _.chain(numArray).invokeMap("toString"); // $ExpectType CollectionChain + _.chain(numArray).invokeMap("toString", 2); // $ExpectType CollectionChain + _.chain(numArray).invokeMap(Number.prototype.toString); // $ExpectType CollectionChain + _.chain(numDict).invokeMap("toString"); // $ExpectType CollectionChain + + fp.invokeMap("toString", numArray); // $ExpectType any[] + fp.invokeMap("toString")(numArray); // $ExpectType any[] + fp.invokeMap(Number.prototype.toString, numArray); // $ExpectType string[] + fp.invokeMap("toString", numDict); // $ExpectType any[] + fp.invokeMap(Number.prototype.toString, numDict); // $ExpectType string[] + + fp.invokeArgsMap("toString", [16], numArray); // $ExpectType any[] + fp.invokeArgsMap("toString")([16])(numArray); // $ExpectType any[] + fp.invokeArgsMap(Number.prototype.toString, [16], numArray); // $ExpectType string[] + fp.invokeArgsMap("toString", [16], numDict); // $ExpectType any[] + fp.invokeArgsMap(Number.prototype.toString, [16], numDict); // $ExpectType string[] +} + +// _.map +{ + _.map(list); // $ExpectType AbcObject[] + // $ExpectType number[] + _.map(list, (value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + return 0; + }); + _.map(dictionary); // $ExpectType AbcObject[] + // $ExpectType number[] + _.map(dictionary, (value, key, collection) => { + value; // $ExpectType AbcObject + key; // $ExpectType string + collection; // $ExpectType Dictionary + return 0; + }); + _.map(numericDictionary); // $ExpectType AbcObject[] + // $ExpectType number[] + _.map(numericDictionary, (value, key, collection) => { + value; // $ExpectType AbcObject + key; // $ExpectType string + collection; // $ExpectType NumericDictionary + return 0; + }); + _.map(list, "a"); // $ExpectType number[] + _.map(dictionary, "a"); // $ExpectType number[] + _.map(numericDictionary, "a"); // $ExpectType number[] + _.map(list, "d.0.b"); // $ExpectType any[] + _.map(dictionary, "d.0.b"); // $ExpectType any[] + _.map(numericDictionary, "d.0.b"); // $ExpectType any[] + _.map(list, { a: 42 }); // $ExpectType boolean[] + _.map(dictionary, { a: 42 }); // $ExpectType boolean[] + _.map(numericDictionary, { a: 42 }); // $ExpectType boolean[] + + _(list).map(); // $ExpectType Collection + // $ExpectType Collection + _(list).map((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + return 0; + }); + _(dictionary).map(); // $ExpectType Collection + // $ExpectType Collection + _(dictionary).map((value, key, collection) => { + value; // $ExpectType AbcObject + key; // $ExpectType string + collection; // $ExpectType Dictionary + return 0; + }); + _(numericDictionary).map(); // $ExpectType Collection + // $ExpectType Collection + _(numericDictionary).map((value, key, collection) => { + value; // $ExpectType AbcObject + key; // $ExpectType string + collection; // $ExpectType NumericDictionary + return 0; + }); + _(list).map("a"); // $ExpectType Collection + _(dictionary).map("a"); // $ExpectType Collection + _(numericDictionary).map("a"); // $ExpectType Collection + _(list).map("d.0.b"); // $ExpectType Collection + _(dictionary).map("d.0.b"); // $ExpectType Collection + _(numericDictionary).map("d.0.b"); // $ExpectType Collection + _(list).map({ a: 42 }); // $ExpectType Collection + _(dictionary).map({ a: 42 }); // $ExpectType Collection + _(numericDictionary).map({ a: 42 }); // $ExpectType Collection + + _.chain(list).map(); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(list).map((value, index, collection) => { + value; // $ExpectType AbcObject + index; // $ExpectType number + collection; // $ExpectType ArrayLike + return 0; + }); + _.chain(dictionary).map(); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(dictionary).map((value, key, collection) => { + value; // $ExpectType AbcObject + key; // $ExpectType string + collection; // $ExpectType Dictionary + return 0; + }); + _.chain(numericDictionary).map(); // $ExpectType CollectionChain + // $ExpectType CollectionChain + _.chain(numericDictionary).map((value, key, collection) => { + value; // $ExpectType AbcObject + key; // $ExpectType string + collection; // $ExpectType NumericDictionary + return 0; + }); + _.chain(list).map("a"); // $ExpectType CollectionChain + _.chain(dictionary).map("a"); // $ExpectType CollectionChain + _.chain(numericDictionary).map("a"); // $ExpectType CollectionChain + _.chain(list).map("d.0.b"); // $ExpectType CollectionChain + _.chain(dictionary).map("d.0.b"); // $ExpectType CollectionChain + _.chain(numericDictionary).map("d.0.b"); // $ExpectType CollectionChain + _.chain(list).map({ a: 42 }); // $ExpectType CollectionChain + _.chain(dictionary).map({ a: 42 }); // $ExpectType CollectionChain + _.chain(numericDictionary).map({ a: 42 }); // $ExpectType CollectionChain + + const valueIterator = (value: AbcObject): number => value.a; + fp.map(valueIterator)(list); // $ExpectType number[] + fp.map(valueIterator, dictionary); // $ExpectType number[] + fp.map("a", list); // $ExpectType number[] + fp.map({ a: 42 }, list); // $ExpectType boolean[] + fp.map(["a", 42], dictionary); // $ExpectType boolean[] +} + +// _.partition +{ + // $ExpectType [any[], any[]] + _.partition(anything, (value) => { + value; // $ExpectType any + return value < "c"; + }); + // $ExpectType [string[], string[]] + _.partition("abcd", (value) => { + value; // $ExpectType string + return value < "c"; + }); + // $ExpectType [AbcObject[], AbcObject[]] + _.partition(list, (value) => { + value; // $ExpectType AbcObject + return true; + }); + + // $ExpectType LoDashImplicitWrapper<[any[], any[]]> + _(anything).partition((value) => { + value; // $ExpectType any + return value < "c"; + }); + // $ExpectType LoDashImplicitWrapper<[string[], string[]]> + _("abcd").partition((value) => { + value; // $ExpectType string + return value < "c"; + }); + // $ExpectType LoDashImplicitWrapper<[AbcObject[], AbcObject[]]> + _(list).partition((value) => { + value; // $ExpectType AbcObject + return true; + }); + + // $ExpectType LoDashExplicitWrapper<[any[], any[]]> + _.chain(anything).partition((value) => { + value; // $ExpectType any + return value < "c"; + }); + // $ExpectType LoDashExplicitWrapper<[string[], string[]]> + _.chain("abcd").partition((value) => { + value; // $ExpectType string + return value < "c"; + }); + // $ExpectType LoDashExplicitWrapper<[AbcObject[], AbcObject[]]> + _.chain(list).partition((value) => { + value; // $ExpectType AbcObject + return true; + }); + + // $ExpectType [any[], any[]] + fp.partition((value) => { + value; // $ExpectType any + return value < "c"; + }, anything); + // $ExpectType [any[], any[]] + fp.partition((value: any) => value < "c")(anything); + // $ExpectType [string[], string[]] + fp.partition((value) => { + value; // $ExpectType string + return value < "c"; + }, "abcd"); + // $ExpectType [AbcObject[], AbcObject[]] + fp.partition((value) => { + value; // $ExpectType AbcObject + return true; + }, list); +} + +// _.reduce +{ + interface ABC { + [key: string]: number; + a: number; + b: number; + c: number; + } + const initial: ABC = { a: 1, b: 2, c: 3 }; + + // $ExpectType number | undefined + _.reduce([1, 2, 3], (sum, curr, key, coll) => { + sum; // $ExpectType number + curr; // $ExpectType number + key; // $ExpectType number + coll; // $ExpectType number[] + return sum + curr; + }); + _.reduce(null, (sum: number, num: number) => sum + num); // $ExpectType number | undefined + _.reduce({ a: 1, b: 2, c: 3 }, (r: ABC, num: number, key: string) => r, initial); // $ExpectType ABC + + _([1, 2, 3]).reduce((sum, num) => sum + num); // $ExpectType number | undefined + _({ a: 1, b: 2, c: 3 }).reduce((r: ABC, num: number, key: string) => r, initial); // $ExpectType ABC + + _.chain([1, 2, 3]).reduce((sum, num) => sum + num); // $ExpectType PrimitiveChain | PrimitiveChain + _.chain({ a: 1, b: 2, c: 3 }).reduce((r: ABC, num: number, key: string) => r, initial); // $ExpectType ObjectChain + + fp.reduce((s: string, num: number) => s + num, "", [1, 2, 3]); // $ExpectType string + fp.reduce((s: string, num: number) => s + num)("")([1, 2, 3]); // $ExpectType string + + _.reduceRight([1, 2, 3], (sum, num) => sum + num); // $ExpectType number | undefined + _.reduceRight(null, (sum: number, num: number) => sum + num); // $ExpectType number | undefined + _.reduceRight({ a: 1, b: 2, c: 3 }, (r: ABC, num: number, key: string) => r, initial); // $ExpectType ABC + + _([1, 2, 3]).reduceRight((sum, num) => sum + num); // $ExpectType number | undefined + _({ a: 1, b: 2, c: 3 }).reduceRight((r: ABC, num: number, key: string) => r, initial); // $ExpectType ABC + + _.chain([1, 2, 3]).reduceRight((sum, num) => sum + num); // $ExpectType PrimitiveChain | PrimitiveChain + _.chain({ a: 1, b: 2, c: 3 }).reduceRight((r: ABC, num: number, key: string) => r, initial); // $ExpectType ObjectChain + + fp.reduceRight((num: number, s: string) => s + num, "", [1, 2, 3]); // $ExpectType string + fp.reduceRight((num: number, s: string) => s + num)("")([1, 2, 3]); // $ExpectType string +} + +// _.reject +{ + const stringIterator = (char: string, index: number, string: string) => true; + + _.reject("", stringIterator); // $ExpectType string[] + _.reject(list, listIterator); // $ExpectType AbcObject[] + _.reject(list, ""); // $ExpectType AbcObject[] + _.reject(list, { a: 42 }); // $ExpectType AbcObject[] + _.reject(dictionary, dictionaryIterator); // $ExpectType AbcObject[] + _.reject(dictionary, ""); // $ExpectType AbcObject[] + _.reject(dictionary, { a: 42 }); // $ExpectType AbcObject[] + + _("").reject(stringIterator); // $ExpectType Collection + _(list).reject(listIterator); // $ExpectType Collection + _(list).reject(""); // $ExpectType Collection + _(list).reject({ a: 42 }); // $ExpectType Collection + _(dictionary).reject(dictionaryIterator); // $ExpectType Collection + _(dictionary).reject(""); // $ExpectType Collection + _(dictionary).reject({ a: 42 }); // $ExpectType Collection + + _.chain("").reject(stringIterator); // $ExpectType CollectionChain + _.chain(list).reject(listIterator); // $ExpectType CollectionChain + _.chain(list).reject(""); // $ExpectType CollectionChain + _.chain(list).reject({ a: 42 }); // $ExpectType CollectionChain + _.chain(dictionary).reject(dictionaryIterator); // $ExpectType CollectionChain + _.chain(dictionary).reject(""); // $ExpectType CollectionChain + _.chain(dictionary).reject({ a: 42 }); // $ExpectType CollectionChain + + fp.reject(valueIterator, list); // $ExpectType AbcObject[] + fp.reject(valueIterator)(list); // $ExpectType AbcObject[] + fp.reject(valueIterator, dictionary); // $ExpectType AbcObject[] + fp.reject("a", list); // $ExpectType AbcObject[] + fp.reject({ a: 42 }, list); // $ExpectType AbcObject[] + fp.reject(["a", 42], list); // $ExpectType AbcObject[] +} + +// _.sample +// _.sampleSize +{ + const list: _.List | null | undefined = anything; + const dictionary: _.Dictionary | null | undefined = anything; + const numericDictionary: _.NumericDictionary | null | undefined = anything; + + _.sample("abc"); // $ExpectType string | undefined + _.sample(list); // $ExpectType string | undefined + _.sample(dictionary); // $ExpectType string | undefined + _.sample(numericDictionary); // $ExpectType string | undefined + _.sample({ a: "foo" }); // $ExpectType string | undefined + + _("abc").sample(); // $ExpectType string | undefined + _(list).sample(); // $ExpectType string | undefined + _(dictionary).sample(); // $ExpectType string | undefined + _(numericDictionary).sample(); // $ExpectType string | undefined + _({ a: "foo" }).sample(); // $ExpectType string | undefined + + _.chain("abc").sample(); // $ExpectType StringNullableChain + _.chain(list).sample(); // $ExpectType StringChain | PrimitiveChain + _.chain(dictionary).sample(); // $ExpectType StringChain | PrimitiveChain + _.chain(numericDictionary).sample(); // $ExpectType StringChain | PrimitiveChain + _.chain({ a: "foo" }).sample(); // $ExpectType StringChain | PrimitiveChain + + fp.sample("abc"); // $ExpectType string | undefined + fp.sample(list); // $ExpectType string | undefined + fp.sample({ a: "foo" }); // $ExpectType string | undefined + + _.sampleSize("abc"); // $ExpectType string[] + _.sampleSize("abc", 3); // $ExpectType string[] + _.sampleSize(list, 3); // $ExpectType string[] + _.sampleSize(dictionary, 3); // $ExpectType string[] + _.sampleSize(numericDictionary, 3); // $ExpectType string[] + _.sampleSize({ a: "foo" }, 3); // $ExpectType string[] + + _("abc").sampleSize(); // $ExpectType Collection + _("abc").sampleSize(3); // $ExpectType Collection + _(list).sampleSize(3); // $ExpectType Collection + _(dictionary).sampleSize(3); // $ExpectType Collection + _(numericDictionary).sampleSize(3); // $ExpectType Collection + _({ a: "foo" }).sampleSize(3); // $ExpectType Collection + + _.chain("abc").sampleSize(); // $ExpectType CollectionChain + _.chain("abc").sampleSize(3); // $ExpectType CollectionChain + _.chain(list).sampleSize(3); // $ExpectType CollectionChain + _.chain(dictionary).sampleSize(3); // $ExpectType CollectionChain + _.chain(numericDictionary).sampleSize(3); // $ExpectType CollectionChain + _.chain({ a: "foo" }).sampleSize(3); // $ExpectType CollectionChain + + fp.sampleSize(3, "abc"); // $ExpectType string[] + fp.sampleSize(3)(list); // $ExpectType string[] + fp.sampleSize(3)({ a: "foo" }); // $ExpectType string[] +} + +// _.shuffle +{ + _.shuffle("abc"); // $ExpectType string[] + _.shuffle(list); // $ExpectType AbcObject[] + _.shuffle(dictionary); // $ExpectType AbcObject[] + _("abc").shuffle(); // $ExpectType Collection + _(list).shuffle(); // $ExpectType Collection + _(dictionary).shuffle(); // $ExpectType Collection + _.chain("abc").shuffle(); // $ExpectType CollectionChain + _.chain(list).shuffle(); // $ExpectType CollectionChain + _.chain(dictionary).shuffle(); // $ExpectType CollectionChain + fp.shuffle("abc"); // $ExpectType string[] + fp.shuffle(list); // $ExpectType AbcObject[] + fp.shuffle(dictionary); // $ExpectType AbcObject[] +} + +// _.size +{ + _.size(list); // $ExpectType number + _.size(dictionary); // $ExpectType number + _.size(""); // $ExpectType number + _(list).size(); // $ExpectType number + _(dictionary).size(); // $ExpectType number + _("").size(); // $ExpectType number + _.chain(list).size(); // $ExpectType PrimitiveChain + _.chain(dictionary).size(); // $ExpectType PrimitiveChain + _.chain("").size(); // $ExpectType PrimitiveChain + fp.size(list); // $ExpectType number + fp.size(dictionary); // $ExpectType number + fp.size(""); // $ExpectType number +} + +// _.some +{ + const subKey: string | number | symbol = anything; + + _.some(list); // $ExpectType boolean + _.some(list, listIterator); // $ExpectType boolean + _.some(list, subKey); // $ExpectType boolean + _.some(list, [subKey, 42]); // $ExpectType boolean + _.some(list, { a: 42 }); // $ExpectType boolean + + _.some(dictionary); // $ExpectType boolean + _.some(dictionary, dictionaryIterator); // $ExpectType boolean + _.some(dictionary, subKey); // $ExpectType boolean + _.some(dictionary, [subKey, 42]); // $ExpectType boolean + _.some(dictionary, { a: 42 }); // $ExpectType boolean + + _.some(numericDictionary); // $ExpectType boolean + _.some(numericDictionary, numericDictionaryIterator); // $ExpectType boolean + _.some(numericDictionary, subKey); // $ExpectType boolean + _.some(numericDictionary, [subKey, 42]); // $ExpectType boolean + _.some(numericDictionary, { a: 42 }); // $ExpectType boolean + + _(list).some(); // $ExpectType boolean + _(list).some(listIterator); // $ExpectType boolean + _(list).some(subKey); // $ExpectType boolean + _(list).some([subKey, 42]); // $ExpectType boolean + _(list).some({ a: 42 }); // $ExpectType boolean + + _(dictionary).some(); // $ExpectType boolean + _(dictionary).some(dictionaryIterator); // $ExpectType boolean + _(dictionary).some(subKey); // $ExpectType boolean + _(dictionary).some([subKey, 42]); // $ExpectType boolean + _(dictionary).some({ a: 42 }); // $ExpectType boolean + + _(numericDictionary).some(); // $ExpectType boolean + _(numericDictionary).some(numericDictionaryIterator); // $ExpectType boolean + _(numericDictionary).some(subKey); // $ExpectType boolean + _(numericDictionary).some([subKey, 42]); // $ExpectType boolean + _(numericDictionary).some({ a: 42 }); // $ExpectType boolean + + _.chain(list).some(); // $ExpectType PrimitiveChain + _.chain(list).some(listIterator); // $ExpectType PrimitiveChain + _.chain(list).some(subKey); // $ExpectType PrimitiveChain + _.chain(list).some([subKey, 42]); // $ExpectType PrimitiveChain + _.chain(list).some({ a: 42 }); // $ExpectType PrimitiveChain + + _.chain(dictionary).some(); // $ExpectType PrimitiveChain + _.chain(dictionary).some(dictionaryIterator); // $ExpectType PrimitiveChain + _.chain(dictionary).some(subKey); // $ExpectType PrimitiveChain + _.chain(dictionary).some([subKey, 42]); // $ExpectType PrimitiveChain + _.chain(dictionary).some({ a: 42 }); // $ExpectType PrimitiveChain + + _.chain(numericDictionary).some(); // $ExpectType PrimitiveChain + _.chain(numericDictionary).some(numericDictionaryIterator); // $ExpectType PrimitiveChain + _.chain(numericDictionary).some(subKey); // $ExpectType PrimitiveChain + _.chain(numericDictionary).some([subKey, 42]); // $ExpectType PrimitiveChain + _.chain(numericDictionary).some({ a: 42 }); // $ExpectType PrimitiveChain + + fp.some(valueIterator, list); // $ExpectType boolean + fp.some(subKey)(list); // $ExpectType boolean + fp.some({ a: 42 }, list); // $ExpectType boolean + fp.some([subKey, 42], list); // $ExpectType boolean + + fp.some(valueIterator, dictionary); // $ExpectType boolean + fp.some(subKey)(dictionary); // $ExpectType boolean + fp.some({ a: 42 })(dictionary); // $ExpectType boolean + fp.some([subKey, 42])(dictionary); // $ExpectType boolean + + fp.some(valueIterator, numericDictionary); // $ExpectType boolean + fp.some(subKey)(numericDictionary); // $ExpectType boolean + fp.some({ a: 42 })(numericDictionary); // $ExpectType boolean + fp.some([subKey, 42])(numericDictionary); // $ExpectType boolean +} + +// _.sortBy +{ + _.sortBy(list); // $ExpectType AbcObject[] + _.sortBy(list, listIterator); // $ExpectType AbcObject[] + _.sortBy(list, listIterator, listIterator); // $ExpectType AbcObject[] + _.sortBy(list, [listIterator, listIterator]); // $ExpectType AbcObject[] + _.sortBy(list, ""); // $ExpectType AbcObject[] + _.sortBy(list, { a: 42 }); // $ExpectType AbcObject[] + _.sortBy(dictionary); // $ExpectType AbcObject[] + _.sortBy(dictionary, dictionaryIterator); // $ExpectType AbcObject[] + _.sortBy(dictionary, ""); // $ExpectType AbcObject[] + _.sortBy(dictionary, { a: 42 }); // $ExpectType AbcObject[] + + _(list).sortBy(); // $ExpectType Collection + _(list).sortBy(listIterator); // $ExpectType Collection + _(list).sortBy(listIterator, listIterator); // $ExpectType Collection + _(list).sortBy([listIterator, listIterator]); // $ExpectType Collection + _(list).sortBy(""); // $ExpectType Collection + _(list).sortBy({ a: 42 }); // $ExpectType Collection + _(dictionary).sortBy(); // $ExpectType Collection + _(dictionary).sortBy(dictionaryIterator); // $ExpectType Collection + _(dictionary).sortBy(""); // $ExpectType Collection + _(dictionary).sortBy({ a: 42 }); // $ExpectType Collection + + _.chain(list).sortBy(); // $ExpectType CollectionChain + _.chain(list).sortBy(listIterator); // $ExpectType CollectionChain + _.chain(list).sortBy(listIterator, listIterator); // $ExpectType CollectionChain + _.chain(list).sortBy([listIterator, listIterator]); // $ExpectType CollectionChain + _.chain(list).sortBy(""); // $ExpectType CollectionChain + _.chain(list).sortBy({ a: 42 }); // $ExpectType CollectionChain + _.chain(dictionary).sortBy(); // $ExpectType CollectionChain + _.chain(dictionary).sortBy(dictionaryIterator); // $ExpectType CollectionChain + _.chain(dictionary).sortBy(""); // $ExpectType CollectionChain + _.chain(dictionary).sortBy({ a: 42 }); // $ExpectType CollectionChain + + fp.sortBy(fp.identity, "bca"); // $ExpectType string[] + fp.sortBy(valueIterator, list); // $ExpectType AbcObject[] + fp.sortBy(valueIterator)(list); // $ExpectType AbcObject[] + fp.sortBy([valueIterator, valueIterator])(list); // $ExpectType AbcObject[] + fp.sortBy("a", list); // $ExpectType AbcObject[] + fp.sortBy({ a: 42 }, list); // $ExpectType AbcObject[] + fp.sortBy(fp.identity, dictionary); // $ExpectType AbcObject[] + fp.sortBy(valueIterator, dictionary); // $ExpectType AbcObject[] + fp.sortBy("a", dictionary); // $ExpectType AbcObject[] + fp.sortBy({ a: 42 }, dictionary); // $ExpectType AbcObject[] +} + +// _.orderBy +{ + _.orderBy("acbd", (value) => 1); // $ExpectType string[] + _.orderBy("acbd", (value) => 1, true); // $ExpectType string[] + _.orderBy("acbd", [(value) => 1, (value) => 2], [true, false]); // $ExpectType string[] + _.orderBy(list, (value) => 1); // $ExpectType AbcObject[] + _.orderBy(list, (value) => 1, true); // $ExpectType AbcObject[] + _.orderBy(list, [(value) => 1, (value) => 2], [true, false]); // $ExpectType AbcObject[] + _.orderBy(dictionary, (value) => 1); // $ExpectType AbcObject[] + _.orderBy(dictionary, (value) => 1, true); // $ExpectType AbcObject[] + _.orderBy(numericDictionary, (value) => 1); // $ExpectType AbcObject[] + _.orderBy(numericDictionary, (value) => 1, true); // $ExpectType AbcObject[] + + _(list).orderBy((value) => 1); // $ExpectType Collection + _(list).orderBy((value) => 1, true); // $ExpectType Collection + _(list).orderBy([(value) => 1, (value) => 2], true); // $ExpectType Collection + _(dictionary).orderBy((value) => 1); // $ExpectType Collection + _(dictionary).orderBy((value) => 1, true); // $ExpectType Collection + _(numericDictionary).orderBy((value) => 1); // LoDashImplicitWrapper + _(numericDictionary).orderBy((value) => 1, true); // LoDashImplicitWrapper + + _.chain(list).orderBy((value) => 1); // $ExpectType CollectionChain + _.chain(list).orderBy((value) => 1, true); // $ExpectType CollectionChain + _.chain(list).orderBy([(value) => 1, (value) => 2], true); // $ExpectType CollectionChain + _.chain(dictionary).orderBy((value) => 1); // $ExpectType CollectionChain + _.chain(dictionary).orderBy((value) => 1, true); // $ExpectType CollectionChain + _.chain(numericDictionary).orderBy((value) => 1); // $ExpectType CollectionChain + _.chain(numericDictionary).orderBy((value) => 1, true); // $ExpectType CollectionChain + + fp.orderBy(fp.identity, "asc", "bca"); // $ExpectType string[] + fp.orderBy(fp.identity, true, "bca"); // $ExpectType string[] + fp.orderBy((value: AbcObject) => 1, true, list); // $ExpectType AbcObject[] + fp.orderBy([(value: AbcObject) => 1, (value: AbcObject) => 1])([true, false])(list); // $ExpectType AbcObject[] + fp.orderBy("a", true, list); // $ExpectType AbcObject[] + fp.orderBy({ a: 42 }, true, list); // $ExpectType AbcObject[] + fp.orderBy((value: AbcObject) => 1, true, dictionary); // $ExpectType AbcObject[] + fp.orderBy("a", true, dictionary); // $ExpectType AbcObject[] + fp.orderBy({ a: 42 }, true, dictionary); // $ExpectType AbcObject[] +} + +/******** + * Date * + ********/ + +_.now(); // $ExpectType number +_({}).now(); // $ExpectType number +_.chain({}).now(); // $ExpectType PrimitiveChain +fp.now(); // $ExpectType number + +/************ + * Function * + ************/ + +// _.after +{ + _.after(42, (a: string, b: number): boolean => true); // $ExpectType (a: string, b: number) => boolean + _(42).after((a: string, b: number): boolean => true); // $ExpectType Function<(a: string, b: number) => boolean> + _.chain(42).after((a: string, b: number): boolean => true); // $ExpectType FunctionChain<(a: string, b: number) => boolean> + fp.after((a: string, b: number): boolean => true, 42); // $ExpectType (a: string, b: number) => boolean + fp.after((a: string, b: number): boolean => true)(42); // $ExpectType (a: string, b: number) => boolean +} + +// _.ary +{ + const func = (a: string, b: number) => true; + + _.ary(func); // $ExpectType (...args: any[]) => any + _.ary(func, 2); // $ExpectType (...args: any[]) => any + _(func).ary(); // $ExpectType Function<(...args: any[]) => any> + _(func).ary(2); // $ExpectType Function<(...args: any[]) => any> + _.chain(func).ary(); // $ExpectType FunctionChain<(...args: any[]) => any> + _.chain(func).ary(2); // $ExpectType FunctionChain<(...args: any[]) => any> + fp.ary(1, func); // $ExpectType (...args: any[]) => any +} + +// _.before +{ + _.before(42, (a: string, b: number): boolean => true); // $ExpectType (a: string, b: number) => boolean + _(42).before((a: string, b: number): boolean => true); // $ExpectType Function<(a: string, b: number) => boolean> + _.chain(42).before((a: string, b: number): boolean => true); // $ExpectType FunctionChain<(a: string, b: number) => boolean> + fp.before((a: string, b: number): boolean => true, 42); // $ExpectType (a: string, b: number) => boolean + fp.before((a: string, b: number): boolean => true)(42); // $ExpectType (a: string, b: number) => boolean +} + +// _.bind +{ + const func = (a: string, b: number) => true; + + _.bind(func, anything); // $ExpectType (...args: any[]) => any + _.bind(func, anything, 42); // $ExpectType (...args: any[]) => any + _.bind(func, anything, 42, ""); // $ExpectType (...args: any[]) => any + _(func).bind(anything); // $ExpectType Function<(...args: any[]) => any> + _(func).bind(anything, 42); // $ExpectType Function<(...args: any[]) => any> + _(func).bind(anything, 42, ""); // $ExpectType Function<(...args: any[]) => any> + _.chain(func).bind(anything); // $ExpectType FunctionChain<(...args: any[]) => any> + _.chain(func).bind(anything, 42); // $ExpectType FunctionChain<(...args: any[]) => any> + _.chain(func).bind(anything, 42, ""); // $ExpectType FunctionChain<(...args: any[]) => any> + fp.bind((a: string, b: number) => true, anything); // $ExpectType (...args: any[]) => any + fp.bind((a: string, b: number) => true)(anything); // $ExpectType (...args: any[]) => any +} + +// _.bindAll +{ + const object = { a: () => {}, b: () => {}, c: () => {} }; + + _.bindAll(object); // $ExpectType { a: () => void; b: () => void; c: () => void; } + _.bindAll(object, "a", ["b", "c"]); // $ExpectType { a: () => void; b: () => void; c: () => void; } + _(object).bindAll(); // $ExpectType Object<{ a: () => void; b: () => void; c: () => void; }> + _(object).bindAll("a", ["b", "c"]); // $ExpectType Object<{ a: () => void; b: () => void; c: () => void; }> + _.chain(object).bindAll(); // $ExpectType ObjectChain<{ a: () => void; b: () => void; c: () => void; }> + _.chain(object).bindAll("a", ["b", "c"]); // $ExpectType ObjectChain<{ a: () => void; b: () => void; c: () => void; }> + fp.bindAll("a", object); // $ExpectType { a: () => void; b: () => void; c: () => void; } + fp.bindAll(["b", "c"])(object); // $ExpectType { a: () => void; b: () => void; c: () => void; } +} + +// _.bindKey +{ + const object = { + foo: (a: number, b: string) => true, + }; + + _.bindKey(object, "foo"); // $ExpectType (...args: any[]) => any + _.bindKey(object, "foo", 42, ""); // $ExpectType (...args: any[]) => any + _(object).bindKey("foo"); // $ExpectType Function<(...args: any[]) => any> + _(object).bindKey("foo", 42, ""); // $ExpectType Function<(...args: any[]) => any> + _.chain(object).bindKey("foo"); // $ExpectType FunctionChain<(...args: any[]) => any> + _.chain(object).bindKey("foo", 42, ""); // $ExpectType FunctionChain<(...args: any[]) => any> + fp.bindKey(object, "foo"); // $ExpectType (...args: any[]) => any + fp.bindKey(object)("foo"); // $ExpectType (...args: any[]) => any +} + +// _.curry +{ + const testCurry = (a: string, b: number, c: boolean): [string, number, boolean] => [a, b, c]; + _.curry(testCurry)("1", 2, true); // $ExpectType [string, number, boolean] + _.curry(testCurry)("1", 2)(true); // $ExpectType [string, number, boolean] + _.curry(testCurry)("1")(2, true); // $ExpectType [string, number, boolean] + _.curry(testCurry)("1")(2)(true); // $ExpectType [string, number, boolean] + _.curry(testCurry)("1", 2); // $ExpectType CurriedFunction1 + _.curry(testCurry)("1")(2); // $ExpectType CurriedFunction1 + _.curry(testCurry)("1"); // $ExpectType CurriedFunction2 + _.curry(testCurry); // $ExpectType CurriedFunction3 + _.curry(testCurry)(_, 2, true)("1"); // $ExpectType [string, number, boolean] + _.curry(testCurry)(_.curry.placeholder, 2, true)("1"); // $ExpectType [string, number, boolean] + _.curry(testCurry)("1", _, true)(2); // $ExpectType [string, number, boolean] + _.curry(testCurry)(_, 2)("1", true); // $ExpectType [string, number, boolean] + _.curry(testCurry)(_.curry.placeholder, 2)("1", true); // $ExpectType [string, number, boolean] + _(testCurry).curry(); // $ExpectType Function> + _.chain(testCurry).curry(); // $ExpectType FunctionChain> + + fp.curry(testCurry)("1", 2, true); // $ExpectType [string, number, boolean] + fp.curry(testCurry)("1", 2)(true); // $ExpectType [string, number, boolean] + fp.curry(testCurry)("1")(2, true); // $ExpectType [string, number, boolean] + fp.curry(testCurry)("1")(2)(true); // $ExpectType [string, number, boolean] + fp.curry(testCurry)("1", 2); // $ExpectType CurriedFunction1 + fp.curry(testCurry)("1")(2); // $ExpectType CurriedFunction1 + fp.curry(testCurry)("1"); // $ExpectType CurriedFunction2 + fp.curry(testCurry); // $ExpectType CurriedFunction3 + fp.curry(testCurry)(fp.__, 2, true)("1"); // $ExpectType [string, number, boolean] + fp.curry(testCurry)(fp.curry.placeholder, 2, true)("1"); // $ExpectType [string, number, boolean] + fp.curryN(3)(testCurry)(fp.curryN.placeholder, 2, true)("1"); // $ExpectType [string, number, boolean] + + // _.curryRight + _.curryRight(testCurry)("1", 2, true); // $ExpectType [string, number, boolean] + _.curryRight(testCurry)(2, true)("1"); // $ExpectType [string, number, boolean] + _.curryRight(testCurry)(true)("1", 2); // $ExpectType [string, number, boolean] + _.curryRight(testCurry)(true)(2)("1"); // $ExpectType [string, number, boolean] + _.curryRight(testCurry)(2, true); // $ExpectType RightCurriedFunction1 + _.curryRight(testCurry)(true)(2); // $ExpectType RightCurriedFunction1 + _.curryRight(testCurry)(true); // $ExpectType RightCurriedFunction2 + _.curryRight(testCurry); // $ExpectType RightCurriedFunction3 + _.curryRight(testCurry)("1", _, true)(2); // $ExpectType [string, number, boolean] + _.curryRight(testCurry)("1", _.curryRight.placeholder, true)(2); // $ExpectType [string, number, boolean] + _.curryRight(testCurry)(true)("1", _)(2); // $ExpectType [string, number, boolean] + _.curryRight(testCurry)(true)("1", _.curryRight.placeholder)(2); // $ExpectType [string, number, boolean] + _(testCurry).curryRight(); // $ExpectType Function> + _.chain(testCurry).curryRight(); // $ExpectType FunctionChain> + + fp.curryRight(testCurry)("1", 2, true); // $ExpectType [string, number, boolean] + fp.curryRight(testCurry)(true)("1", 2); // $ExpectType [string, number, boolean] + fp.curryRight(testCurry)(2, true)("1"); // $ExpectType [string, number, boolean] + fp.curryRight(testCurry)(true)(2)("1"); // $ExpectType [string, number, boolean] + fp.curryRight(testCurry)(2, true); // $ExpectType RightCurriedFunction1 + fp.curryRight(testCurry)(true)(2); // $ExpectType RightCurriedFunction1 + fp.curryRight(testCurry)(true); // $ExpectType RightCurriedFunction2 + fp.curryRight(testCurry); // $ExpectType RightCurriedFunction3 + fp.curryRight(testCurry)("1", fp.__, true)(2); // $ExpectType [string, number, boolean] + fp.curryRight(testCurry)("1", fp.curryRight.placeholder, true)(2); // $ExpectType [string, number, boolean] + fp.curryRightN(3)(testCurry)("1", fp.curryRightN.placeholder, true)(2); // $ExpectType [string, number, boolean] +} + +// _.debounce +{ + const func = (n: number, s: string): boolean => true; + const options: _.DebounceSettings = { + leading: true, + maxWait: 100, + trailing: false, + }; + + const result = _.debounce(func); // $ExpectType ((n: number, s: string) => boolean) & Cancelable + result.cancel(); // $ExpectType void + result.flush(); // $ExpectType void + _.debounce(func, 42); // $ExpectType ((n: number, s: string) => boolean) & Cancelable + _.debounce(func, 42, options); // $ExpectType ((n: number, s: string) => boolean) & Cancelable + + _(func).debounce(42, options); // $ExpectType Function<((n: number, s: string) => boolean) & Cancelable> + _.chain(func).debounce(42, options); // $ExpectType FunctionChain<((n: number, s: string) => boolean) & Cancelable> + fp.debounce(42, func); // $ExpectType ((n: number, s: string) => boolean) & Cancelable + fp.debounce(42)(func); // $ExpectType ((n: number, s: string) => boolean) & Cancelable +} + +// _.defer +{ + const func = (a: number, b: string) => true; + + _.defer(func); // $ExpectType number + _.defer(func, anything, anything, anything); // $ExpectType number + _(func).defer(); // $ExpectType Primitive + _(func).defer(anything, anything, anything); // $ExpectType Primitive + _.chain(func).defer(); // $ExpectType PrimitiveChain + _.chain(func).defer(anything, anything, anything); // $ExpectType PrimitiveChain + fp.defer(func); // $ExpectType number +} + +// _.delay +{ + const func = (a: number, b: string) => true; + + _.delay(func, 500); // $ExpectType number + _.delay(func, 500, anything, anything); // $ExpectType number + _(func).delay(500); // $ExpectType Primitive + _(func).delay(500, anything, anything); // $ExpectType Primitive + _.chain(func).delay(500); // $ExpectType PrimitiveChain + _.chain(func).delay(500, anything, anything); // $ExpectType PrimitiveChain + fp.delay(500, func); // $ExpectType number + fp.delay(500)(func); // $ExpectType number +} + +// _.flip +{ + // TODO: fix - output arguments should be reversed + _.flip((a: string, b: number): boolean => true); // $ExpectType (a: string, b: number) => boolean + _((a: string, b: number): boolean => true).flip(); // $ExpectType Function<(a: string, b: number) => boolean> + _.chain((a: string, b: number): boolean => true).flip(); // $ExpectType FunctionChain<(a: string, b: number) => boolean> + fp.flip((a: string, b: number): boolean => true); // $ExpectType (a: string, b: number) => boolean +} + +// _.flow +// _.flowRight +{ + const fn1 = (n: number): number => 0; + const fn2 = (m: number, n: number): number => 0; + const fn3 = (a: number): string => ""; + const fn4 = (a: string): boolean => true; + const fn5 = (): number => 0; + + _.flow(fn2, fn1); // $ExpectType (m: number, n: number) => number + _.flow(fn2, fn1, fn1, fn1, fn1, fn1, fn1); // $ExpectType (m: number, n: number) => number + _.flow(fn2, fn1, fn3, fn4); // $ExpectType (m: number, n: number) => boolean + _.flow([fn2, fn1, fn3, fn4]); // $ExpectType (...args: any[]) => any + _.flow(fn5, fn1); // $ExpectType () => number + + _(fn2).flow(fn1); // $ExpectType Function<(m: number, n: number) => number> + _(fn2).flow(fn1, fn1); // $ExpectType Function<(m: number, n: number) => number> + _(fn2).flow(fn1, fn1, fn1); // $ExpectType Function<(m: number, n: number) => number> + _(fn2).flow([fn1, fn1, fn1]); // $ExpectType Function<(...args: any[]) => any> + _(fn5).flow(fn1); // $ExpectType Function<() => number> + + _.chain(fn2).flow(fn1); // $ExpectType FunctionChain<(m: number, n: number) => number> + _.chain(fn2).flow(fn1, fn1); // $ExpectType FunctionChain<(m: number, n: number) => number> + _.chain(fn2).flow(fn1, fn1, fn1); // $ExpectType FunctionChain<(m: number, n: number) => number> + _.chain(fn2).flow([fn1, fn1, fn1]); // $ExpectType FunctionChain<(...args: any[]) => any> + _.chain(fn5).flow(fn1); // $ExpectType FunctionChain<() => number> + + fp.flow(fn1, fn1); // $ExpectType (n: number) => number + fp.flow(fn1, fn3); // $ExpectType (n: number) => string + fp.flow(fn2, fn1, fn1); // $ExpectType (m: number, n: number) => number + fp.flow(fn2, fn1, fn1, fn1); // $ExpectType (m: number, n: number) => number + fp.flow(fn2, fn1, fn1, fn1, fn1); // $ExpectType (m: number, n: number) => number + fp.flow(fn2, fn1, fn1, fn1, fn1, fn1); // $ExpectType (m: number, n: number) => number + fp.flow(fn2, fn1, fn1, fn1, fn1, fn1, fn1); // $ExpectType (m: number, n: number) => number + fp.flow(fn2, fn3); // $ExpectType (m: number, n: number) => string + fp.flow(fn2, fn3, fn4); // $ExpectType (m: number, n: number) => boolean + fp.flow(fn2, fn1, fn3, fn4); // $ExpectType (m: number, n: number) => boolean + fp.flow([fn2, fn1, fn3, fn4]); // $ExpectType (...args: any[]) => any + fp.flow(fn5, fn1); // $ExpectType () => number + + _.flowRight(fn1, fn2); // $ExpectType (m: number, n: number) => number + _.flowRight(fn1, fn1, fn2); // $ExpectType (m: number, n: number) => number + _.flowRight(fn1, fn1, fn1, fn2); // $ExpectType (m: number, n: number) => number + _.flowRight([fn1, fn1, fn1, fn2]); // $ExpectType (...args: any[]) => any + _.flowRight(fn1, fn5); // $ExpectType () => number + + _(fn1).flowRight(fn2); // $ExpectType Function<(m: number, n: number) => number> + _(fn1).flowRight(fn1, fn2); // $ExpectType Function<(m: number, n: number) => number> + _(fn1).flowRight(fn1, fn1, fn2); // $ExpectType Function<(m: number, n: number) => number> + _(fn1).flowRight([fn1, fn1, fn2]); // $ExpectType Function<(...args: any[]) => any> + _(fn1).flowRight(fn5); // $ExpectType Function<() => number> + + _.chain(fn1).flowRight(fn2); // $ExpectType FunctionChain<(m: number, n: number) => number> + _.chain(fn1).flowRight(fn1, fn2); // $ExpectType FunctionChain<(m: number, n: number) => number> + _.chain(fn1).flowRight(fn1, fn1, fn2); // $ExpectType FunctionChain<(m: number, n: number) => number> + _.chain(fn1).flowRight([fn1, fn1, fn2]); // $ExpectType FunctionChain<(...args: any[]) => any> + _.chain(fn1).flowRight(fn5); // $ExpectType FunctionChain<() => number> + + fp.flowRight(fn1, fn1); // $ExpectType (n: number) => number + fp.flowRight(fn3, fn1); // $ExpectType (n: number) => string + fp.flowRight(fn1, fn1, fn2); // $ExpectType (m: number, n: number) => number + fp.flowRight(fn1, fn1, fn1, fn2); // $ExpectType (m: number, n: number) => number + fp.flowRight(fn1, fn1, fn1, fn1, fn2); // $ExpectType (m: number, n: number) => number + fp.flowRight(fn1, fn1, fn1, fn1, fn1, fn2); // $ExpectType (m: number, n: number) => number + fp.flowRight(fn1, fn1, fn1, fn1, fn1, fn1, fn2); // $ExpectType (m: number, n: number) => number + fp.flowRight(fn3, fn2); // $ExpectType (m: number, n: number) => string + fp.flowRight(fn4, fn3, fn2); // $ExpectType (m: number, n: number) => boolean + fp.flowRight(fn4, fn3, fn1, fn2); // $ExpectType (m: number, n: number) => boolean + fp.flowRight([fn4, fn3, fn1, fn2]); // $ExpectType (...args: any[]) => any + fp.flowRight(fn1, fn5); // $ExpectType () => number +} + +// _.memoize +{ + const memoizedFunction: _.MemoizedFunction = anything; + memoizedFunction.cache; // $ExpectType MapCache + + const testMapCache: _.MapCache = { + delete(key: string) { return true; }, + get(key: string): any { return 1; }, + has(key: string) { return true; }, + set(key: string, value: any): _.MapCache { return this; }, + clear() { }, + }; + + const memoizeFn = (a1: string, a2: number): boolean => true; + const memoizeResolverFn = (a1: string, a2: number) => ""; + + _.memoize(memoizeFn); // $ExpectType ((a1: string, a2: number) => boolean) & MemoizedFunction + _.memoize(memoizeFn, memoizeResolverFn); // $ExpectType ((a1: string, a2: number) => boolean) & MemoizedFunction + _(memoizeFn).memoize(); // $ExpectType Function<((a1: string, a2: number) => boolean) & MemoizedFunction> + _(memoizeFn).memoize(memoizeResolverFn); // $ExpectType Function<((a1: string, a2: number) => boolean) & MemoizedFunction> + _.chain(memoizeFn).memoize(); // $ExpectType FunctionChain<((a1: string, a2: number) => boolean) & MemoizedFunction> + _.chain(memoizeFn).memoize(memoizeResolverFn); // $ExpectType FunctionChain<((a1: string, a2: number) => boolean) & MemoizedFunction> + fp.memoize(memoizeFn); // $ExpectType ((a1: string, a2: number) => boolean) & MemoizedFunction + + // $ExpectType MapCache + new _.memoize.Cache(); + _.memoize.Cache = WeakMap; + _.memoize.Cache = Map; + const memoizedFn = _.memoize(memoizeFn); + memoizedFn.cache = new WeakMap(); + memoizedFn.cache = new Map(); +} + +// _.overArgs +{ + const func = (a: number, b: string) => true; + + _.overArgs(func, (a: number) => true, (b: string) => true); // $ExpectType (...args: any[]) => any + _.overArgs(func, [(a: number) => true, (b: string) => true]); // $ExpectType (...args: any[]) => any + _(func).overArgs((a: number) => true, (b: string) => true); // $ExpectType Function<(...args: any[]) => any> + _(func).overArgs([(a: number) => true, (b: string) => true]); // $ExpectType Function<(...args: any[]) => any> + _.chain(func).overArgs((a: number) => true, (b: string) => true); // $ExpectType FunctionChain<(...args: any[]) => any> + _.chain(func).overArgs([(a: number) => true, (b: string) => true]); // $ExpectType FunctionChain<(...args: any[]) => any> + + fp.overArgs(func, [(a: number) => true, (b: string) => true]); // $ExpectType (...args: any[]) => any + fp.overArgs(func)([(a: number) => true, (b: string) => true]); // $ExpectType (...args: any[]) => any +} + +// _.negate +{ + _.negate((a1: number, a2: number): boolean => true); // $ExpectType (a1: number, a2: number) => boolean + _((a1: number, a2: number): boolean => true).negate(); // $ExpectType Function<(a1: number, a2: number) => boolean> + _.chain((a1: number, a2: number): boolean => true).negate(); // $ExpectType FunctionChain<(a1: number, a2: number) => boolean> + fp.negate((a1: number, a2: number): boolean => true); // $ExpectType (a1: number, a2: number) => boolean + + const userDefinedTypeGuard = (item: any): item is number => typeof item === "number"; + + _.negate(userDefinedTypeGuard); // $ExpectType (item: any) => boolean + _(userDefinedTypeGuard).negate(); // $ExpectType Function<(item: any) => boolean> + _.chain(userDefinedTypeGuard).negate(); // $ExpectType FunctionChain<(item: any) => boolean> + fp.negate(userDefinedTypeGuard); // $ExpectType (item: any) => boolean + + _.negate((a1: number, a2: number, a3: number): boolean => true); // $ExpectType (a1: number, a2: number, a3: number) => boolean + _((a1: number, a2: number, a3: number): boolean => true).negate(); // $ExpectType Function<(a1: number, a2: number, a3: number) => boolean> + _.chain((a1: number, a2: number, a3: number): boolean => true).negate(); // $ExpectType FunctionChain<(a1: number, a2: number, a3: number) => boolean> + fp.negate((a1: number, a2: number, a3: number): boolean => true); // $ExpectType (a1: number, a2: number, a3: number) => boolean +} + +// _.once +{ + _.once((a: string, b: number): boolean => true); // $ExpectType (a: string, b: number) => boolean + _((a: string, b: number): boolean => true).once(); // $ExpectType Function<(a: string, b: number) => boolean> + _.chain((a: string, b: number): boolean => true).once(); // $ExpectType FunctionChain<(a: string, b: number) => boolean> + fp.once((a: string, b: number): boolean => true); // $ExpectType (a: string, b: number) => boolean +} + +// _.rearg +{ + const testReargFn = (a: string, b: string, c: string) => [a, b, c]; + _.rearg(testReargFn, 2, 0, 1); // $ExpectType (...args: any[]) => any + _.rearg(testReargFn, [2, 0, 1]); // $ExpectType (...args: any[]) => any + _(testReargFn).rearg(2, 0, 1); // $ExpectType Function<(...args: any[]) => any> + _(testReargFn).rearg([2, 0, 1]); // $ExpectType Function<(...args: any[]) => any> + _.chain(testReargFn).rearg(2, 0, 1); // $ExpectType FunctionChain<(...args: any[]) => any> + _.chain(testReargFn).rearg([2, 0, 1]); // $ExpectType FunctionChain<(...args: any[]) => any> + + fp.rearg([2, 0, 1], testReargFn); // $ExpectType (...args: any[]) => any + fp.rearg([2, 0, 1])(testReargFn); // $ExpectType (...args: any[]) => any +} + +// _.rest +{ + _.rest((a: string, b: number[]) => true); // $ExpectType (...args: any[]) => any + _.rest((a: string, b: number[]) => true, 1); // $ExpectType (...args: any[]) => any + _((a: string, b: number[]) => true).rest(); // $ExpectType Function<(...args: any[]) => any> + _((a: string, b: number[]) => true).rest(1); // $ExpectType Function<(...args: any[]) => any> + _.chain((a: string, b: number[]) => true).rest(); // $ExpectType FunctionChain<(...args: any[]) => any> + _.chain((a: string, b: number[]) => true).rest(1); // $ExpectType FunctionChain<(...args: any[]) => any> + fp.rest((a: string, b: number[]) => true); // $ExpectType (...args: any[]) => any + fp.restFrom(1)((a: string, b: number[]) => true); // $ExpectType (...args: any[]) => any +} + +// _.spread +{ + _.spread((a: Array): boolean => true); // $ExpectType (...args: any[]) => boolean + _((a: Array): boolean => true).spread(); // $ExpectType Function<(...args: any[]) => boolean> + _.chain((a: Array): boolean => true).spread(); // $ExpectType FunctionChain<(...args: any[]) => boolean> + fp.spread((a: Array): boolean => true); // $ExpectType (...args: any[]) => boolean +} + +// _.throttle +{ + const options: _.ThrottleSettings = { + leading: true, + trailing: false, + }; + + const func = (a: number, b: string): boolean => true; + + _.throttle(func); // $ExpectType ((a: number, b: string) => boolean) & Cancelable + _.throttle(func, 42); // $ExpectType ((a: number, b: string) => boolean) & Cancelable + _.throttle(func, 42, options); // $ExpectType ((a: number, b: string) => boolean) & Cancelable + _(func).throttle(); // $ExpectType Function<((a: number, b: string) => boolean) & Cancelable> + _(func).throttle(42); // $ExpectType Function<((a: number, b: string) => boolean) & Cancelable> + _(func).throttle(42, options); // $ExpectType Function<((a: number, b: string) => boolean) & Cancelable> + _.chain(func).throttle(); // $ExpectType FunctionChain<((a: number, b: string) => boolean) & Cancelable> + _.chain(func).throttle(42); // $ExpectType FunctionChain<((a: number, b: string) => boolean) & Cancelable> + _.chain(func).throttle(42, options); // $ExpectType FunctionChain<((a: number, b: string) => boolean) & Cancelable> + + fp.throttle(42, func); // $ExpectType ((a: number, b: string) => boolean) & Cancelable + fp.throttle(42)(func); // $ExpectType ((a: number, b: string) => boolean) & Cancelable +} + +// _.unary +{ + _.unary((a: string, b: number): boolean => true); // $ExpectType (arg1: string) => boolean + _((a: string, b: number): boolean => true).unary(); // $ExpectType Function<(arg1: string) => boolean> + _.chain((a: string, b: number): boolean => true).unary(); // $ExpectType FunctionChain<(arg1: string) => boolean> + fp.unary((a: string, b: number): boolean => true); // $ExpectType (arg1: string) => boolean +} + +// _.wrap +{ + _.wrap("a", (arg1: string, ...args: number[]): boolean => true); // $ExpectType (...args: number[]) => boolean + _("a").wrap((arg1: string, ...args: number[]): boolean => true); // $ExpectType Function<(...args: number[]) => boolean> + _.chain("a").wrap((arg1: string, ...args: number[]): boolean => true); // $ExpectType FunctionChain<(...args: number[]) => boolean> + fp.wrap((arg1: string, ...args: number[]): boolean => true, "a"); // $ExpectType (...args: number[]) => boolean + fp.wrap((arg1: string, ...args: number[]): boolean => true)("a"); // $ExpectType (...args: number[]) => boolean +} + +/******** + * Lang * + ********/ + +// _.castArray +{ + _.castArray(42); // $ExpectType number[] + _.castArray([42]); // $ExpectType number[] + _.castArray({ a: 42 }); // $ExpectType { a: number; }[] + _(42).castArray(); // $ExpectType Collection + _([42]).castArray(); // $ExpectType Collection + _.chain(42).castArray(); // $ExpectType CollectionChain + _.chain([42]).castArray(); // $ExpectType CollectionChain + + fp.castArray(42); // $ExpectType number[] + fp.castArray([42]); // $ExpectType number[] +} + +// _.clone +{ + _.clone(42); // $ExpectType 42 + _.clone({ a: { b: 42 } }); // $ExpectType { a: { b: number; }; } + _(42).clone(); // $ExpectType number + _({ a: { b: 42 } }).clone(); // $ExpectType { a: { b: number; }; } + _.chain(42).clone(); // $ExpectType PrimitiveChain + _.chain({ a: { b: 42 } }).clone(); // $ExpectType ObjectChain<{ a: { b: number; }; }> + fp.clone(42); // $ExpectType 42 + fp.clone({ a: { b: 42 } }); // $ExpectType { a: { b: number; }; } +} + +// _.cloneDeep +{ + _.cloneDeep(42); // $ExpectType 42 + _.cloneDeep({ a: { b: 42 } }); // $ExpectType { a: { b: number; }; } + _(42).cloneDeep(); // $ExpectType number + _({ a: { b: 42 } }).cloneDeep(); // $ExpectType { a: { b: number; }; } + _.chain(42).cloneDeep(); // $ExpectType PrimitiveChain + _.chain({ a: { b: 42 } }).cloneDeep(); // $ExpectType ObjectChain<{ a: { b: number; }; }> + fp.cloneDeep(42); // $ExpectType 42 + fp.cloneDeep({ a: { b: 42 } }); // $ExpectType { a: { b: number; }; } +} + +// _.cloneDeepWith +{ + const customizer = (x: any) => ""; + + _.cloneDeepWith(42, customizer); // $ExpectType any + _(42).cloneDeepWith(customizer); // $ExpectType any + _.chain(42).cloneDeepWith(customizer); // $ExpectType LoDashExplicitWrapper + + _.cloneDeepWith({a: {b: 42}}, customizer); // $ExpectType any + + fp.cloneDeepWith((x) => "", 42); // $ExpectType any + fp.cloneDeepWith((x) => "")(42); // $ExpectType any + fp.cloneDeepWith((x) => "", [42]); // $ExpectType any + fp.cloneDeepWith((x) => "", { a: { b: 42 } }); // $ExpectType any +} + +// _.cloneWith +{ + { + const customizer = (x: number) => ""; + + _.cloneWith(42, customizer); // $ExpectType string + _(42).cloneWith(customizer); // $ExpectType string + _.chain(42).cloneWith(customizer); // $ExpectType StringChain + + fp.cloneWith(customizer, 42); // $ExpectType string + fp.cloneWith(customizer)(42); // $ExpectType string + } + + { + const customizer = (x: number): string | undefined => ""; + const value: number = anything; + + _.cloneWith(value, customizer); // string | number + _(value).cloneWith(customizer); // string | number + _.chain(value).cloneWith(customizer); // string | number + + fp.cloneWith(customizer, value); // $ExpectType string | number + fp.cloneWith(customizer)(value); // $ExpectType string | number + } +} + +// _.conforms +{ + _.conforms({ })({ foo: "foo" }); // $ExpectType boolean + _({ foo: (v: string) => false }).conforms().value()({ foo: "foo" }); // $ExpectType boolean + _.chain({ foo: (v: string) => false }).conforms().value()({ foo: "foo" }); // $ExpectType boolean + fp.conforms({ foo: (v: string) => false })({ foo: "foo" }); // $ExpectType boolean +} + +// _.conformsTo +{ + _.conformsTo({ foo: "foo" }, { foo: (v: string) => false }); // $ExpectType boolean + _({ foo: "foo" }).conformsTo({ foo: (v: string) => false }); // $ExpectType boolean + _.chain({ foo: "foo" }).conformsTo({ foo: (v: string) => false }); // $ExpectType PrimitiveChain + + fp.conformsTo({ foo: (v: string) => false }, { foo: "foo" }); // $ExpectType boolean + fp.conformsTo({ foo: (v: string) => false })({ foo: "foo" }); // $ExpectType boolean +} + +// _.eq +{ + _.eq(anything, anything); // $ExpectType boolean + _(anything).eq(anything); // $ExpectType boolean + _.chain(anything).eq(anything); // $ExpectType PrimitiveChain + + fp.eq(anything, anything); // $ExpectType boolean + fp.eq(anything)(anything); // $ExpectType boolean +} + +// _.gt +{ + _.gt(anything, anything); // $ExpectType boolean + _(anything).gt(anything); // $ExpectType boolean + _.chain(anything).gt(anything); // $ExpectType PrimitiveChain + + fp.gt(anything, anything); // $ExpectType boolean + fp.gt(anything)(anything); // $ExpectType boolean +} + +// _.gte +{ + _.gte(anything, anything); // $ExpectType boolean + _(anything).gte(anything); // $ExpectType boolean + _.chain(anything).gte(anything); // $ExpectType PrimitiveChain + + fp.gte(anything, anything); // $ExpectType boolean + fp.gte(anything)(anything); // $ExpectType boolean +} + +// _.isArguments +{ + const value: number | IArguments = 0; + + if (_.isArguments(value)) { + const result: IArguments = value; + } else { + value; // $ExpectType number + } + + if (fp.isArguments(value)) { + const result: IArguments = value; + } else { + value; // $ExpectType number + } + + _.isArguments(""); // $ExpectType boolean + _({}).isArguments(); // $ExpectType boolean + _.chain([]).isArguments(); // $ExpectType PrimitiveChain + fp.isArguments(anything); // $ExpectType boolean +} + +// _.isArray +{ + const value: number | string[] | boolean[] = anything; + + if (_.isArray(value)) { + const result: string[] | boolean[] = value; + } else { + value; // $ExpectType number + } + + if (fp.isArray(value)) { + const result: string[] | boolean[] = value; + } else { + value; // $ExpectType number + } + + _.isArray(anything); // $ExpectType boolean + _({}).isArray(); // $ExpectType boolean + _.chain([]).isArray(); // $ExpectType PrimitiveChain + fp.isArray(anything); // $ExpectType boolean +} + +// _.isArrayBuffer +{ + const value: ArrayBuffer | number = anything; + + if (_.isArrayBuffer(value)) { + value; // $ExpectType ArrayBuffer + } else { + value; // $ExpectType number + } + + if (fp.isArrayBuffer(value)) { + value; // $ExpectType ArrayBuffer + } else { + value; // $ExpectType number + } + + _.isArrayBuffer(anything); // $ExpectType boolean + _({}).isArrayBuffer(); // $ExpectType boolean + _.chain([]).isArrayBuffer(); // $ExpectType PrimitiveChain + fp.isArrayBuffer(anything); // $ExpectType boolean +} + +// _.isArrayLike +{ + { + const value: string | string[] | { [index: number]: boolean, length: number } | [number, boolean] + | number | { length: string } | { a: string } | null | undefined + = anything; + + if (_.isArrayLike(value)) { + const result: string | string[] | { [index: number]: boolean, length: number } | [number, boolean] = value; + } else { + const result: number | { length: string } | { a: string; } | null | undefined = value; + } + + if (fp.isArrayLike(value)) { + const result: string | string[] | { [index: number]: boolean; length: number; } | [number, boolean] = value; + } else { + const result: number | { length: string; } | { a: string; } | null | undefined = value; + } + } + + { + const value: boolean[] = anything; + + if (_.isArrayLike(value)) { + const result: boolean[] = value; + } else { + value; // $ExpectType never + } + + if (fp.isArrayLike(value)) { + value; // $ExpectType boolean[] + } else { + value; // $ExpectType never + } + } + + { + const value: () => number = anything; + + if (_.isArrayLike(value)) { + value; // $ExpectType never + } else { + value; // $ExpectType () => number + } + + if (fp.isArrayLike(value)) { + value; // $ExpectType never + } else { + value; // $ExpectType () => number + } + } + + { + const value: { a: string } = anything; + + if (_.isArrayLike(value)) { + const result: { a: string, length: number } = value; + } else { + value; // $ExpectType { a: string; } + } + + if (fp.isArrayLike(value)) { + const result: { a: string, length: number } = value; + } else { + value; // $ExpectType { a: string; } + } + } + + { + const value: any = anything; + + if (_.isArrayLike(value)) { + value; // $ExpectType any + } else { + value; // $ExpectType any + } + + if (fp.isArrayLike(value)) { + value; // $ExpectType any + } else { + value; // $ExpectType any + } + } + + _.isArrayLike(anything); // $ExpectType boolean + _({}).isArrayLike(); // $ExpectType boolean + _.chain([]).isArrayLike(); // $ExpectType PrimitiveChain + fp.isArrayLike(anything); // $ExpectType boolean +} + +// _.isArrayLikeObject +{ + { + const value: string[] | { [index: number]: boolean, length: number } | [number, boolean] + | number | string | { length: string } | { a: string } | null | undefined + = anything; + + if (_.isArrayLikeObject(value)) { + const result: string[] | { [index: number]: boolean, length: number } | [number, boolean] = value; + } else { + const result: string | number | { length: string; } | { a: string; } | null | undefined = value; + } + + if (fp.isArrayLikeObject(value)) { + const result: string[] | [number, boolean] | { [index: number]: boolean; length: number; } = value; + } else { + const result: string | number | { length: string; } | { a: string; } | null | undefined = value; + } + } + + { + const value: boolean[] = anything; + + if (_.isArrayLikeObject(value)) { + const result: boolean[] = value; + } else { + value; // $ExpectType never + } + + if (fp.isArrayLikeObject(value)) { + const result: boolean[] = value; + } else { + value; // $ExpectType never + } + } + + { + const value: (a: string) => boolean = anything; + + if (_.isArrayLikeObject(value)) { + value; // $ExpectType never + } else { + value; // $ExpectType (a: string) => boolean + } + + if (fp.isArrayLikeObject(value)) { + value; // $ExpectType never + } else { + value; // $ExpectType (a: string) => boolean + } + } + + { + const value: { a: string } = anything; + + if (_.isArrayLikeObject(value)) { + const result: { a: string, length: number } = value; + } else { + value; // $ExpectType { a: string; } + } + + if (fp.isArrayLikeObject(value)) { + const result: { a: string, length: number } = value; + } else { + value; // $ExpectType { a: string; } + } + } + + { + const value: any = anything; + + if (_.isArrayLikeObject(value)) { + value; // $ExpectType any + } else { + value; // $ExpectType any + } + + if (fp.isArrayLikeObject(value)) { + value; // $ExpectType any + } else { + value; // $ExpectType any + } + } + + _.isArrayLikeObject(anything); // $ExpectType boolean + _({}).isArrayLikeObject(); // $ExpectType boolean + _.chain([]).isArrayLikeObject(); // $ExpectType PrimitiveChain + fp.isArrayLikeObject(anything); // $ExpectType boolean +} + +// _.isBoolean +{ + const value: number | boolean = 0; + + if (_.isBoolean(value)) { + const result: boolean = value; + } else { + value; // $ExpectType number + } + + if (fp.isBoolean(value)) { + const result: boolean = value; + } else { + value; // $ExpectType number + } + + _.isBoolean(anything); // $ExpectType boolean + _({}).isBoolean(); // $ExpectType boolean + _.chain([]).isBoolean(); // $ExpectType PrimitiveChain +} + +// _.isBuffer +{ + _.isBuffer(anything); // $ExpectType boolean + _({}).isBuffer(); // $ExpectType boolean + _.chain([]).isBuffer(); // $ExpectType PrimitiveChain + fp.isBuffer(anything); // $ExpectType boolean +} + +// _.isDate +{ + const value: number | Date = 0; + + if (_.isDate(value)) { + const result: Date = value; + } else { + value; // $ExpectType number + } + + if (fp.isDate(value)) { + const date: Date = value; + } else { + value; // $ExpectType number + } + + _.isDate(anything); // $ExpectType boolean + _({}).isDate(); // $ExpectType boolean + _.chain([]).isDate(); // $ExpectType PrimitiveChain + fp.isDate(anything); // $ExpectType boolean +} + +// _.isElement +{ + _.isElement(anything); // $ExpectType boolean + _({}).isElement(); // $ExpectType boolean + _.chain([]).isElement(); // $ExpectType PrimitiveChain + fp.isElement(anything); // $ExpectType boolean +} + +// _.isEmpty +{ + _.isEmpty(anything); // $ExpectType boolean + _({}).isEmpty(); // $ExpectType boolean + _.chain([]).isEmpty(); // $ExpectType PrimitiveChain + fp.isEmpty(anything); // $ExpectType boolean +} + +// _.isEqual +{ + _.isEqual(anything, anything); // $ExpectType boolean + _(anything).isEqual(anything); // $ExpectType boolean + _.chain(anything).isEqual(anything); // $ExpectType PrimitiveChain + + fp.isEqual(anything, anything); // $ExpectType boolean + fp.isEqual(anything)(anything); // $ExpectType boolean + fp.equals(anything)(anything); // $ExpectType boolean +} + +// _.isEqualWith +{ + const customizer = (value: any, other: any, indexOrKey: number|string|symbol|undefined, parent: any, otherParent: any, stack: any) => true; + + _.isEqualWith(anything, anything, customizer); // $ExpectType boolean + _(anything).isEqualWith(anything, customizer); // $ExpectType boolean + _.chain(anything).isEqualWith(anything, customizer); // $ExpectType PrimitiveChain + + fp.isEqualWith(customizer, anything, anything); // $ExpectType boolean + fp.isEqualWith(customizer)(anything)(anything); // $ExpectType boolean +} + +// _.isError +{ + { + const value: number | Error = anything; + + if (_.isError(value)) { + value; // $ExpectType Error + } else { + value; // $ExpectType number + } + + if (fp.isError(value)) { + value; // $ExpectType Error + } else { + value; // $ExpectType number + } + } + + { + class CustomError extends Error { + custom: string; + } + + const value: number | CustomError = anything; + + if (_.isError(value)) { + value; // $ExpectType CustomError + } else { + value; // $ExpectType number + } + + if (fp.isError(value)) { + value; // $ExpectType CustomError + } else { + value; // $ExpectType number + } + } + + _.isError(anything); // $ExpectType boolean + _({}).isError(); // $ExpectType boolean + _.chain([]).isError(); // $ExpectType PrimitiveChain + fp.isError(anything); // $ExpectType boolean +} + +// _.isFinite +{ + _.isFinite(NaN); // $ExpectType boolean + _(42).isFinite(); // $ExpectType boolean + _.chain([]).isFinite(); // $ExpectType PrimitiveChain + fp.isFinite(anything); // $ExpectType boolean +} + +// _.isFunction +{ + const value: number | (() => void) = anything; + + if (_.isFunction(value)) { + value; // $ExpectType () => void + } else { + value; // $ExpectType number + } + + if (fp.isFunction(value)) { + value; // $ExpectType () => void + } else { + value; // $ExpectType number + } + + if (_.isFunction(anything)) { + anything(); + } + + if (fp.isFunction(anything)) { + anything(); + } + + _.isFunction(anything); // $ExpectType boolean + _({}).isFunction(); // $ExpectType boolean + _.chain([]).isFunction(); // $ExpectType PrimitiveChain + fp.isFunction(anything); // $ExpectType boolean +} + +// _.isInteger +{ + _.isInteger(NaN); // $ExpectType boolean + _(42).isInteger(); // $ExpectType boolean + _.chain([]).isInteger(); // $ExpectType PrimitiveChain + fp.isInteger(anything); // $ExpectType boolean +} + +// _.isLength +{ + _.isLength(NaN); // $ExpectType boolean + _(42).isLength(); // $ExpectType boolean + _.chain([]).isLength(); // $ExpectType PrimitiveChain + fp.isLength(anything); // $ExpectType boolean +} + +// _.isMap +{ + const value: number | Map = 0; + + if (_.isMap(value)) { + const result: Map = value; + } else { + const result: number = value; + } + + if (fp.isMap(value)) { + const result: Map = value; + } else { + const result: number = value; + } + + _.isMap(anything); // $ExpectType boolean + _({}).isMap(); // $ExpectType boolean + _.chain([]).isMap(); // $ExpectType PrimitiveChain + fp.isMap(anything); // $ExpectType boolean +} + +// _.isMatch +{ + _.isMatch({}, {}); // $ExpectType boolean + _({}).isMatch({}); // $ExpectType boolean + _.chain({}).isMatch({}); // $ExpectType PrimitiveChain + fp.isMatch({}, {}); // $ExpectType boolean + fp.isMatch({})({}); // $ExpectType boolean +} + +// _.isMatchWith +{ + const testIsMatchCustiomizerFn = (value: any, other: any, indexOrKey: number|string|symbol, object: object, source: object) => true; + + _.isMatchWith({}, {}, testIsMatchCustiomizerFn); // $ExpectType boolean + _({}).isMatchWith({}, testIsMatchCustiomizerFn); // $ExpectType boolean + _.chain({}).isMatchWith({}, testIsMatchCustiomizerFn); // $ExpectType PrimitiveChain + + fp.isMatchWith(testIsMatchCustiomizerFn, {}, {}); // $ExpectType boolean + fp.isMatchWith(testIsMatchCustiomizerFn)({})({}); // $ExpectType boolean +} + +// _.isNaN +{ + _.isNaN(NaN); // $ExpectType boolean + _(42).isNaN(); // $ExpectType boolean + _.chain([]).isNaN(); // $ExpectType PrimitiveChain + fp.isNaN(anything); // $ExpectType boolean +} + +// _.isNative +{ + const value: number | (() => void) = anything; + + if (_.isNative(value)) { + value; // $ExpectType () => void + } else { + value; // $ExpectType number + } + + if (fp.isNative(value)) { + value; // $ExpectType () => void + } else { + value; // $ExpectType number + } + + _.isNative(anything); // $ExpectType boolean + _({}).isNative(); // $ExpectType boolean + _.chain([]).isNative(); // $ExpectType PrimitiveChain + fp.isNative(anything); // $ExpectType boolean +} + +// _.isNil +{ + _.isNil(null); // $ExpectType boolean + _(undefined).isNil(); // $ExpectType boolean + _.chain(NaN).isNil(); // $ExpectType PrimitiveChain + fp.isNil(undefined); // $ExpectType boolean +} + +// _.isNull +{ + _.isNull(null); // $ExpectType boolean + _(undefined).isNull(); // $ExpectType boolean + _.chain(NaN).isNull(); // $ExpectType PrimitiveChain + fp.isNull(undefined); // $ExpectType boolean +} + +// _.isNumber +{ + const value: string | number = 0; + + if (_.isNumber(value)) { + const result: number = value; + } else { + const result: string = value; + } + + if (fp.isNumber(value)) { + const result: number = value; + } else { + const result: string = value; + } + + _.isNumber(NaN); // $ExpectType boolean + _(42).isNumber(); // $ExpectType boolean + _.chain([]).isNumber(); // $ExpectType PrimitiveChain + fp.isNumber(anything); // $ExpectType boolean +} + +// _.isObject +{ + _.isObject(NaN); // $ExpectType boolean + _(42).isObject(); // $ExpectType boolean + _.chain([]).isObject(); // $ExpectType PrimitiveChain + fp.isObject(anything); // $ExpectType boolean + if (fp.isObject(anything)) { + anything; // $ExpectType object + } + if (_.isObject(anything)) { + anything; // $ExpectType object + } +} + +// _.isObjectLike +{ + _.isObjectLike(NaN); // $ExpectType boolean + _(42).isObjectLike(); // $ExpectType boolean + _.chain([]).isObjectLike(); // $ExpectType PrimitiveChain + fp.isObjectLike(anything); // $ExpectType boolean +} + +// _.isPlainObject +{ + _.isPlainObject(NaN); // $ExpectType boolean + _(42).isPlainObject(); // $ExpectType boolean + _.chain([]).isPlainObject(); // $ExpectType PrimitiveChain + fp.isPlainObject(anything); // $ExpectType boolean +} + +// _.isRegExp +{ + { + const value: number | RegExp = anything; + + if (_.isRegExp(value)) { + const result: RegExp = value; + } else { + const result: number = value; + } + + if (fp.isRegExp(value)) { + const result: RegExp = value; + } else { + const result: number = value; + } + } + + _.isRegExp(/./); // $ExpectType boolean + _(42).isRegExp(); // $ExpectType boolean + _.chain([]).isRegExp(); // $ExpectType PrimitiveChain + fp.isRegExp(anything); // $ExpectType boolean +} + +// _.isSafeInteger +{ + _.isSafeInteger(NaN); // $ExpectType boolean + _(42).isSafeInteger(); // $ExpectType boolean + _.chain([]).isSafeInteger(); // $ExpectType PrimitiveChain + fp.isSafeInteger(anything); // $ExpectType boolean +} + +// _.isSet +{ + const value: number | Set = 0; + + if (_.isSet(value)) { + const result: Set = value; + } else { + const result: number = value; + } + + if (fp.isSet(value)) { + const result: Set = value; + } else { + const result: number = value; + } + + _.isSet(NaN); // $ExpectType boolean + _(42).isSet(); // $ExpectType boolean + _.chain([]).isSet(); // $ExpectType PrimitiveChain + fp.isSet(anything); // $ExpectType boolean +} + +// _.isString +{ + const value: number | string = ""; + + if (_.isString(value)) { + const result: string = value; + } else { + const result: number = value; + } + + if (fp.isString(value)) { + const result: string = value; + } else { + const result: number = value; + } + + _.isString(""); // $ExpectType boolean + _(42).isString(); // $ExpectType boolean + _.chain([]).isString(); // $ExpectType PrimitiveChain + fp.isString(anything); // $ExpectType boolean +} + +// _.isSymbol +{ + _.isSymbol(NaN); // $ExpectType boolean + _(42).isSymbol(); // $ExpectType boolean + _.chain([]).isSymbol(); // $ExpectType PrimitiveChain + fp.isSymbol(anything); // $ExpectType boolean +} + +// _.isTypedArray +{ + _.isTypedArray(NaN); // $ExpectType boolean + _(42).isTypedArray(); // $ExpectType boolean + _.chain([]).isTypedArray(); // $ExpectType PrimitiveChain + fp.isTypedArray(anything); // $ExpectType boolean +} + +// _.isUndefined +{ + _.isUndefined(null); // $ExpectType boolean + _(undefined).isUndefined(); // $ExpectType boolean + _.chain(NaN).isUndefined(); // $ExpectType PrimitiveChain + fp.isUndefined(undefined); // $ExpectType boolean +} + +// _.isWeakMap +{ + const value: number | WeakMap = 0; + + if (_.isWeakMap(value)) { + const result: WeakMap = value; + } else { + const result: number = value; + } + + if (fp.isWeakMap(value)) { + const result: WeakMap = value; + } else { + const result: number = value; + } + + _.isWeakMap(NaN); // $ExpectType boolean + _(42).isWeakMap(); // $ExpectType boolean + _.chain([]).isWeakMap(); // $ExpectType PrimitiveChain + fp.isWeakMap(anything); // $ExpectType boolean +} + +// _.isWeakSet +{ + const value: number | WeakSet = 0; + + if (_.isWeakSet(value)) { + const result: WeakSet = value; + } else { + const result: number = value; + } + + if (fp.isWeakSet(value)) { + const result: WeakSet = value; + } else { + const result: number = value; + } + + _.isWeakSet(NaN); // $ExpectType boolean + _(42).isWeakSet(); // $ExpectType boolean + _.chain([]).isWeakSet(); // $ExpectType PrimitiveChain + fp.isWeakSet(anything); // $ExpectType boolean +} + +// _.lt +{ + _.lt(anything, anything); // $ExpectType boolean + _(anything).lt(anything); // $ExpectType boolean + _.chain(anything).lt(anything); // $ExpectType PrimitiveChain + + fp.lt(anything, anything); // $ExpectType boolean + fp.lt(anything)(anything); // $ExpectType boolean +} + +// _.lte +{ + _.lte(anything, anything); // $ExpectType boolean + _(anything).lte(anything); // $ExpectType boolean + _.chain(anything).lte(anything); // $ExpectType PrimitiveChain + + fp.lte(anything, anything); // $ExpectType boolean + fp.lte(anything)(anything); // $ExpectType boolean +} + +// _.toArray +{ + const array: AbcObject[] = []; + const list: _.List = []; + const dictionary: _.Dictionary = {}; + const numericDictionary: _.NumericDictionary = {}; + + _.toArray(""); // $ExpectType string[] + _.toArray(array); // $ExpectType AbcObject[] + _.toArray(list); // $ExpectType AbcObject[] + _.toArray(dictionary); // $ExpectType AbcObject[] + _.toArray(numericDictionary); // $ExpectType AbcObject[] + + _(array).toArray(); // $ExpectType Collection + _(list).toArray(); // $ExpectType Collection + _(dictionary).toArray(); // $ExpectType Collection + _(numericDictionary).toArray(); // $ExpectType Collection + + _.chain(array).toArray(); // $ExpectType CollectionChain + _.chain(list).toArray(); // $ExpectType CollectionChain + _.chain(dictionary).toArray(); // $ExpectType CollectionChain + _.chain(numericDictionary).toArray(); // $ExpectType CollectionChain + + fp.toArray(""); // $ExpectType string[] + fp.toArray(array); // $ExpectType AbcObject[] + fp.toArray(list); // $ExpectType AbcObject[] + fp.toArray(dictionary); // $ExpectType AbcObject[] + fp.toArray(numericDictionary); // $ExpectType AbcObject[] +} + +// _.toPlainObject +{ + _.toPlainObject(); // $ExpectType any + _.toPlainObject(true); // $ExpectType any + _.toPlainObject(1); // $ExpectType any + _.toPlainObject("a"); // $ExpectType any + _.toPlainObject([]); // $ExpectType any + _.toPlainObject({}); // $ExpectType any + + _(true).toPlainObject(); // $ExpectType Object + _([""]).toPlainObject(); // $ExpectType Object + _({}).toPlainObject(); // $ExpectType Object + + _.chain(true).toPlainObject(); // $ExpectType ObjectChain + _.chain([""]).toPlainObject(); // $ExpectType ObjectChain + _.chain({}).toPlainObject(); // $ExpectType ObjectChain + + fp.toPlainObject(true); // $ExpectType any + fp.toPlainObject(["a"]); // $ExpectType any + fp.toPlainObject({}); // $ExpectType any +} + +// _.toFinite +{ + _.toFinite(true); // $ExpectType number + _.toFinite(1); // $ExpectType number + _.toFinite("3.2"); // $ExpectType number + _(1).toFinite(); // $ExpectType number + _("3.2").toFinite(); // $ExpectType number + _.chain(1).toFinite(); // $ExpectType PrimitiveChain + _.chain("3.2").toFinite(); // $ExpectType PrimitiveChain + fp.toFinite(true); // $ExpectType number + fp.toFinite(1); // $ExpectType number + fp.toFinite("3.2"); // $ExpectType number +} + +// _.toInteger +{ + _.toInteger(true); // $ExpectType number + _.toInteger(1); // $ExpectType number + _.toInteger("3.2"); // $ExpectType number + _(1).toInteger(); // $ExpectType number + _("3.2").toInteger(); // $ExpectType number + _.chain(1).toInteger(); // $ExpectType PrimitiveChain + _.chain("3.2").toInteger(); // $ExpectType PrimitiveChain + fp.toInteger(true); // $ExpectType number + fp.toInteger(1); // $ExpectType number + fp.toInteger("3.2"); // $ExpectType number +} + +// _.toLength +{ + _.toLength(true); // $ExpectType number + _.toLength(1); // $ExpectType number + _.toLength("3.2"); // $ExpectType number + _(1).toLength(); // $ExpectType number + _("3.2").toLength(); // $ExpectType number + _.chain(1).toLength(); // $ExpectType PrimitiveChain + _.chain("3.2").toLength(); // $ExpectType PrimitiveChain + fp.toLength(true); // $ExpectType number + fp.toLength(1); // $ExpectType number + fp.toLength("3.2"); // $ExpectType number +} + +// _.toNumber +{ + _.toNumber(true); // $ExpectType number + _.toNumber(1); // $ExpectType number + _.toNumber("3.2"); // $ExpectType number + _(1).toNumber(); // $ExpectType number + _("3.2").toNumber(); // $ExpectType number + _.chain(1).toNumber(); // $ExpectType PrimitiveChain + _.chain("3.2").toNumber(); // $ExpectType PrimitiveChain + fp.toNumber(true); // $ExpectType number + fp.toNumber(1); // $ExpectType number + fp.toNumber("3.2"); // $ExpectType number +} + +// _.toSafeInteger +{ + _.toSafeInteger(true); // $ExpectType number + _.toSafeInteger(1); // $ExpectType number + _.toSafeInteger("3.2"); // $ExpectType number + _(1).toSafeInteger(); // $ExpectType number + _("3.2").toSafeInteger(); // $ExpectType number + _.chain(1).toSafeInteger(); // $ExpectType PrimitiveChain + _.chain("3.2").toSafeInteger(); // $ExpectType PrimitiveChain + fp.toSafeInteger(true); // $ExpectType number + fp.toSafeInteger(1); // $ExpectType number + fp.toSafeInteger("3.2"); // $ExpectType number +} + +/******** + * Math * + ********/ + +// _.add +{ + _.add(1, 1); // $ExpectType number + _(1).add(1); // $ExpectType number + _(1).chain().add(1); // $ExpectType PrimitiveChain + fp.add(1, 1); // $ExpectType number + fp.add(1)(1); // $ExpectType number +} + +// _.ceil +{ + _.ceil(6.004); // $ExpectType number + _.ceil(6.004, 2); // $ExpectType number + _(6.004).ceil(); // $ExpectType number + _(6.004).ceil(2); // $ExpectType number + _(6.004).chain().ceil(); // $ExpectType PrimitiveChain + _(6.004).chain().ceil(2); // $ExpectType PrimitiveChain + fp.ceil(6.004); // $ExpectType number +} + +// _.divide +{ + _.divide(6, 4); // $ExpectType number + _(6).divide(4); // $ExpectType number + _(6).chain().floor(4); // $ExpectType PrimitiveChain + fp.divide(6, 4); // $ExpectType number + fp.divide(6)(4); // $ExpectType number +} + +// _.floor +{ + _.floor(4.006); // $ExpectType number + _.floor(0.046, 2); // $ExpectType number + _.floor(4060, -2); // $ExpectType number + _(4.006).floor(); // $ExpectType number + _(0.046).floor(2); // $ExpectType number + _(4060).floor(-2); // $ExpectType number + _(4.006).chain().floor(); // $ExpectType PrimitiveChain + _(0.046).chain().floor(2); // $ExpectType PrimitiveChain + _(4060).chain().floor(-2); // $ExpectType PrimitiveChain + fp.floor(4.006); // $ExpectType number +} + +// _.max +// _.min +{ + const list: ArrayLike = anything; + + _.max(list); // $ExpectType string | undefined + _(list).max(); // $ExpectType string | undefined + _.chain(list).max(); // $ExpectType StringChain | PrimitiveChain + fp.max(list); // $ExpectType string | undefined + + _.min(list); // $ExpectType string | undefined + _(list).min(); // $ExpectType string | undefined + _.chain(list).min(); // $ExpectType StringChain | PrimitiveChain + fp.min(list); // $ExpectType string | undefined +} + +// _.maxBy +// _.minBy +{ + const list: ArrayLike = anything; + + _.maxBy(list, valueIterator); // $ExpectType AbcObject | undefined + _.maxBy(list, "a"); // $ExpectType AbcObject | undefined + _.maxBy(list, { a: 42 }); // $ExpectType AbcObject | undefined + _(list).maxBy(valueIterator); // $ExpectType AbcObject | undefined + _(list).maxBy("a"); // $ExpectType AbcObject | undefined + _(list).maxBy({ a: 42 }); // $ExpectType AbcObject | undefined + _.chain(list).maxBy(valueIterator); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).maxBy("a"); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).maxBy({ a: 42 }); // $ExpectType PrimitiveChain | ObjectChain + fp.maxBy(valueIterator)(list); // $ExpectType AbcObject | undefined + fp.maxBy("a", list); // $ExpectType AbcObject | undefined + fp.maxBy({ a: 42 }, list); // $ExpectType AbcObject | undefined + + _.minBy(list, valueIterator); // $ExpectType AbcObject | undefined + _.minBy(list, "a"); // $ExpectType AbcObject | undefined + _.minBy(list, { a: 42 }); // $ExpectType AbcObject | undefined + _(list).minBy(valueIterator); // $ExpectType AbcObject | undefined + _(list).minBy("a"); // $ExpectType AbcObject | undefined + _(list).minBy({ a: 42 }); // $ExpectType AbcObject | undefined + _.chain(list).minBy(valueIterator); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).minBy("a"); // $ExpectType PrimitiveChain | ObjectChain + _.chain(list).minBy({ a: 42 }); // $ExpectType PrimitiveChain | ObjectChain + fp.minBy(valueIterator)(list); // $ExpectType AbcObject | undefined + fp.minBy("a", list); // $ExpectType AbcObject | undefined + fp.minBy({ a: 42 }, list); // $ExpectType AbcObject | undefined +} + +// _.mean +{ + const list: ArrayLike = anything; + + _.mean(list); // $ExpectType number + _(list).mean(); // $ExpectType number + _.chain(list).mean(); // $ExpectType PrimitiveChain + fp.mean(list); // $ExpectType number +} + +// _.meanBy +{ + const list: ArrayLike = anything; + + _.meanBy(list, (x) => x.a); // $ExpectType number + _.meanBy(list, "a"); // $ExpectType number + _(list).meanBy((x) => x.a); // $ExpectType number + _.chain(list).meanBy((x) => x.a); // $ExpectType PrimitiveChain + + fp.meanBy((x) => x.a, list); // $ExpectType number + fp.meanBy((x: AbcObject) => x.a)(list); // $ExpectType number + fp.meanBy("a", list); // $ExpectType number +} + +// _.multiply +{ + _.multiply(6, 4); // $ExpectType number + _(6).multiply(4); // $ExpectType number + _(6).chain().multiply(4); // $ExpectType PrimitiveChain + fp.multiply(6, 4); // $ExpectType number + fp.multiply(6)(4); // $ExpectType number +} + +// _.round +{ + _.round(4.006); // $ExpectType number + _.round(4.006, 2); // $ExpectType number + _(4.006).round(); // $ExpectType number + _(4.006).round(2); // $ExpectType number + _(4.006).chain().round(); // $ExpectType PrimitiveChain + _(4.006).chain().round(2); // $ExpectType PrimitiveChain + fp.round(4.006); // $ExpectType number +} + + // _.subtract +{ + _.subtract(3, 2); // $ExpectType number + _(3).subtract(2); // $ExpectType number + _(3).chain().subtract(2); // $ExpectType PrimitiveChain + fp.subtract(3, 2); // $ExpectType number + fp.subtract(3)(2); // $ExpectType number +} + +// _.sum +{ + const list: ArrayLike | null | undefined = anything; + + _.sum(list); // $ExpectType number + _(list).sum(); // $ExpectType number + _(list).chain().sum(); // $ExpectType PrimitiveChain + fp.sum(list); // $ExpectType number +} + +// _.sumBy +{ + const listIterator = (value: AbcObject) => 0; + + _.sumBy(list, listIterator); // $ExpectType number + _.sumBy(list, "a"); // $ExpectType number + _(list).sumBy(listIterator); // $ExpectType number + _(list).sumBy("a"); // $ExpectType number + _(list).chain().sumBy(listIterator); // $ExpectType PrimitiveChain + _(list).chain().sumBy("a"); // $ExpectType PrimitiveChain + + fp.sumBy(listIterator, list); // $ExpectType number + fp.sumBy("a")(list); // $ExpectType number +} + +/********** + * Number * + **********/ + +// _.clamp +{ + _.clamp(3, 2, 4); // $ExpectType number + _.clamp(3, 4); // $ExpectType number + _(3).clamp(2, 4); // $ExpectType number + _(3).clamp(4); // $ExpectType number + _.chain(3).clamp(2, 4); // $ExpectType PrimitiveChain + fp.clamp(2, 4, 3); // $ExpectType number + fp.clamp(2)(4)(3); // $ExpectType number +} + +// _.inRange +{ + _.inRange(3, 2, 4); // $ExpectType boolean + _.inRange(4, 8); // $ExpectType boolean + _(3).inRange(2, 4); // $ExpectType boolean + _(4).inRange(8); // $ExpectType boolean + _.chain(3).inRange(2, 4); // $ExpectType PrimitiveChain + _.chain(4).inRange(8); // $ExpectType PrimitiveChain + fp.inRange(2, 4, 3); // $ExpectType boolean + fp.inRange(2)(4)(3); // $ExpectType boolean +} + +// _.random +{ + _.random(); // $ExpectType number + _.random(1); // $ExpectType number + _.random(1, 2); // $ExpectType number + _.random(1, 2, true); // $ExpectType number + _.random(1, true); // $ExpectType number + _.random(true); // $ExpectType number + + _(1).random(); // $ExpectType number + _(1).random(2); // $ExpectType number + _(1).random(2, true); // $ExpectType number + _(1).random(true); // $ExpectType number + _(true).random(); // $ExpectType number + + _.chain(1).random(); // $ExpectType PrimitiveChain + _.chain(1).random(2); // $ExpectType PrimitiveChain + _.chain(1).random(2, true); // $ExpectType PrimitiveChain + _.chain(1).random(true); // $ExpectType PrimitiveChain + _.chain(true).random(); // $ExpectType PrimitiveChain + + fp.random(1, 2); // $ExpectType number + fp.random(1)(2); // $ExpectType number + + _.map([5, 5], _.random); // $ExpectType number[] +} + +/********** + * Object * + **********/ + +// _.assign +// _.assignIn +// _.assignWith +// _.assignInWith +// _.defaults +// _.extend +// _.extendWith +// _.merge +// _.mergeWith +{ + const obj = { a: "" }; + const s1 = { b: 1 }; + const s2 = { c: 1 }; + const s3 = { d: 1 }; + const s4 = { e: 1 }; + const s5 = { f: 1 }; + + const customizer = (objectValue: any, sourceValue: any, key: string | undefined, object: {} | undefined, source: {} | undefined) => 1; + + _.assign(obj); // $ExpectType { a: string; } + _.assign(obj, s1); // $ExpectType { a: string; } & { b: number; } + _.assign(obj, s1, s2, s3, s4); // $ExpectType { a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; } + _.assign(obj, s1, s2, s3, s4, s5); + _(obj).assign(); // $ExpectType Object<{ a: string; }> + _(obj).assign(s1); // $ExpectType Object<{ a: string; } & { b: number; }> + _(obj).assign(s1, s2, s3, s4); // $ExpectType Object<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _(obj).assign(s1, s2, s3, s4, s5); + _.chain(obj).assign(); // $ExpectType ObjectChain<{ a: string; }> + _.chain(obj).assign(s1); // $ExpectType ObjectChain<{ a: string; } & { b: number; }> + _.chain(obj).assign(s1, s2, s3, s4); // $ExpectType ObjectChain<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _.chain(obj).assign(s1, s2, s3, s4, s5); + fp.assign(obj, s1); // $ExpectType { a: string; } & { b: number; } + fp.assign(obj)(s1); // $ExpectType { a: string; } & { b: number; } + + _.assignIn(obj); // $ExpectType { a: string; } + _.assignIn(obj, s1); // $ExpectType { a: string; } & { b: number; } + _.assignIn(obj, s1, s2, s3, s4); // $ExpectType { a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; } + _.assignIn(obj, s1, s2, s3, s4, s5); + _(obj).assignIn(); // $ExpectType Object<{ a: string; }> + _(obj).assignIn(s1); // $ExpectType Object<{ a: string; } & { b: number; }> + _(obj).assignIn(s1, s2, s3, s4); // $ExpectType Object<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _(obj).assignIn(s1, s2, s3, s4, s5); + _.chain(obj).assignIn(); // $ExpectType ObjectChain<{ a: string; }> + _.chain(obj).assignIn(s1); // $ExpectType ObjectChain<{ a: string; } & { b: number; }> + _.chain(obj).assignIn(s1, s2, s3, s4); // $ExpectType ObjectChain<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _.chain(obj).assignIn(s1, s2, s3, s4, s5); + fp.assignIn(obj, s1); // $ExpectType { a: string; } & { b: number; } + fp.assignIn(obj)(s1); // $ExpectType { a: string; } & { b: number; } + + _.assignWith(obj); // $ExpectType { a: string; } + _.assignWith(obj, s1, customizer); // $ExpectType { a: string; } & { b: number; } + _.assignWith(obj, s1, s2, s3, s4, customizer); // $ExpectType { a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; } + _.assignWith(obj, s1, s2, s3, s4, s5, customizer); + _(obj).assignWith(); // $ExpectType Object<{ a: string; }> + _(obj).assignWith(s1, customizer); // $ExpectType Object<{ a: string; } & { b: number; }> + _(obj).assignWith(s1, s2, s3, s4, customizer); // $ExpectType Object<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _(obj).assignWith(s1, s2, s3, s4, s5, customizer); + _.chain(obj).assignWith(); // $ExpectType ObjectChain<{ a: string; }> + _.chain(obj).assignWith(s1, customizer); // $ExpectType ObjectChain<{ a: string; } & { b: number; }> + _.chain(obj).assignWith(s1, s2, s3, s4, customizer); // $ExpectType ObjectChain<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _.chain(obj).assignWith(s1, s2, s3, s4, s5, customizer); + fp.assignWith(customizer, obj, s1); // $ExpectType { a: string; } & { b: number; } + fp.assignWith(customizer)(obj)(s1); // $ExpectType { a: string; } & { b: number; } + + _.assignInWith(obj); // $ExpectType { a: string; } + _.assignInWith(obj, s1, customizer); // $ExpectType { a: string; } & { b: number; } + _.assignInWith(obj, s1, s2, s3, s4, customizer); // $ExpectType { a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; } + _.assignInWith(obj, s1, s2, s3, s4, s5, customizer); + _(obj).assignInWith(); // $ExpectType Object<{ a: string; }> + _(obj).assignInWith(s1, customizer); // $ExpectType Object<{ a: string; } & { b: number; }> + _(obj).assignInWith(s1, s2, s3, s4, customizer); // $ExpectType Object<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _(obj).assignInWith(s1, s2, s3, s4, s5, customizer); + _.chain(obj).assignInWith(); // $ExpectType ObjectChain<{ a: string; }> + _.chain(obj).assignInWith(s1, customizer); // $ExpectType ObjectChain<{ a: string; } & { b: number; }> + _.chain(obj).assignInWith(s1, s2, s3, s4, customizer); // $ExpectType ObjectChain<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _.chain(obj).assignInWith(s1, s2, s3, s4, s5, customizer); + fp.assignInWith(customizer, obj, s1); // $ExpectType { a: string; } & { b: number; } + fp.assignInWith(customizer)(obj)(s1); // $ExpectType { a: string; } & { b: number; } + + _.defaults(obj); // $ExpectType { a: string; } + _.defaults(obj, s1); // $ExpectType { b: number; } & { a: string; } + _.defaults(obj, s1, s2, s3, s4); // $ExpectType { e: number; } & { d: number; } & { c: number; } & { b: number; } & { a: string; } + _.defaults(obj, s1, s2, s3, s4, s5); + _(obj).defaults(); // $ExpectType Object<{ a: string; }> + _(obj).defaults(s1); // $ExpectType Object<{ b: number; } & { a: string; }> + _(obj).defaults(s1, s2, s3, s4); // $ExpectType Object<{ e: number; } & { d: number; } & { c: number; } & { b: number; } & { a: string; }> + _(obj).defaults(s1, s2, s3, s4, s5); + _.chain(obj).defaults(); // $ExpectType ObjectChain<{ a: string; }> + _.chain(obj).defaults(s1); // $ExpectType ObjectChain<{ b: number; } & { a: string; }> + _.chain(obj).defaults(s1, s2, s3, s4); // $ExpectType ObjectChain<{ e: number; } & { d: number; } & { c: number; } & { b: number; } & { a: string; }> + _.chain(obj).defaults(s1, s2, s3, s4, s5); + fp.defaults(obj, s1); // $ExpectType { a: string; } & { b: number; } + fp.defaults(obj)(s1); // $ExpectType { a: string; } & { b: number; } + + _.extend(obj); // $ExpectType { a: string; } + _.extend(obj, s1); // $ExpectType { a: string; } & { b: number; } + _.extend(obj, s1, s2, s3, s4); // $ExpectType { a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; } + _.extend(obj, s1, s2, s3, s4, s5); + _(obj).extend(); // $ExpectType Object<{ a: string; }> + _(obj).extend(s1); // $ExpectType Object<{ a: string; } & { b: number; }> + _(obj).extend(s1, s2, s3, s4); // $ExpectType Object<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _(obj).extend(s1, s2, s3, s4, s5); + _.chain(obj).extend(); // $ExpectType ObjectChain<{ a: string; }> + _.chain(obj).extend(s1); // $ExpectType ObjectChain<{ a: string; } & { b: number; }> + _.chain(obj).extend(s1, s2, s3, s4); // $ExpectType ObjectChain<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _.chain(obj).extend(s1, s2, s3, s4, s5); + fp.extend(obj, s1); // $ExpectType { a: string; } & { b: number; } + fp.extend(obj)(s1); // $ExpectType { a: string; } & { b: number; } + + _.extendWith(obj); // $ExpectType { a: string; } + _.extendWith(obj, s1, customizer); // $ExpectType { a: string; } & { b: number; } + _.extendWith(obj, s1, s2, s3, s4, customizer); // $ExpectType { a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; } + _.extendWith(obj, s1, s2, s3, s4, s5, customizer); + _(obj).extendWith(); // $ExpectType Object<{ a: string; }> + _(obj).extendWith(s1, customizer); // $ExpectType Object<{ a: string; } & { b: number; }> + _(obj).extendWith(s1, s2, s3, s4, customizer); // $ExpectType Object<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _(obj).extendWith(s1, s2, s3, s4, s5, customizer); + _.chain(obj).extendWith(); // $ExpectType ObjectChain<{ a: string; }> + _.chain(obj).extendWith(s1, customizer); // $ExpectType ObjectChain<{ a: string; } & { b: number; }> + _.chain(obj).extendWith(s1, s2, s3, s4, customizer); // $ExpectType ObjectChain<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _.chain(obj).extendWith(s1, s2, s3, s4, s5, customizer); + fp.extendWith(customizer, obj, s1); // $ExpectType { a: string; } & { b: number; } + fp.extendWith(customizer)(obj)(s1); // $ExpectType { a: string; } & { b: number; } + + _.merge(obj, s1); // $ExpectType { a: string; } & { b: number; } + _.merge(obj, s1, s2, s3, s4); // $ExpectType { a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; } + _.merge(obj, s1, s2, s3, s4, s5); + _(obj).merge(s1); // $ExpectType Object<{ a: string; } & { b: number; }> + _(obj).merge(s1, s2, s3, s4); // $ExpectType Object<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _(obj).merge(s1, s2, s3, s4, s5); + _.chain(obj).merge(s1); // $ExpectType ObjectChain<{ a: string; } & { b: number; }> + _.chain(obj).merge(s1, s2, s3, s4); // $ExpectType ObjectChain<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _.chain(obj).merge(s1, s2, s3, s4, s5); + fp.merge(obj, s1); // $ExpectType { a: string; } & { b: number; } + fp.merge(obj)(s1); // $ExpectType { a: string; } & { b: number; } + + _.mergeWith(obj, s1, customizer); // $ExpectType { a: string; } & { b: number; } + _.mergeWith(obj, s1, s2, s3, s4, customizer); // $ExpectType { a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; } + _.mergeWith(obj, s1, s2, s3, s4, s5, customizer); + _(obj).mergeWith(s1, customizer); // $ExpectType Object<{ a: string; } & { b: number; }> + _(obj).mergeWith(s1, s2, s3, s4, customizer); // $ExpectType Object<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _(obj).mergeWith(s1, s2, s3, s4, s5, customizer); + _.chain(obj).mergeWith(s1, customizer); // $ExpectType ObjectChain<{ a: string; } & { b: number; }> + _.chain(obj).mergeWith(s1, s2, s3, s4, customizer); // $ExpectType ObjectChain<{ a: string; } & { b: number; } & { c: number; } & { d: number; } & { e: number; }> + _.chain(obj).mergeWith(s1, s2, s3, s4, s5, customizer); + fp.mergeWith(customizer, obj, s1); // $ExpectType { a: string; } & { b: number; } + fp.mergeWith(customizer)(obj)(s1); // $ExpectType { a: string; } & { b: number; } +} + +// _.create +{ + const prototype = { a: 1 }; + const properties = { b: "" }; + + _.create(prototype, properties); // $ExpectType { a: number; } & { b: string; } + _(prototype).create(properties); // $ExpectType Object<{ a: number; } & { b: string; }> + _.chain(prototype).create(properties); // $ExpectType ObjectChain<{ a: number; } & { b: string; }> + const combined: { a: number } & object = fp.create(prototype); +} + +// _.defaultsDeep +{ + const testDefaultsDeepObject = { user: { name: "barney" } }; + const testDefaultsDeepSource = { user: { name: "fred", age: 36 } }; + _.defaultsDeep(testDefaultsDeepObject, testDefaultsDeepSource); // $ExpectType any + _(testDefaultsDeepObject).defaultsDeep(testDefaultsDeepSource); // $ExpectType Object + _.chain(testDefaultsDeepObject).defaultsDeep(testDefaultsDeepSource); // $ExpectType ObjectChain + + fp.defaultsDeep(testDefaultsDeepSource, testDefaultsDeepObject); // $ExpectType any + fp.defaultsDeep(testDefaultsDeepSource)(testDefaultsDeepObject); // $ExpectType any +} + +// _.entries +// _.entriesIn +{ + const dictionary: _.Dictionary = anything; + const numericDictionary: _.NumericDictionary = anything; + + _.entries(dictionary); // $ExpectType [string, number][] + _.entries(numericDictionary); // $ExpectType [string, number][] + _.entries(abcObject); // $ExpectType [string, any][] + _(dictionary).entries(); // $ExpectType Collection<[string, number]> + _(numericDictionary).entries(); // $ExpectType Collection<[string, number]> + _.chain(dictionary).entries(); // $ExpectType CollectionChain<[string, number]> + _.chain(numericDictionary).entries(); // $ExpectType CollectionChain<[string, number]> + _.chain(abcObject).entries(); // $ExpectType CollectionChain<[string, string | number | boolean]> + fp.entries(dictionary); // $ExpectType [string, number][] + + _.entriesIn(dictionary); // $ExpectType [string, number][] + _.entriesIn(numericDictionary); // $ExpectType [string, number][] + _.entriesIn(abcObject); // $ExpectType [string, any][] + _(dictionary).entriesIn(); // $ExpectType Collection<[string, number]> + _(numericDictionary).entriesIn(); // $ExpectType Collection<[string, number]> + _.chain(dictionary).entriesIn(); // $ExpectType CollectionChain<[string, number]> + _.chain(numericDictionary).entriesIn(); // $ExpectType CollectionChain<[string, number]> + _.chain(abcObject).entriesIn(); // $ExpectType CollectionChain<[string, string | number | boolean]> + fp.entriesIn(dictionary); // $ExpectType [string, number][] +} + +// _.findKey +// _.findLastKey +{ + const predicateFn = (value: string, key: string, object: { a: string }) => true; + const predicateFn2 = (value: number) => true; + + _.findKey({ a: "" }); // $ExpectType string | undefined + _.findKey({ a: "" }, predicateFn); // $ExpectType string | undefined + _.findKey({ a: "" }, ""); // $ExpectType string | undefined + _.findKey({ a: { b: 5 } }, { b: 42 }); // $ExpectType string | undefined + _.findKey({ a: { b: 5 } }, ["b", 5]); // $ExpectType string | undefined + _({ a: "" }).findKey(); // $ExpectType string | undefined + _({ a: "" }).findKey(predicateFn); // $ExpectType string | undefined + _({ a: "" }).findKey(""); // $ExpectType string | undefined + _({ a: { b: 5 } }).findKey({ b: 42 }); // $ExpectType string | undefined + _({ a: { b: 5 } }).findKey(["b", 5]); // $ExpectType string | undefined + _.chain({ a: "" }).findKey(); // $ExpectType StringNullableChain + _.chain({ a: "" }).findKey(predicateFn); // $ExpectType StringNullableChain + _.chain({ a: "" }).findKey(""); // $ExpectType StringNullableChain + _.chain({ a: { b: 5 } }).findKey({ b: 42 }); // $ExpectType StringNullableChain + _.chain({ a: { b: 5 } }).findKey(["b", 5]); // $ExpectType StringNullableChain + fp.findKey(predicateFn2, { a: 1 }); // $ExpectType string | undefined + fp.findKey(predicateFn2)({ a: 1 }); // $ExpectType string | undefined + + _.findLastKey({ a: "" }); // $ExpectType string | undefined + _.findLastKey({ a: "" }, predicateFn); // $ExpectType string | undefined + _.findLastKey({ a: "" }, ""); // $ExpectType string | undefined + _.findLastKey({ a: { b: 5 } }, { b: 42 }); // $ExpectType string | undefined + _.findLastKey({ a: { b: 5 } }, ["b", 5]); // $ExpectType string | undefined + _({ a: "" }).findLastKey(); // $ExpectType string | undefined + _({ a: "" }).findLastKey(predicateFn); // $ExpectType string | undefined + _({ a: "" }).findLastKey(""); // $ExpectType string | undefined + _({ a: { b: 5 } }).findLastKey({ b: 42 }); // $ExpectType string | undefined + _({ a: { b: 5 } }).findLastKey(["b", 5]); // $ExpectType string | undefined + _.chain({ a: "" }).findLastKey(); // $ExpectType StringNullableChain + _.chain({ a: "" }).findLastKey(predicateFn); // $ExpectType StringNullableChain + _.chain({ a: "" }).findLastKey(""); // $ExpectType StringNullableChain + _.chain({ a: { b: 5 } }).findLastKey({ b: 42 }); // $ExpectType StringNullableChain + _.chain({ a: { b: 5 } }).findLastKey(["b", 5]); // $ExpectType StringNullableChain + fp.findLastKey(predicateFn2, { a: 1 }); // $ExpectType string | undefined + fp.findLastKey(predicateFn2)({ a: 1 }); // $ExpectType string | undefined +} + +// _.forIn +// _.forInRight +// _.forOwn +// _.forOwnRight +{ + const dictionary: _.Dictionary = {}; + const dictionaryIterator = (value: number, key: string, collection: _.Dictionary) => {}; + const dictionaryIterator2 = (value: number) => {}; + + const object: AbcObject | null | undefined = anything; + const objectIterator = (element: string | number | boolean, key: string, collection: AbcObject) => {}; + const objectIterator2 = (element: number | string | boolean) => {}; + + _.forIn(dictionary); // $ExpectType Dictionary + _.forIn(dictionary, dictionaryIterator); // $ExpectType Dictionary + _.forIn(object); // $ExpectType AbcObject | null | undefined + _.forIn(object, objectIterator); // $ExpectType AbcObject | null | undefined + _(object).forIn(); // $ExpectType Object + _(object).forIn(objectIterator); // $ExpectType Object + _.chain(object).forIn(); // $ExpectType ObjectChain + _.chain(object).forIn(objectIterator); // $ExpectType ObjectChain + fp.forIn(dictionaryIterator2, dictionary); // $ExpectType Dictionary + fp.forIn(objectIterator2)(object); // $ExpectType AbcObject | null | undefined + + _.forInRight(dictionary); // $ExpectType Dictionary + _.forInRight(dictionary, dictionaryIterator); // $ExpectType Dictionary + _.forInRight(object); // $ExpectType AbcObject | null | undefined + _.forInRight(object, objectIterator); // $ExpectType AbcObject | null | undefined + _(object).forInRight(); // $ExpectType Object + _(object).forInRight(objectIterator); // $ExpectType Object + _.chain(object).forInRight(); // $ExpectType ObjectChain + _.chain(object).forInRight(objectIterator); // $ExpectType ObjectChain + fp.forInRight(dictionaryIterator2, dictionary); // $ExpectType Dictionary + fp.forInRight(objectIterator2)(object); // $ExpectType AbcObject | null | undefined + + _.forOwn(dictionary); // $ExpectType Dictionary + _.forOwn(dictionary, dictionaryIterator); // $ExpectType Dictionary + _.forOwn(object); // $ExpectType AbcObject | null | undefined + _.forOwn(object, objectIterator); // $ExpectType AbcObject | null | undefined + _(object).forOwn(); // $ExpectType Object + _(object).forOwn(objectIterator); // $ExpectType Object + _.chain(object).forOwn(); // $ExpectType ObjectChain + _.chain(object).forOwn(objectIterator); // $ExpectType ObjectChain + fp.forOwn(dictionaryIterator2, dictionary); // $ExpectType Dictionary + fp.forOwn(objectIterator2)(object); // $ExpectType AbcObject | null | undefined + + _.forOwnRight(dictionary); // $ExpectType Dictionary + _.forOwnRight(dictionary, dictionaryIterator); // $ExpectType Dictionary + _.forOwnRight(object); // $ExpectType AbcObject | null | undefined + _.forOwnRight(object, objectIterator); // $ExpectType AbcObject | null | undefined + _(object).forOwnRight(); // $ExpectType Object + _(object).forOwnRight(objectIterator); // $ExpectType Object + _.chain(object).forOwnRight(); // $ExpectType ObjectChain + _.chain(object).forOwnRight(objectIterator); // $ExpectType ObjectChain + fp.forOwnRight(dictionaryIterator2, dictionary); // $ExpectType Dictionary + fp.forOwnRight(objectIterator2)(object); // $ExpectType AbcObject | null | undefined +} + +// _.functions +// _.functionsIn +{ + _.functions(abcObject); // $ExpectType string[] + _(abcObject).functions(); // $ExpectType Collection + _.chain(abcObject).functions(); // $ExpectType CollectionChain + fp.functions(abcObject); // $ExpectType string[] + + _.functionsIn(abcObject); // $ExpectType string[] + _(abcObject).functionsIn(); // $ExpectType Collection + _.chain(abcObject).functionsIn(); // $ExpectType CollectionChain + fp.functionsIn(abcObject); // $ExpectType string[] +} + +// _.get +{ + const value: string | undefined = anything; + const defaultValue: boolean = anything; + + _.get([], Symbol.iterator); + _.get([], [Symbol.iterator]); + + _.get("abc", 1); // $ExpectType string + _.get("abc", [0], "_"); + _.get([42], 0, -1); // $ExpectType number + _.get({ a: { b: true } }, "a"); // $ExpectType { b: boolean; } + _.get({ a: { b: true } }, ["a"]); // $ExpectType { b: boolean; } + _.get({ a: { b: true } }, ["a", "b"]); // $ExpectType any + _.get({ a: undefined }, "a"); // $ExpectType undefined + _.get({ a: value }, "a", defaultValue); // $ExpectType string | boolean + _.get({ a: undefined }, "a", defaultValue); // $ExpectType boolean + + _("abc").get(1); // $ExpectType string + _("abc").get([0], "_"); + _([42]).get(0, -1); // $ExpectType number + _({ a: { b: true } }).get("a"); // $ExpectType { b: boolean; } + _({ a: { b: true } }).get(["a"]); // $ExpectType { b: boolean; } + _({ a: { b: true } }).get(["a", "b"]); // $ExpectType any + _({ a: undefined }).get("a"); // $ExpectType undefined + _({ a: value }).get("a", defaultValue); // $ExpectType string | boolean + _({ a: undefined }).get("a", defaultValue); // $ExpectType boolean + + _.chain("abc").get(1); // $ExpectType StringChain + _.chain("abc").get([0], "_"); + _.chain([42]).get(0, -1); // ExpectType PrimitiveChain + _.chain({ a: { b: true } }).get("a"); // $ExpectType ObjectChain<{ b: boolean; }> + _.chain({ a: { b: true } }).get(["a"]); // $ExpectType ObjectChain<{ b: boolean; }> + _.chain({ a: { b: true } }).get(["a", "b"]); // $ExpectType LoDashExplicitWrapper + _.chain({ a: undefined }).get("a"); // $ExpectType PrimitiveChain + _.chain({ a: value }).get("a", defaultValue); // $ExpectType StringChain | PrimitiveChain | PrimitiveChain + _.chain({ a: undefined }).get("a", defaultValue); // $ExpectType PrimitiveChain | PrimitiveChain + + fp.get(Symbol.iterator, []); // $ExpectType any + fp.get(Symbol.iterator)([]); // $ExpectType any + fp.get([Symbol.iterator], []); // $ExpectType any + fp.get(1)("abc"); // $ExpectType string + fp.get("1")("abc"); // $ExpectType any + fp.get("a", { a: { b: true } }); // $ExpectType { b: boolean; } + fp.get<{ a: { b: boolean } }, "a">("a")({ a: { b: true } }); // $ExpectType { b: boolean; } + fp.get(["a", "b"])({ a: { b: true } }); // $ExpectType any + fp.get(0)([42]); // $ExpectType number + + fp.getOr(-1, 0, [42]); // $ExpectType number + fp.getOr(-1)(0)([42]); // $ExpectType number + fp.getOr("empty" as "empty")(0)([42]); // $ExpectType number | "empty" +} + +// _.has +// _.hasIn +{ + _.has(abcObject, ""); // $ExpectType boolean + _.has(abcObject, 42); // $ExpectType boolean + _.has(abcObject, ["", 42]); // $ExpectType boolean + _(abcObject).has(""); // $ExpectType boolean + _(abcObject).has(42); // $ExpectType boolean + _(abcObject).has(["", 42]); // $ExpectType boolean + _.chain(abcObject).has(""); // $ExpectType PrimitiveChain + _.chain(abcObject).has(42); // $ExpectType PrimitiveChain + _.chain(abcObject).has(["", 42]); // $ExpectType PrimitiveChain + fp.has("a", abcObject); // $ExpectType boolean + fp.has("a")(abcObject); // $ExpectType boolean + fp.has(["a", 42])(abcObject); // $ExpectType boolean + + _.hasIn(abcObject, ""); // $ExpectType boolean + _.hasIn(abcObject, 42); // $ExpectType boolean + _.hasIn(abcObject, ["", 42]); // $ExpectType boolean + _(abcObject).hasIn(""); // $ExpectType boolean + _(abcObject).hasIn(42); // $ExpectType boolean + _(abcObject).hasIn(["", 42]); // $ExpectType boolean + _.chain(abcObject).hasIn(""); // $ExpectType PrimitiveChain + _.chain(abcObject).hasIn(42); // $ExpectType PrimitiveChain + _.chain(abcObject).hasIn(["", 42]); // $ExpectType PrimitiveChain + fp.hasIn("a", abcObject); // $ExpectType boolean + fp.hasIn("a")(abcObject); // $ExpectType boolean + fp.hasIn(["a", 42])(abcObject); // $ExpectType boolean +} + +// _.invert +{ + _.invert({}); // $ExpectType Dictionary + _({}).invert(); // $ExpectType Object> + _.chain({}).invert(); // $ExpectType ObjectChain> + fp.invert({}); // $ExpectType Dictionary +} + +// _.invertBy +{ + const list: ArrayLike<{ a: number }> = anything; + const dictionary: _.Dictionary<{ a: number }> = {}; + const numericDictionary: _.NumericDictionary<{ a: number }> = {}; + + const valueIterator = (value: {a: number }) => 1; + + _.invertBy("foo"); // $ExpectType Dictionary + _.invertBy("foo", stringIterator); // $ExpectType Dictionary + _.invertBy(list); // $ExpectType Dictionary + _.invertBy(list, "a"); // $ExpectType Dictionary + _.invertBy(list, valueIterator); // $ExpectType Dictionary + _.invertBy(list, {a: 1}); // $ExpectType Dictionary + _.invertBy(dictionary); // $ExpectType Dictionary + _.invertBy(dictionary, "a"); // $ExpectType Dictionary + _.invertBy(dictionary, valueIterator); // $ExpectType Dictionary + _.invertBy(dictionary, {a: 1}); // $ExpectType Dictionary + _.invertBy(numericDictionary); // $ExpectType Dictionary + _.invertBy(numericDictionary, "a"); // $ExpectType Dictionary + _.invertBy(numericDictionary, valueIterator); // $ExpectType Dictionary + _.invertBy(numericDictionary, {a: 1}); // $ExpectType Dictionary + + _("foo").invertBy(stringIterator); // $ExpectType Object> + _(list).invertBy(); // $ExpectType Object> + _(list).invertBy("a"); // $ExpectType Object> + _(dictionary).invertBy(valueIterator); // $ExpectType Object> + _(numericDictionary).invertBy({a: 1}); // $ExpectType Object> + + _.chain("foo").invertBy(stringIterator); // $ExpectType ObjectChain> + _.chain(list).invertBy(); // $ExpectType ObjectChain> + _.chain(list).invertBy("a"); // $ExpectType ObjectChain> + _.chain(dictionary).invertBy(valueIterator); // $ExpectType ObjectChain> + _.chain(numericDictionary).invertBy({a: 1}); // $ExpectType ObjectChain> + + fp.invertBy(stringIterator, "foo"); // $ExpectType Dictionary + fp.invertBy(stringIterator)("foo"); // $ExpectType Dictionary + fp.invertBy(valueIterator)(list); // $ExpectType Dictionary + fp.invertBy("a")(list); // $ExpectType Dictionary + fp.invertBy({ a: 1 })(list); // $ExpectType Dictionary + fp.invertBy(valueIterator)(dictionary); // $ExpectType Dictionary + fp.invertBy("a")(dictionary); // $ExpectType Dictionary + fp.invertBy({ a: 1 })(dictionary); // $ExpectType Dictionary + fp.invertBy(valueIterator)(numericDictionary); // $ExpectType Dictionary + fp.invertBy("a")(numericDictionary); // $ExpectType Dictionary + fp.invertBy({ a: 1 })(numericDictionary); // $ExpectType Dictionary +} + +// _.keys +// _.keysIn +{ + const object: AbcObject | null | undefined = anything; + + _.keys(object); // $ExpectType string[] + _(object).keys(); // $ExpectType Collection + _.chain(object).keys(); // $ExpectType CollectionChain + fp.keys({}); // $ExpectType string[] + + _.keysIn(object); // $ExpectType string[] + _(object).keysIn(); // $ExpectType Collection + _.chain(object).keysIn(); // $ExpectType CollectionChain + fp.keysIn({}); // $ExpectType string[] +} + +// _.mapKeys +{ + const abcObjectIterator = (value: AbcObject[keyof AbcObject], key: string, collection: AbcObject) => ""; + + _.mapKeys(list); // $ExpectType Dictionary + _.mapKeys(list, listIterator); // $ExpectType Dictionary + _.mapKeys(list, ""); // $ExpectType Dictionary + _.mapKeys(list, {}); // $ExpectType Dictionary + + _.mapKeys(dictionary); // $ExpectType Dictionary + _.mapKeys(dictionary, dictionaryIterator); // $ExpectType Dictionary + _.mapKeys(dictionary, ""); // $ExpectType Dictionary + _.mapKeys(dictionary, {}); // $ExpectType Dictionary + + _.mapKeys(numericDictionary); // $ExpectType Dictionary + _.mapKeys(numericDictionary, numericDictionaryIterator); // $ExpectType Dictionary + _.mapKeys(numericDictionary, ""); // $ExpectType Dictionary + _.mapKeys(numericDictionary, {}); // $ExpectType Dictionary + + _.mapKeys(abcObject); // $ExpectType Dictionary + _.mapKeys(abcObject, abcObjectIterator); // $ExpectType Dictionary + _.mapKeys(abcObject, ""); // $ExpectType Dictionary + + _(list).mapKeys(); // $ExpectType Object> + _(list).mapKeys(listIterator); // $ExpectType Object> + _(list).mapKeys(""); // $ExpectType Object> + _(list).mapKeys({}); // $ExpectType Object> + + _(dictionary).mapKeys(); // $ExpectType Object> + _(dictionary).mapKeys(dictionaryIterator); // $ExpectType Object> + _(dictionary).mapKeys(""); // $ExpectType Object> + _(dictionary).mapKeys({}); // $ExpectType Object> + + _(numericDictionary).mapKeys(); // $ExpectType Object> + _(numericDictionary).mapKeys(numericDictionaryIterator); // $ExpectType Object> + _(numericDictionary).mapKeys(""); // $ExpectType Object> + _(numericDictionary).mapKeys({}); // $ExpectType Object> + + _(abcObject).mapKeys(); // $ExpectType Object> + _(abcObject).mapKeys(abcObjectIterator); // $ExpectType Object> + _(abcObject).mapKeys(""); // $ExpectType Object> + + _.chain(list).mapKeys(); // $ExpectType ObjectChain> + _.chain(list).mapKeys(listIterator); // $ExpectType ObjectChain> + _.chain(list).mapKeys(""); // $ExpectType ObjectChain> + _.chain(list).mapKeys({}); // $ExpectType ObjectChain> + + _.chain(dictionary).mapKeys(); // $ExpectType ObjectChain> + _.chain(dictionary).mapKeys(dictionaryIterator); // $ExpectType ObjectChain> + _.chain(dictionary).mapKeys(""); // $ExpectType ObjectChain> + _.chain(dictionary).mapKeys({}); // $ExpectType ObjectChain> + + _.chain(numericDictionary).mapKeys(); // $ExpectType ObjectChain> + _.chain(numericDictionary).mapKeys(numericDictionaryIterator); // $ExpectType ObjectChain> + _.chain(numericDictionary).mapKeys(""); // $ExpectType ObjectChain> + _.chain(numericDictionary).mapKeys({}); // $ExpectType ObjectChain> + + _.chain(abcObject).mapKeys(); // $ExpectType ObjectChain> + _.chain(abcObject).mapKeys(abcObjectIterator); // $ExpectType ObjectChain> + _.chain(abcObject).mapKeys(""); // $ExpectType ObjectChain> + + const indexIterator = (index: number) => index + 1; + const keyIterator = (key: string) => "_" + key; + fp.mapKeys(indexIterator, list); // $ExpectType Dictionary + fp.mapKeys(keyIterator)(dictionary); // $ExpectType Dictionary + fp.mapKeys(keyIterator)(abcObject); // $ExpectType Dictionary +} + +// _.mapValues +{ + const abcObjectOrNull: AbcObject | null = anything; + const key: string = anything; + + // $ExpectType NumericDictionary + _.mapValues("foo", (char, index, str) => { + char; // $ExpectType string + index; // $ExpectType number + str; // $ExpectType string + return abcObject; + }); + + // $ExpectType Dictionary + _.mapValues(dictionary, (value, key, collection) => { + value; // $ExpectType AbcObject + key; // $ExpectType string + collection; // $ExpectType Dictionary + return ""; + }); + + // Can"t really support NumericDictionary fully, but it at least gets treated like a Dictionary + // $ExpectType Dictionary + _.mapValues(numericDictionary, (value, key, collection) => { + value; // $ExpectType AbcObject + key; // $ExpectType string + collection; // $ExpectType Dictionary + return ""; + }); + + // $ExpectType { a: string; b: string; c: string; } + _.mapValues(abcObject, (value, key, collection) => { + value; // $ExpectType string | number | boolean + key; // $ExpectType string + collection; // $ExpectType AbcObject + return ""; + }); + + _.mapValues(dictionary, {}); // $ExpectType Dictionary + // Can"t really support NumericDictionary fully, but it at least gets treated like a Dictionary + _.mapValues(numericDictionary, {}); // $ExpectType Dictionary + _.mapValues(abcObject, {}); // $ExpectType { a: boolean; b: boolean; c: boolean; } + + _.mapValues(dictionary, "a"); // $ExpectType Dictionary + // Can"t really support NumericDictionary fully, but it at least gets treated like a Dictionary + _.mapValues(numericDictionary, "a"); // $ExpectType Dictionary + + _.mapValues(abcObject, key); // $ExpectType { a: any; b: any; c: any; } + _.mapValues(dictionary, key); // $ExpectType Dictionary + // Can"t really support NumericDictionary fully, but it at least gets treated like a Dictionary + _.mapValues(numericDictionary, key); // $ExpectType Dictionary + + _.mapValues("a"); // $ExpectType NumericDictionary + _.mapValues(dictionary); // $ExpectType Dictionary + // Can"t really support NumericDictionary fully, but it at least gets treated like a Dictionary + _.mapValues(numericDictionary); // $ExpectType Dictionary + _.mapValues(abcObject); // $ExpectType AbcObject + _.mapValues(abcObjectOrNull); // $ExpectType Partial + + // $ExpectType Object> + _("foo").mapValues((char, index, str) => { + char; // $ExpectType string + index; // $ExpectType number + str; // $ExpectType string + return abcObject; + }); + + // $ExpectType Object<{ [x: string]: string; }> + _(dictionary).mapValues((value, key, collection) => { + value; // $ExpectType AbcObject + key; // $ExpectType string + collection; // $ExpectType Dictionary + return ""; + }); + + // $ExpectType Object<{ [x: number]: string; }> + _(numericDictionary).mapValues((value, key, collection) => { + value; // $ExpectType AbcObject + key; // $ExpectType string + collection; // $ExpectType NumericDictionary + return ""; + }); + + // $ExpectType Object<{ a: string; b: string; c: string; }> + _(abcObject).mapValues((value, key, collection) => { + value; // $ExpectType string | number | boolean + key; // $ExpectType string + collection; // $ExpectType AbcObject + return ""; + }); + + _(dictionary).mapValues({}); // $ExpectType Object<{ [x: string]: boolean; }> + _(numericDictionary).mapValues({}); // $ExpectType Object<{ [x: number]: boolean; }> + _(abcObject).mapValues({}); // $ExpectType Object<{ a: boolean; b: boolean; c: boolean; }> + + _(dictionary).mapValues("a"); // $ExpectType Object> + // Can"t really support NumericDictionary fully, but it at least gets treated like a Dictionary + _(numericDictionary).mapValues("a"); // $ExpectType Object> + + _(abcObject).mapValues(key); // $ExpectType Object<{ a: any; b: any; c: any; }> + _(dictionary).mapValues(key); // $ExpectType Object<{ [x: string]: any; }> + _(numericDictionary).mapValues(key); // $ExpectType Object<{ [x: number]: any; }> + + _("a").mapValues(); // $ExpectType Object> + _(dictionary).mapValues(); // $ExpectType Object> + _(numericDictionary).mapValues(); // $ExpectType Object> + _(abcObject).mapValues(); // $ExpectType Object + _(abcObjectOrNull).mapValues(); // $ExpectType Object + + // $ExpectType ObjectChain> + _.chain("foo").mapValues((char, index, str) => { + char; // $ExpectType string + index; // $ExpectType number + str; // $ExpectType string + return abcObject; + }); + + // $ExpectType ObjectChain<{ [x: string]: string; }> + _.chain(dictionary).mapValues((value, key, collection) => { + value; // $ExpectType AbcObject + key; // $ExpectType string + collection; // $ExpectType Dictionary + return ""; + }); + + // $ExpectType ObjectChain<{ [x: number]: string; }> + _.chain(numericDictionary).mapValues((value, key, collection) => { + value; // $ExpectType AbcObject + key; // $ExpectType string + collection; // $ExpectType NumericDictionary + return ""; + }); + + // $ExpectType ObjectChain<{ a: string; b: string; c: string; }> + _.chain(abcObject).mapValues((value, key, collection) => { + value; // $ExpectType string | number | boolean + key; // $ExpectType string + collection; // $ExpectType AbcObject + return ""; + }); + + _.chain(dictionary).mapValues({}); // $ExpectType ObjectChain<{ [x: string]: boolean; }> + _.chain(numericDictionary).mapValues({}); // $ExpectType ObjectChain<{ [x: number]: boolean; }> + _.chain(abcObject).mapValues({}); // $ExpectType ObjectChain<{ a: boolean; b: boolean; c: boolean; }> + + _.chain(dictionary).mapValues("a"); // $ExpectType ObjectChain> + // Can"t really support NumericDictionary fully, but it at least gets treated like a Dictionary + _.chain(numericDictionary).mapValues("a"); // $ExpectType ObjectChain> + + _.chain(abcObject).mapValues(key); // $ExpectType ObjectChain<{ a: any; b: any; c: any; }> + _.chain(dictionary).mapValues(key); // $ExpectType ObjectChain<{ [x: string]: any; }> + _.chain(numericDictionary).mapValues(key); // $ExpectType ObjectChain<{ [x: number]: any; }> + + _.chain("a").mapValues(); // $ExpectType ObjectChain> + _.chain(dictionary).mapValues(); // $ExpectType ObjectChain> + _.chain(numericDictionary).mapValues(); // $ExpectType ObjectChain> + + _.chain(abcObject).mapValues(); // $ExpectType ObjectChain + _.chain(abcObjectOrNull).mapValues(); // $ExpectType ObjectChain + + fp.mapValues(valueIterator)(dictionary); // $ExpectType Dictionary + fp.mapValues("a", dictionary); // $ExpectType Dictionary + fp.mapValues(valueIterator)(numericDictionary); // $ExpectType Dictionary + fp.mapValues({ a: 42 })(numericDictionary); // $ExpectType Dictionary + fp.mapValues(value => "", abcObjectOrNull); // $ExpectType { a: string; b: string; c: string; } +} + +// _.omit +{ + const obj: AbcObject | null | undefined = anything; + const dictionary: _.Dictionary = anything; + const numericDictionary: _.NumericDictionary = anything; + + _.omit(obj, "a"); // $ExpectType Pick + _.omit(obj, ["b", 1], 0, "a"); // $ExpectType Partial + _.omit(dictionary, "a"); // $ExpectType Pick, string | number> + _.omit(numericDictionary, "a"); // $ExpectType Partial> + + _(obj).omit("a"); // $ExpectType Object> + _(obj).omit(["b", 1], 0, "a"); // $ExpectType Object> + _(dictionary).omit("a"); // $ExpectType Object, string | number>> + _(numericDictionary).omit(100); // $ExpectType Object, number>> + + _.chain(obj).omit("a"); // $ExpectType ObjectChain> + _.chain(obj).omit(["b", 1], 0, "a"); // $ExpectType ObjectChain> + _.chain(dictionary).omit("a"); // $ExpectType ObjectChain, string | number>> + _.chain(numericDictionary).omit("a"); // $ExpectType ObjectChain>> + + fp.omit("a", obj); // $ExpectType Pick + fp.omit("a")(obj); // $ExpectType Partial + fp.omit(["a", "b"])(obj); // $ExpectType Partial +} + +// _.omitBy +{ + const obj: AbcObject | null | undefined = anything; + const dictionary: _.Dictionary | null | undefined = anything; + const numericDictionary: _.NumericDictionary | null | undefined = anything; + const predicate = (element: string | number | boolean, key: string) => true; + const predicate2 = (element: boolean, key: string) => true; + + _.omitBy(obj, predicate); // $ExpectType Partial + _.omitBy(dictionary, predicate2); // $ExpectType Dictionary + _.omitBy(numericDictionary, predicate2); // $ExpectType NumericDictionary + _(obj).omitBy(predicate); // $ExpectType Object> + _(dictionary).omitBy(predicate2); // $ExpectType Object>> + _(numericDictionary).omitBy(predicate2); // $ExpectType Object>> + _.chain(obj).omitBy(predicate); // $ExpectType ObjectChain> + _.chain(dictionary).omitBy(predicate2); // $ExpectType ObjectChain>> + _.chain(numericDictionary).omitBy(predicate2); // $ExpectType ObjectChain>> + fp.omitBy(predicate, obj); // $ExpectType Partial + fp.omitBy(predicate2)(dictionary); // $ExpectType Dictionary + fp.omitBy(predicate2)(numericDictionary); // $ExpectType NumericDictionary +} + +// _.pick +{ + const obj1: AbcObject | null | undefined = anything; + const obj2: AbcObject = anything; + const readonlyArray: ReadonlyArray = ["a", "b"]; + const literalsArray: Array<"a" | "b"> = ["a", "b"]; + const roLiteralsArray: ReadonlyArray<"a" | "b"> = literalsArray; + + _.pick(obj1, "a"); // $ExpectType PartialDeep + _.pick(obj1, 0, "a"); // $ExpectType PartialDeep + _.pick(obj1, ["b", 1], 0, "a"); // $ExpectType PartialDeep + _.pick(obj1, readonlyArray); // $ExpectType PartialDeep + _.pick(obj2, "a", "b"); // $ExpectType Pick + // We can't use ExpectType here because typescript keeps changing what order the types appear. + let result1: Pick; + result1 = _.pick(obj2, literalsArray); + result1 = _.pick(obj2, roLiteralsArray); + + _(obj1).pick("a"); // $ExpectType Object> + _(obj1).pick(0, "a"); // $ExpectType Object> + _(obj1).pick(["b", 1], 0, "a"); // $ExpectType Object> + _(obj1).pick(readonlyArray); // $ExpectType Object> + _(obj2).pick("a", "b"); // $ExpectType Object> + let result2: _.Object>; + result2 = _(obj2).pick(literalsArray); + result2 = _(obj2).pick(roLiteralsArray); + + _.chain(obj1).pick("a"); // $ExpectType ObjectChain> + _.chain(obj1).pick(0, "a"); // $ExpectType ObjectChain> + _.chain(obj1).pick(["b", 1], 0, "a"); // $ExpectType ObjectChain> + _.chain(obj1).pick(readonlyArray); // $ExpectType ObjectChain> + _.chain(obj2).pick("a", "b"); // $ExpectType ObjectChain> + let result3: _.LoDashExplicitWrapper>; + result3 = _.chain(obj2).pick(literalsArray); + result3 = _.chain(obj2).pick(roLiteralsArray); + + fp.pick("a", obj2); // $ExpectType Pick + fp.pick("a")(obj2); // $ExpectType Pick + result1 = fp.pick(literalsArray)(obj2); +} + +// _.pickBy +{ + const obj: AbcObject | null | undefined = anything; + const dictionary: _.Dictionary | null | undefined = anything; + const numericDictionary: _.NumericDictionary | null | undefined = anything; + const predicate = (element: string | number | boolean, key: string) => true; + const predicate2 = (element: boolean, key: string) => true; + + _.pickBy(obj, predicate); // $ExpectType Partial + _.pickBy(dictionary, predicate2); // $ExpectType Dictionary + _.pickBy(numericDictionary, predicate2); // $ExpectType NumericDictionary + _(obj).pickBy(predicate); // $ExpectType Object> + _(dictionary).pickBy(predicate2); // $ExpectType Object>> + _(numericDictionary).pickBy(predicate2); // $ExpectType Object>> + _.chain(obj).pickBy(predicate); // $ExpectType ObjectChain> + _.chain(dictionary).pickBy(predicate2); // $ExpectType ObjectChain>> + _.chain(numericDictionary).pickBy(predicate2); // $ExpectType ObjectChain>> + fp.pickBy(predicate, obj); // $ExpectType Partial + fp.pickBy(predicate2)(dictionary); // $ExpectType Dictionary + fp.pickBy(predicate2)(numericDictionary); // $ExpectType NumericDictionary + + const mixedDictionary: _.Dictionary | null | undefined = anything; + + const userDefinedTypeGuard = (item: string | number): item is number => typeof item === "number"; + + _.pickBy(mixedDictionary, userDefinedTypeGuard); // $ExpectType Dictionary + _(mixedDictionary).pickBy(userDefinedTypeGuard); // $ExpectType Object> + _.chain(mixedDictionary).pickBy(userDefinedTypeGuard); // $ExpectType ObjectChain> + fp.pickBy(userDefinedTypeGuard)(mixedDictionary); // $ExpectType Dictionary + + const mixedNumericDictionary: _.NumericDictionary | null | undefined = anything; + + _.pickBy(mixedNumericDictionary, userDefinedTypeGuard); // $ExpectType NumericDictionary + _(mixedNumericDictionary).pickBy(userDefinedTypeGuard); // $ExpectType Object> + _.chain(mixedNumericDictionary).pickBy(userDefinedTypeGuard); // $ExpectType ObjectChain> + fp.pickBy(userDefinedTypeGuard)(mixedNumericDictionary); // $ExpectType NumericDictionary +} + +// _.result +{ + _.result("abc", "0"); // $ExpectType string + _.result("abc", 0, "_"); // $ExpectType string + _.result("abc", "0", () => "_"); // $ExpectType string + _.result("abc", ["0"]); // $ExpectType string + _.result("abc", [0], () => "_"); // $ExpectType string + _.result({ a: () => true }, "a"); // $ExpectType boolean + _("abc").result("0"); // $ExpectType string + _("abc").result(0, "_"); // $ExpectType string + _("abc").result("0", () => "_"); // $ExpectType string + _("abc").result(["0"]); // $ExpectType string + _("abc").result([0], () => "_"); // $ExpectType string + _({ a: () => true }).result("a"); // $ExpectType boolean + _.chain("abc").result("0"); // $ExpectType StringChain + _.chain("abc").result(0, "_"); // $ExpectType StringChain + _.chain("abc").result("0", () => "_"); // $ExpectType StringChain + _.chain("abc").result(["0"]); // $ExpectType StringChain + _.chain("abc").result([0], () => "_"); // $ExpectType StringChain + _.chain({ a: () => true }).result("a"); // $ExpectType PrimitiveChain | PrimitiveChain + + fp.result("0", "abc"); // $ExpectType string + fp.result("0")("abc"); // $ExpectType string +} + +// _.set +// _.setWith +{ + interface SampleResult { + a: { + b: number[]; + }; + } + + const object = { a: {} }; + + _.set(object, "a.b[1]", 42); // $ExpectType SampleResult + _.set(object, ["a", "b", 1], 42); // $ExpectType SampleResult + + _(object).set("a.b[1]", 42); // $ExpectType Object + _(object).set(["a", "b", 1], 42); // $ExpectType Object + + _.chain(object).set("a.b[1]", 42); // $ExpectType ObjectChain + _.chain(object).set(["a", "b", 1], 42); // $ExpectType ObjectChain + + fp.set("a", 42, object); // $ExpectType { a: {}; } + fp.set("a.b[1]")(42)(object); // $ExpectType { a: {}; } + fp.set(["a", "b", 1])(42)(object); // $ExpectType { a: {}; } +} +{ + interface SampleResult { + a: { + b: number[]; + }; + } + + const object: SampleResult = { a: { b: [0, 1] } }; + const customizer = (value: any, key: string, object: SampleResult) => 0; + + _.setWith(object, "a.b[1]", 42); // $ExpectType SampleResult + _.setWith(object, "a.b[1]", 42, customizer); // $ExpectType SampleResult + _.setWith(object, ["a", "b", 1], 42, customizer); // $ExpectType SampleResult + + _(object).setWith("a.b[1]", 42); // $ExpectType Object + _(object).setWith("a.b[1]", 42, customizer); // $ExpectType Object + _(object).setWith(["a", "b", 1], 42, customizer); // $ExpectType Object + + _.chain(object).setWith("a.b[1]", 42); // $ExpectType ObjectChain + _.chain(object).setWith("a.b[1]", 42, customizer); // $ExpectType ObjectChain + _.chain(object).setWith(["a", "b", 1], 42, customizer); // $ExpectType ObjectChain + + fp.setWith(customizer, "a", 42, object); // $ExpectType SampleResult + fp.setWith(customizer)("a.b[1]")(42)(object); // $ExpectType SampleResult + fp.setWith(customizer)(["a", "b", 1])(42)(object); // $ExpectType SampleResult +} + +// _.toPairs +// _.toPairsIn +{ + const dictionary: _.Dictionary = {}; + const numericDictionary: _.NumericDictionary = {}; + + _.toPairs(dictionary); // $ExpectType [string, number][] + _.toPairs(numericDictionary); // $ExpectType [string, number][] + _.toPairs(abcObject); // $ExpectType [string, any][] + + _(dictionary).toPairs(); // $ExpectType Collection<[string, number]> + _(numericDictionary).toPairs(); // $ExpectType Collection<[string, number]> + _(abcObject).toPairs(); // $ExpectType Collection<[string, any]> + + _.chain(dictionary).toPairs(); // $ExpectType CollectionChain<[string, number]> + _.chain(numericDictionary).toPairs(); // $ExpectType CollectionChain<[string, number]> + _.chain(abcObject).toPairs(); // $ExpectType CollectionChain<[string, any]> + + fp.toPairs(dictionary); // $ExpectType [string, number][] + + _.toPairsIn(dictionary); // $ExpectType [string, number][] + _.toPairsIn(numericDictionary); // $ExpectType [string, number][] + _.toPairsIn(abcObject); // $ExpectType [string, any][] + + _(dictionary).toPairsIn(); // $ExpectType Collection<[string, number]> + _(numericDictionary).toPairsIn(); // $ExpectType Collection<[string, number]> + _(abcObject).toPairsIn(); // $ExpectType Collection<[string, any]> + + _.chain(dictionary).toPairsIn(); // $ExpectType CollectionChain<[string, number]> + _.chain(numericDictionary).toPairsIn(); // $ExpectType CollectionChain<[string, number]> + _.chain(abcObject).toPairsIn(); // $ExpectType CollectionChain<[string, any]> + + fp.toPairsIn(dictionary); // $ExpectType [string, number][] +} + +// _.transform +{ + const array: number[] = []; + const dictionary: _.Dictionary = {}; + + { + const iterator = (acc: AbcObject[], curr: number, index?: number, arr?: number[]) => {}; + const accumulator: AbcObject[] = []; + + _.transform(array); // $ExpectType any[] + _.transform(array, iterator); // $ExpectType AbcObject[] + _.transform(array, iterator, accumulator); // $ExpectType AbcObject[] + _(array).transform(); // $ExpectType Collection + _(array).transform(iterator); // $ExpectType Collection + _(array).transform(iterator, accumulator); // $ExpectType Collection + _.chain(array).transform(iterator, accumulator); // $ExpectType CollectionChain + } + + { + const iterator = (acc: _.Dictionary, curr: number, index?: number, arr?: number[]) => {}; + const accumulator: _.Dictionary = {}; + + _.transform>(array, iterator, accumulator); // $ExpectType Dictionary + _(array).transform(iterator, accumulator); // $ExpectType Object> + _.chain(array).transform(iterator, accumulator); // $ExpectType ObjectChain> + } + + { + const iterator = (acc: _.Dictionary, curr: number, key?: string, dict?: _.Dictionary) => {}; + const accumulator: _.Dictionary = {}; + + _.transform(dictionary); // $ExpectType Dictionary + _.transform(dictionary, iterator); // $ExpectType Dictionary + _.transform>(dictionary, iterator, accumulator); // $ExpectType Dictionary + _(dictionary).transform(); // $ExpectType Object> + _(dictionary).transform(iterator); // $ExpectType Object> + _(dictionary).transform(iterator, accumulator); // $ExpectType Object> + } + + { + const iterator = (acc: AbcObject[], curr: number, index?: string, dict?: _.Dictionary) => {}; + const accumulator: AbcObject[] = []; + + _.transform(dictionary, iterator, accumulator); // $ExpectType AbcObject[] + _(dictionary).transform(iterator, accumulator); // $ExpectType Collection + _.chain(dictionary).transform(iterator, accumulator); // $ExpectType CollectionChain + } + + { + const iterator = (acc: AbcObject[], curr: number): AbcObject => anything; + const accumulator: AbcObject[] = []; + + fp.transform(iterator, accumulator, array); // $ExpectType AbcObject[] + fp.transform(iterator)(accumulator)(array); // $ExpectType AbcObject[] + fp.transform(iterator)(accumulator)(dictionary); // $ExpectType AbcObject[] + } + + { + const iterator = (acc: _.Dictionary, curr: number): AbcObject => anything; + const accumulator: _.Dictionary = {}; + + fp.transform(iterator)(accumulator)(array); // $ExpectType Dictionary + fp.transform(iterator)(accumulator)(dictionary); // $ExpectType Dictionary + } +} + +// _.unset +{ + const object = { a: { b: "", c: true } }; + + _.unset(object, "a.b"); // $ExpectType boolean + _.unset(object, ["a", "b"]); // $ExpectType boolean + _(object).unset("a.b"); // $ExpectType Primitive + _(object).unset(["a", "b"]); // $ExpectType Primitive + _.chain(object).unset("a.b"); // $ExpectType PrimitiveChain + _.chain(object).unset(["a", "b"]); // $ExpectType PrimitiveChain + + fp.unset("a.b", object); // $ExpectType { a: { b: string; c: boolean; }; } + fp.unset("a.b")(object); // $ExpectType { a: { b: string; c: boolean; }; } + fp.unset(["a", "b"])(object); // $ExpectType { a: { b: string; c: boolean; }; } +} + +// _.update +{ + const object = { a: { b: [0] } }; + const updater = (value: any) => 0; + + _.update(object, "a.b[1]", updater); // $ExpectType any + _.update(object, ["a", "b", 1], updater); // $ExpectType any + _(object).update("a.b[1]", updater); // $ExpectType Object + _(object).update(["a", "b", 1], updater); // $ExpectType Object + _.chain(object).update("a.b[1]", updater); // $ExpectType ObjectChain + _.chain(object).update(["a", "b", 1], updater); // $ExpectType ObjectChain + fp.update("a.b[1]", updater, object); // $ExpectType any + fp.update(["a", "b", 1])(updater)(object); // $ExpectType any +} + +// _.updateWith +{ + interface SampleResult { + a: { + b: number[]; + }; + } + const object: SampleResult = { a: { b: [] } }; + const updater = (value: any) => 0; + const customizer = (value: any, key: string, object: SampleResult) => 0; + + _.updateWith(object, "a.b[1]", updater); // $ExpectType SampleResult + _.updateWith(object, "a.b[1]", updater, customizer); // $ExpectType SampleResult + _.updateWith(object, ["a", "b", 1], updater, customizer); // $ExpectType SampleResult + _(object).updateWith("a.b[1]", updater); // $ExpectType Object + _(object).updateWith("a.b[1]", updater, customizer); // $ExpectType Object + _(object).updateWith(["a", "b", 1], updater, customizer); // $ExpectType Object + _.chain(object).updateWith("a.b[1]", updater, customizer); // $ExpectType ObjectChain + fp.updateWith(customizer, "a.b[1]", updater, object); // $ExpectType SampleResult + fp.updateWith(customizer)(["a", "b", 1])(updater)(object); // $ExpectType SampleResult +} + +// _.values +// _.valuesIn +{ + const dict: _.Dictionary = {}; + const numDict: _.NumericDictionary = {}; + + _.values(123); // $ExpectType any[] + _.values(true); // $ExpectType any[] + _.values("hi"); // $ExpectType string[] + _.values(["h", "i"]); // $ExpectType string[] + _.values([true, false]); // $ExpectType boolean[] + _.values(dict); // $ExpectType AbcObject[] + _.values(numDict); // $ExpectType AbcObject[] + _.values(list); // $ExpectType AbcObject[] + _.values(abcObject); // $ExpectType (string | number | boolean)[] + + // _(true).values(); // $ExpectError + _("hi").values(); // $ExpectType Collection + _(dict).values(); // $ExpectType Collection + + // _.chain(true).values(); // $ExpectError + _.chain("hi").values(); // $ExpectType CollectionChain + _.chain(dict).values(); // $ExpectType CollectionChain + + fp.values("hi"); // $ExpectType string[] + fp.values(["h", "i"]); // $ExpectType string[] + fp.values([true, false]); // $ExpectType boolean[] + fp.values(dict); // $ExpectType AbcObject[] + fp.values(numDict); // $ExpectType AbcObject[] + fp.values(list); // $ExpectType AbcObject[] + fp.values(abcObject); // $ExpectType (string | number | boolean)[] + + _.valuesIn([true, false]); // $ExpectType boolean[] + _.valuesIn(dict); // $ExpectType AbcObject[] + _.valuesIn(numDict); // $ExpectType AbcObject[] + _.valuesIn(list); // $ExpectType AbcObject[] + _.valuesIn(abcObject); // $ExpectType (string | number | boolean)[] + + _(dict).valuesIn(); // $ExpectType Collection + _.chain(dict).valuesIn(); // $ExpectType CollectionChain + + fp.valuesIn(dict); // $ExpectType AbcObject[] + fp.valuesIn(numDict); // $ExpectType AbcObject[] + fp.valuesIn(list); // $ExpectType AbcObject[] + fp.valuesIn(abcObject); // $ExpectType (string | number | boolean)[] +} + +/******* + * Seq * + *******/ + +// _ +{ + _(""); // $ExpectType String + _(42); // $ExpectType Primitive + _(true); // $ExpectType Primitive + _([""]); // $ExpectType Collection + _({ a: "" }); // $ExpectType Object<{ a: string; }> + _(array); // $ExpectType Collection +} + +// _.chain +{ + _.chain(""); // $ExpectType StringChain + _("").chain(); // $ExpectType StringChain + _.chain("").chain(); // $ExpectType StringChain + _.chain(42); // $ExpectType PrimitiveChain + _.chain([""]); // $ExpectType CollectionChain + _.chain({ a: 42 }); // $ExpectType ObjectChain<{ a: number; }> +} + +// _.tap +{ + // $ExpectType string + _.tap("a", (value) => { + value; // $ExpectType string + }); + // $ExpectType boolean[] + _.tap([true], (value) => { + value; // $ExpectType boolean[] + }); + // $ExpectType { a: number; } + _.tap({ a: 42 }, (value) => { + value; // $ExpectType { a: number; } + }); + + // $ExpectType String + _("a").tap((value) => { + value; // $ExpectType string + }); + // $ExpectType Collection + _([true]).tap((value) => { + value; // $ExpectType ArrayLike + }); + // $ExpectType Object<{ a: number; }> + _({ a: 42 }).tap((value) => { + value; // $ExpectType { a: number; } + }); + + // $ExpectType StringChain + _.chain("a").tap((value) => { + value; // $ExpectType string + }); + // $ExpectType CollectionChain + _.chain([true]).tap((value) => { + value; // $ExpectType ArrayLike + }); + // $ExpectType ObjectChain<{ a: number; }> + _.chain({ a: 42 }).tap((value) => { + value; // $ExpectType { a: number; } + }); + + fp.tap((value: string) => {}, "a" as string); // $ExpectType string + fp.tap((value: string) => {})("a"); // $ExpectType string + fp.tap((value: string[]) => {}, ["a"]); // $ExpectType string[] +} + +// _.thru +{ + // $ExpectType number + _.thru("a", (value) => { + value; // $ExpectType string + return 1; + }); + // $ExpectType number + _.thru([true], (value) => { + value; // $ExpectType boolean[] + return 1; + }); + // $ExpectType number + _.thru({ a: 42 }, (value) => { + value; // $ExpectType { a: number; } + return 1; + }); + + // $ExpectType Primitive + _("a").thru((value) => { + value; // $ExpectType string + return 1; + }); + // $ExpectType Primitive + _([true]).thru((value) => { + value; // $ExpectType ArrayLike + return 1; + }); + // $ExpectType Primitive + _({ a: 42 }).thru((value) => { + value; // $ExpectType { a: number; } + return 1; + }); + + // $ExpectType PrimitiveChain + _.chain("a").thru((value) => { + value; // $ExpectType string + return 1; + }); + // $ExpectType PrimitiveChain + _.chain([true]).thru((value) => { + value; // $ExpectType ArrayLike + return 1; + }); + // $ExpectType PrimitiveChain + _.chain({ a: 42 }).thru((value) => { + value; // $ExpectType { a: number; } + return 1; + }); + + fp.thru((x: number) => x.toString(), 1); // $ExpectType string + fp.thru((x: number) => x.toString())(1); // $ExpectType string + fp.thru((x: number[]) => x.toString())([1]); // $ExpectType string +} + +// _.prototype.commit +{ + _(42).commit(); // $ExpectType Primitive + _({ a: 42 }).commit(); // $ExpectType Object<{ a: number; }> + _.chain(42).commit(); // $ExpectType PrimitiveChain + _.chain({ a: 42 }).commit(); // $ExpectType ObjectChain<{ a: number; }> +} + +// _.prototype.concat +{ + const numberROA: ReadonlyArray = [0]; + + _.concat(1); // $ExpectType number[] + _.concat([1]); // $ExpectType number[] + _.concat(numberROA); // $ExpectType number[] + _.concat(1, 2); // $ExpectType number[] + _.concat(1, [1]); // $ExpectType number[] + _.concat(1, [1], numberROA); // $ExpectType number[] + + _(1).concat(2); // $ExpectType Collection + _(1).concat([1]); // $ExpectType Collection + _(1).concat([2], numberROA); // $ExpectType Collection + _([1]).concat(2); // $ExpectType Collection + _(numberROA).concat(numberROA); // $ExpectType Collection + _(numberROA).concat(numberROA, numberROA); // $ExpectType Collection + + _.chain(1).concat(2); // $ExpectType CollectionChain + _.chain(1).concat([1]); // $ExpectType CollectionChain + _.chain(1).concat([2], numberROA); // $ExpectType CollectionChain + _.chain([1]).concat(2); // $ExpectType CollectionChain + _.chain(numberROA).concat(numberROA); // $ExpectType CollectionChain + _.chain(numberROA).concat(numberROA, numberROA); // $ExpectType CollectionChain + + const objectROA: ReadonlyArray = [{ a: 1, b: 'foo', c: true }]; + + _.concat(abcObject, abcObject); // $ExpectType AbcObject[] + _.concat(abcObject, [abcObject], objectROA); // $ExpectType AbcObject[] + + _(abcObject).concat(abcObject); // $ExpectType Collection + _(abcObject).concat([abcObject], objectROA); // $ExpectType Collection + + _.chain(abcObject).concat(abcObject); // $ExpectType CollectionChain + _.chain(abcObject).concat([abcObject], objectROA); // $ExpectType CollectionChain +} + +// _.prototype.plant +{ + _(anything).plant(""); // $ExpectType Collection & Function & Object & Primitive & String + _(anything).plant(42); // $ExpectType Collection & Function & Object & Primitive & String + _(anything).plant([""]); // $ExpectType Collection & Function & Object & Primitive & String + _(anything).plant({ a: 42 }); // $ExpectType Collection & Function & Object & Primitive & String + + _.chain(anything).plant(""); // $ExpectType CollectionChain & FunctionChain & ObjectChain & PrimitiveChain & StringChain + _.chain(anything).plant(42); // $ExpectType CollectionChain & FunctionChain & ObjectChain & PrimitiveChain & StringChain + _.chain(anything).plant([""]); // $ExpectType CollectionChain & FunctionChain & ObjectChain & PrimitiveChain & StringChain + _.chain(anything).plant({ a: 42 }); // $ExpectType CollectionChain & FunctionChain & ObjectChain & PrimitiveChain & StringChain +} + +// _.prototype.reverse +{ + _([42]).reverse(); // $ExpectType Collection + _.chain([42]).reverse(); // $ExpectType CollectionChain +} + +// _.prototype.toString +{ + _('').toString(); // $ExpectType string + _(42).toString(); // $ExpectType string + _([true]).toString(); // $ExpectType string + _({}).toString(); // $ExpectType string + + _.chain('').toString(); // $ExpectType string + _.chain(42).toString(); // $ExpectType string + _.chain([true]).toString(); // $ExpectType string + _.chain({}).toString(); // $ExpectType string +} + +// _.prototype.value +// _.prototype.valueOf +// _.prototype.toJSON +{ + _("").value(); // $ExpectType string + _([true]).value(); // $ExpectType ArrayLike + _({ a: 42 }).value(); // $ExpectType { a: number; } + _({ a: 42 }).valueOf(); // $ExpectType { a: number; } + _({ a: 42 }).toJSON(); // $ExpectType { a: number; } + + _.chain("").value(); // $ExpectType string + _.chain([true]).value(); // $ExpectType ArrayLike + _.chain({ a: 42 }).value(); // $ExpectType { a: number; } + _.chain({ a: 42 }).valueOf(); // $ExpectType { a: number; } + _.chain({ a: 42 }).toJSON(); // $ExpectType { a: number; } +} + +/********** + * String * + **********/ + +// _.camelCase +{ + _.camelCase("Foo Bar"); // $ExpectType string + _("Foo Bar").camelCase(); // $ExpectType string + _.chain("Foo Bar").camelCase(); // $ExpectType StringChain + fp.camelCase("Foo Bar"); // $ExpectType string +} + +// _.capitalize +{ + _.capitalize("fred"); // $ExpectType string + _("fred").capitalize(); // $ExpectType string + _.chain("fred").capitalize(); // $ExpectType StringChain + fp.capitalize("fred"); // $ExpectType string +} + +// _.deburr +{ + _.deburr("déjà vu"); // $ExpectType string + _("déjà vu").deburr(); // $ExpectType string + _.chain("déjà vu").deburr(); // $ExpectType StringChain + fp.deburr("déjà vu"); // $ExpectType string +} + +// _.endsWith +{ + _.endsWith("abc", "c"); // $ExpectType boolean + _.endsWith("abc", "c", 1); // $ExpectType boolean + _("abc").endsWith("c"); // $ExpectType boolean + _("abc").endsWith("c", 1); // $ExpectType boolean + _.chain("abc").endsWith("c"); // $ExpectType PrimitiveChain + _.chain("abc").endsWith("c", 1); // $ExpectType PrimitiveChain + fp.endsWith("c", "abc"); // $ExpectType boolean + fp.endsWith("c")("abc"); // $ExpectType boolean +} + +// _.escape +{ + _.escape("fred, barney, & pebbles"); // $ExpectType string + _("fred, barney, & pebbles").escape(); // $ExpectType string + _.chain("fred, barney, & pebbles").escape(); // $ExpectType StringChain + fp.escape("fred, barney, & pebbles"); // $ExpectType string +} + +// _.escapeRegExp +{ + _.escapeRegExp("[lodash](https://lodash.com/)"); // $ExpectType string + _("[lodash](https://lodash.com/)").escapeRegExp(); // $ExpectType string + _.chain("[lodash](https://lodash.com/)").escapeRegExp(); // $ExpectType StringChain + fp.escapeRegExp("[lodash](https://lodash.com/)"); // $ExpectType string +} + +// _.kebabCase +{ + _.kebabCase("Foo Bar"); // $ExpectType string + _("Foo Bar").kebabCase(); // $ExpectType string + _.chain("Foo Bar").kebabCase(); // $ExpectType StringChain + fp.kebabCase("Foo Bar"); // $ExpectType string +} + +// _.lowerCase +{ + _.lowerCase("Foo Bar"); // $ExpectType string + _("Foo Bar").lowerCase(); // $ExpectType string + _.chain("Foo Bar").lowerCase(); // $ExpectType StringChain + fp.lowerCase("Foo Bar"); // $ExpectType string +} + +// _.lowerFirst +{ + _.lowerFirst("Foo Bar"); // $ExpectType string + _("Foo Bar").lowerFirst(); // $ExpectType string + _.chain("Foo Bar").lowerFirst(); // $ExpectType StringChain + fp.lowerFirst("Foo Bar"); // $ExpectType string +} + +// _.pad +{ + _.pad("abc"); // $ExpectType string + _.pad("abc", 8); // $ExpectType string + _.pad("abc", 8, "_-"); // $ExpectType string + _("abc").pad(); // $ExpectType string + _("abc").pad(8); // $ExpectType string + _("abc").pad(8, "_-"); // $ExpectType string + _.chain("abc").pad(); // $ExpectType StringChain + _.chain("abc").pad(8); // $ExpectType StringChain + _.chain("abc").pad(8, "_-"); // $ExpectType StringChain + fp.pad(8, "abc"); // $ExpectType string + fp.pad(8)("abc"); // $ExpectType string + fp.padChars("_", 8, "abc"); // $ExpectType string + fp.padChars("_")(8)("abc"); // $ExpectType string +} + +// _.padEnd +{ + _.padEnd("abc"); // $ExpectType string + _.padEnd("abc", 6); // $ExpectType string + _.padEnd("abc", 6, "_-"); // $ExpectType string + _("abc").padEnd(); // $ExpectType string + _("abc").padEnd(6); // $ExpectType string + _("abc").padEnd(6, "_-"); // $ExpectType string + _.chain("abc").padEnd(); // $ExpectType StringChain + _.chain("abc").padEnd(6); // $ExpectType StringChain + _.chain("abc").padEnd(6, "_-"); // $ExpectType StringChain + fp.padEnd(8, "abc"); // $ExpectType string + fp.padEnd(8)("abc"); // $ExpectType string + fp.padCharsEnd("_", 8, "abc"); // $ExpectType string + fp.padCharsEnd("_")(8)("abc"); // $ExpectType string +} + +// _.padStart +{ + _.padStart("abc"); // $ExpectType string + _.padStart("abc", 6); // $ExpectType string + _.padStart("abc", 6, "_-"); // $ExpectType string + _("abc").padStart(); // $ExpectType string + _("abc").padStart(6); // $ExpectType string + _("abc").padStart(6, "_-"); // $ExpectType string + _.chain("abc").padStart(); // $ExpectType StringChain + _.chain("abc").padStart(6); // $ExpectType StringChain + _.chain("abc").padStart(6, "_-"); // $ExpectType StringChain + fp.padStart(8, "abc"); // $ExpectType string + fp.padStart(8)("abc"); // $ExpectType string + fp.padCharsStart("_", 8, "abc"); // $ExpectType string + fp.padCharsStart("_")(8)("abc"); // $ExpectType string +} + +// _.parseInt +{ + _.parseInt("08"); // $ExpectType number + _.parseInt("08", 10); // $ExpectType number + _("08").parseInt(); // $ExpectType number + _("08").parseInt(10); // $ExpectType number + _.chain("08").parseInt(); // $ExpectType PrimitiveChain + _.chain("08").parseInt(10); // $ExpectType PrimitiveChain + fp.parseInt(10, "08"); // $ExpectType number + fp.parseInt(10)("08"); // $ExpectType number +} + +// _.repeat +{ + _.repeat("*"); // $ExpectType string + _.repeat("*", 3); // $ExpectType string + _("*").repeat(); // $ExpectType string + _("*").repeat(3); // $ExpectType string + _.chain("*").repeat(); // $ExpectType StringChain + _.chain("*").repeat(3); // $ExpectType StringChain + fp.repeat(3, "*"); // $ExpectType string +} + +// _.replace +{ + const replacer = (match: string, offset: number, string: string) => "Barney"; + + _.replace("Hi Fred", "Fred", "Barney"); // $ExpectType string + _.replace("Hi Fred", "Fred", replacer); // $ExpectType string + _.replace("Hi Fred", /fred/i, "Barney"); // $ExpectType string + _.replace("Hi Fred", /fred/i, replacer); // $ExpectType string + + _("Hi Fred").replace("Fred", "Barney"); // $ExpectType string + _("Hi Fred").replace("Fred", replacer); // $ExpectType string + _("Hi Fred").replace(/fred/i, "Barney"); // $ExpectType string + _("Hi Fred").replace(/fred/i, replacer); // $ExpectType string + + _.chain("Hi Fred").replace("Fred", "Barney"); // $ExpectType StringChain + _.chain("Hi Fred").replace("Fred", replacer); // $ExpectType StringChain + _.chain("Hi Fred").replace(/fred/i, "Barney"); // $ExpectType StringChain + _.chain("Hi Fred").replace(/fred/i, replacer); // $ExpectType StringChain + + fp.replace("Fred", "Barney", "Hi Fred"); // $ExpectType string + fp.replace("Fred")("Barney")("Hi Fred"); // $ExpectType string + fp.replace("Fred")(replacer)("Hi Fred"); // $ExpectType string + fp.replace(/fred/i)("Barney")("Hi Fred"); // $ExpectType string + fp.replace(/fred/i)(replacer)("Hi Fred"); // $ExpectType string +} + +// _.snakeCase +{ + _.snakeCase("Foo Bar"); // $ExpectType string + _("Foo Bar").snakeCase(); // $ExpectType string + _.chain("Foo Bar").snakeCase(); // $ExpectType StringChain + fp.snakeCase("Foo Bar"); // $ExpectType string +} + +// _.split +{ + _.split("a-b-c"); // $ExpectType string[] + _.split("a-b-c", "-"); // $ExpectType string[] + _.split("a-b-c", "-", 2); // $ExpectType string[] + _("a-b-c").split(); // $ExpectType Collection + _("a-b-c").split("-"); // $ExpectType Collection + _("a-b-c").split("-", 2); // $ExpectType Collection + _.chain("a-b-c").split(); // $ExpectType CollectionChain + _.chain("a-b-c").split("-"); // $ExpectType CollectionChain + _.chain("a-b-c").split("-", 2); // $ExpectType CollectionChain + fp.split("-", "a-b-c"); // $ExpectType string[] + fp.split("-")("a-b-c"); // $ExpectType string[] + + _.map(["abc", "def"], _.split); // $ExpectType string[][] +} + +// _.startCase +{ + _.startCase("--foo-bar"); // $ExpectType string + _("--foo-bar").startCase(); // $ExpectType string + _.chain("--foo-bar").startCase(); // $ExpectType StringChain + fp.startCase("--foo-bar"); // $ExpectType string +} + +// _.startsWith +{ + _.startsWith("abc", "a"); // $ExpectType boolean + _.startsWith("abc", "a", 1); // $ExpectType boolean + _("abc").startsWith("a"); // $ExpectType boolean + _("abc").startsWith("a", 1); // $ExpectType boolean + _.chain("abc").startsWith("a"); // $ExpectType PrimitiveChain + _.chain("abc").startsWith("a", 1); // $ExpectType PrimitiveChain + fp.startsWith("a", "abc"); // $ExpectType boolean + fp.startsWith("a")("abc"); // $ExpectType boolean +} + +// _.template +{ + const options: _.TemplateOptions = { + escape: / /, + evaluate: / /, + imports: {}, + interpolate: / /, + sourceURL: "", + variable: "a", + }; + + const result = _.template(""); + result.source; // $ExpectType string + result({}); // $ExpectType string + + _.template(""); // $ExpectType TemplateExecutor + _.template("", options); // $ExpectType TemplateExecutor + _("").template(); // $ExpectType TemplateExecutor + _("").template(options); // $ExpectType TemplateExecutor + _.chain("").template(); // $ExpectType FunctionChain + _.chain("").template(options); // $ExpectType FunctionChain + + const result2 = fp.template(""); + result2(); // $ExpectType string + result2.source; // $ExpectType string +} + +// _.toLower +{ + _.toLower("fred, barney, & pebbles"); // $ExpectType string + _("fred, barney, & pebbles").toLower(); // $ExpectType string + _.chain("fred, barney, & pebbles").toLower(); // $ExpectType StringChain + fp.toLower("fred, barney, & pebbles"); // $ExpectType string +} + +// _.toUpper +{ + _.toUpper("fred, barney, & pebbles"); // $ExpectType string + _("fred, barney, & pebbles").toUpper(); // $ExpectType string + _.chain("fred, barney, & pebbles").toUpper(); // $ExpectType StringChain + fp.toUpper("fred, barney, & pebbles"); // $ExpectType string +} + +// _.trim +{ + _.trim(); // $ExpectType string + _.trim(" abc "); // $ExpectType string + _.trim("-_-abc-_-", "_-"); // $ExpectType string + _("-_-abc-_-").trim(); // $ExpectType string + _("-_-abc-_-").trim("_-"); // $ExpectType string + _.chain("-_-abc-_-").trim(); // $ExpectType StringChain + _.chain("-_-abc-_-").trim("_-"); // $ExpectType StringChain + fp.trim(" abc "); // $ExpectType string + fp.trimChars(" ", " abc "); // $ExpectType string + fp.trimChars(" ")(" abc "); // $ExpectType string + + _.map([" foo ", " bar "], _.trim); // $ExpectType string[] +} + +// _.trimEnd +{ + _.trimEnd(); // $ExpectType string + _.trimEnd(" abc "); // $ExpectType string + _.trimEnd("-_-abc-_-", "_-"); // $ExpectType string + _("-_-abc-_-").trimEnd(); // $ExpectType string + _("-_-abc-_-").trimEnd("_-"); // $ExpectType string + _.chain("-_-abc-_-").trimEnd(); // $ExpectType StringChain + _.chain("-_-abc-_-").trimEnd("_-"); // $ExpectType StringChain + fp.trimEnd(" abc "); // $ExpectType string + fp.trimCharsEnd(" ", " abc "); // $ExpectType string + fp.trimCharsEnd(" ")(" abc "); // $ExpectType string +} + +// _.trimStart +{ + _.trimStart(); // $ExpectType string + _.trimStart(" abc "); // $ExpectType string + _.trimStart("-_-abc-_-", "_-"); // $ExpectType string + _("-_-abc-_-").trimStart(); // $ExpectType string + _("-_-abc-_-").trimStart("_-"); // $ExpectType string + _.chain("-_-abc-_-").trimStart(); // $ExpectType StringChain + _.chain("-_-abc-_-").trimStart("_-"); // $ExpectType StringChain + fp.trimStart(" abc "); // $ExpectType string + fp.trimCharsStart(" ", " abc "); // $ExpectType string + fp.trimCharsStart(" ")(" abc "); // $ExpectType string +} + +// _.truncate +{ + _.truncate("hi-diddly-ho there, neighborino"); // $ExpectType string + _.truncate("hi-diddly-ho there, neighborino", { length: 24, separator: " " }); // $ExpectType string + _.truncate("hi-diddly-ho there, neighborino", { length: 24, separator: /,? +/ }); // $ExpectType string + _.truncate("hi-diddly-ho there, neighborino", { omission: " […]" }); // $ExpectType string + + _("hi-diddly-ho there, neighborino").truncate(); // $ExpectType string + _("hi-diddly-ho there, neighborino").truncate({ length: 24, separator: " " }); // $ExpectType string + _("hi-diddly-ho there, neighborino").truncate({ length: 24, separator: /,? +/ }); // $ExpectType string + _("hi-diddly-ho there, neighborino").truncate({ omission: " […]" }); // $ExpectType string + + _.chain("hi-diddly-ho there, neighborino").truncate(); // $ExpectType StringChain + _.chain("hi-diddly-ho there, neighborino").truncate({ length: 24, separator: " " }); // $ExpectType StringChain + _.chain("hi-diddly-ho there, neighborino").truncate({ length: 24, separator: /,? +/ }); // $ExpectType StringChain + _.chain("hi-diddly-ho there, neighborino").truncate({ omission: " […]" }); // $ExpectType StringChain + + fp.truncate({ length: 24, separator: " " }, "hi-diddly-ho there, neighborino"); // $ExpectType string + fp.truncate({ length: 24, separator: " " })("hi-diddly-ho there, neighborino"); // $ExpectType string + fp.truncate({ length: 24, separator: /,? +/ }, "hi-diddly-ho there, neighborino"); // $ExpectType string + fp.truncate({ omission: " […]" }, "hi-diddly-ho there, neighborino"); // $ExpectType string +} + +// _.unescape +{ + _.unescape("fred, barney, & pebbles"); // $ExpectType string + _("fred, barney, & pebbles").unescape(); // $ExpectType string + _.chain("fred, barney, & pebbles").unescape(); // $ExpectType StringChain + fp.unescape("fred, barney, & pebbles"); // $ExpectType string +} + +// _.upperCase +{ + _.upperCase("fred, barney, & pebbles"); // $ExpectType string + _("fred, barney, & pebbles").upperCase(); // $ExpectType string + _.chain("fred, barney, & pebbles").upperCase(); // $ExpectType StringChain + fp.upperCase("fred, barney, & pebbles"); // $ExpectType string +} + +// _.upperFirst +{ + _.upperFirst("fred, barney, & pebbles"); // $ExpectType string + _("fred, barney, & pebbles").upperFirst(); // $ExpectType string + _.chain("fred, barney, & pebbles").upperFirst(); // $ExpectType StringChain + fp.upperFirst("fred, barney, & pebbles"); // $ExpectType string +} + +// _.words +{ + _.words("fred, barney, & pebbles"); // $ExpectType string[] + _.words("fred, barney, & pebbles", /[^, ]+/g); // $ExpectType string[] + _("fred, barney, & pebbles").words(); // $ExpectType string[] + _("fred, barney, & pebbles").words(/[^, ]+/g); // $ExpectType string[] + _.chain("fred, barney, & pebbles").words(); // $ExpectType CollectionChain + _.chain("fred, barney, & pebbles").words(/[^, ]+/g); // $ExpectType CollectionChain + fp.words("fred, barney, & pebbles"); // $ExpectType string[] + + _.map(["fred, barney", "pebbles"], _.words); // $ExpectType string[][] +} + +/******** + * Util * + ********/ + +// _.attempt +{ + const func = (...args: any[]): AbcObject => anything; + + // We can't use ExpectType here because typescript keeps changing what order the types appear. + let result: Error | AbcObject; + result = _.attempt(func); + result = _.attempt(func, "foo", "bar", "baz"); + result = _(func).attempt(); + result = _(func).attempt("foo", "bar", "baz"); + + let explicitResult: _.ObjectChain | _.ObjectChain; + explicitResult = _.chain(func).attempt(); + explicitResult = _.chain(func).attempt("foo", "bar", "baz"); + + result = fp.attempt(func); +} + +// _.cond +{ + const pairPred1 = (val: string) => true; + const pairPred2 = (val: string) => false; + const pairRes1 = (val: string) => 1; + const pairRes2 = (val: string) => 2; + + _.cond([[pairPred1, pairRes1], [pairPred2, pairRes2]])("hello"); // $ExpectType number + fp.cond([[pairPred1, pairRes1], [pairPred2, pairRes2]])("hello"); // $ExpectType number +} + +// _.constant +{ + _.constant(42); // $ExpectType () => number + _.constant("a"); // $ExpectType () => string + _.constant([true]); // $ExpectType () => boolean[] + _.constant({ a: "" }); // $ExpectType () => { a: string; } + + _(42).constant(); // $ExpectType Function<() => number> + _("a").constant(); // $ExpectType Function<() => string> + _([true]).constant(); // $ExpectType Function<() => ArrayLike> + _({ a: "" }).constant(); // $ExpectType Function<() => { a: string; }> + + _.chain(42).constant(); // $ExpectType FunctionChain<() => number> + _.chain("a").constant(); // $ExpectType FunctionChain<() => string> + _.chain([true]).constant(); // $ExpectType FunctionChain<() => ArrayLike> + _.chain({ a: "" }).constant(); // $ExpectType FunctionChain<() => { a: string; }> + + fp.constant(42); // $ExpectType () => number + fp.constant("a"); // $ExpectType () => string + fp.constant([true]); // $ExpectType () => boolean[] + fp.constant({ a: "" }); // $ExpectType () => { a: string; } +} + +// _.defaultTo +{ + _.defaultTo(42, 42); // $ExpectType 42 + _.defaultTo(undefined, 42); // $ExpectType 42 + _.defaultTo(null, 42); // $ExpectType 42 + _.defaultTo(NaN, 42); // $ExpectType number + _.defaultTo(undefined, "default"); // $ExpectType "default" + _.defaultTo(undefined, [true]); // $ExpectType boolean[] + _.defaultTo(undefined, { a: "" }); // $ExpectType { a: string; } + + _(42).defaultTo(42); // $ExpectType number + _(undefined).defaultTo(42); // $ExpectType 42 + _(null).defaultTo(42); // $ExpectType 42 + _(NaN).defaultTo(42); // $ExpectType number + _(undefined).defaultTo("default"); // $ExpectType "default" + _(undefined).defaultTo([true]); // $ExpectType boolean[] + _(undefined).defaultTo({ a: "" }); // $ExpectType { a: string; } + + _.chain(42).defaultTo(42); // $ExpectType PrimitiveChain + const z1: _.PrimitiveChain = _.chain(undefined).defaultTo(42); + const z2: _.PrimitiveChain = _.chain(null).defaultTo(42); + _.chain(NaN).defaultTo(42); // $ExpectType PrimitiveChain + const z3: _.LoDashExplicitWrapper = _.chain(undefined).defaultTo("default"); + _.chain(undefined).defaultTo([true]); // $ExpectType CollectionChain + _.chain(undefined).defaultTo({ a: "" }); // $ExpectType ObjectChain<{ a: string; }> + + const n: number = anything; + fp.defaultTo(42, n); // $ExpectType number + fp.defaultTo(42)(n); // $ExpectType number + fp.defaultTo(42)(undefined); // $ExpectType number + fp.defaultTo(42)(null); // $ExpectType number + fp.defaultTo(42)(NaN); // $ExpectType number + + const arr: boolean[] | undefined = anything; + const result: boolean[] | "a" = fp.defaultTo("a", arr); +} + +// _.identity +{ + _.identity(42); // $ExpectType 42 + _.identity([""]); // $ExpectType string[] + _.identity({ a: true }); // $ExpectType { a: boolean; } + _(42).identity(); // $ExpectType number + _([""]).identity(); // $ExpectType ArrayLike + _({ a: true }).identity(); // $ExpectType { a: boolean; } + _.chain(42).identity(); // $ExpectType PrimitiveChain + _.chain([""]).identity(); // $ExpectType CollectionChain + _.chain({ a: true }).identity(); // $ExpectType ObjectChain<{ a: boolean; }> + fp.identity(42); // $ExpectType 42 + fp.identity([""]); // $ExpectType string[] + fp.identity({ a: true }); // $ExpectType { a: boolean; } +} + +// _.iteratee +{ + _.iteratee((a: AbcObject): boolean => anything); // $ExpectType (a: AbcObject) => boolean + _.iteratee((...args: any[]): AbcObject => anything); // $ExpectType (...args: any[]) => AbcObject + _.iteratee("a"); // $ExpectType (...args: any[]) => any + _.iteratee({ a: 42 }); // $ExpectType (...args: any[]) => any + _.iteratee(["a", 42]); // $ExpectType (...args: any[]) => any + + _((a: AbcObject): boolean => anything).iteratee(); // $ExpectType Function<(a: AbcObject) => boolean> + _("a").iteratee(); // $ExpectType Function<(o: object) => any> + _({ a: 42 }).iteratee(); // $ExpectType Function<(o: { a: number; }) => boolean> + _(["a", 42]).iteratee(); // $ExpectType Function<(o: object) => boolean> + + _.chain((a: AbcObject): boolean => anything).iteratee(); // $ExpectType FunctionChain<(a: AbcObject) => boolean> + _.chain("a").iteratee(); // $ExpectType FunctionChain<(o: object) => any> + _.chain({ a: 42 }).iteratee(); // $ExpectType FunctionChain<(o: { a: number; }) => boolean> + _.chain(["a", 42]).iteratee(); // $ExpectType FunctionChain<(o: object) => boolean> + + fp.iteratee((a: AbcObject): boolean => anything); // $ExpectType (a: AbcObject) => boolean + fp.iteratee((...args: any[]): AbcObject => anything); // $ExpectType (...args: any[]) => AbcObject + fp.iteratee(""); // $ExpectType (...args: any[]) => any + fp.iteratee({ a: 42 }); // $ExpectType (...args: any[]) => any + fp.iteratee(["a", 42]); // $ExpectType (...args: any[]) => any +} + +// _.matches +{ + _.matches(abcObject); // $ExpectType (value: any) => boolean + _.matches(abcObject); // $ExpectType (value: AbcObject) => boolean + _(abcObject).matches(); // $ExpectType Function<(value: AbcObject) => boolean> + _.chain(abcObject).matches(); // $ExpectType FunctionChain<(value: AbcObject) => boolean> + + fp.matches(abcObject, {}); // $ExpectType boolean + fp.matches(abcObject)({}); // $ExpectType boolean +} + +// _.matchesProperty +{ + const path: string | string[] = anything; + + _.matchesProperty(path, abcObject); // $ExpectType (value: any) => boolean + _.matchesProperty(path, abcObject); // $ExpectType (value: AbcObject) => boolean + _(path).matchesProperty(abcObject); // $ExpectType Function<(value: any) => boolean> + _(path).matchesProperty(abcObject); + _.chain(path).matchesProperty(abcObject); // $ExpectType FunctionChain<(value: any) => boolean> + fp.matchesProperty(path, abcObject); // $ExpectType (value: any) => boolean +} + +// _.method +{ + _.method("a.0"); // $ExpectType (object: any) => any + _.method("a.0", anything, anything, anything); // $ExpectType (object: any) => any + _.method(["a", 0]); // $ExpectType (object: any) => any + _.method(["a", 0], anything, anything, anything); // $ExpectType (object: any) => any + + _("a.0").method(); // $ExpectType Function<(object: any) => any> + _("a.0").method(anything, anything, anything); // $ExpectType Function<(object: any) => any> + _(["a", 0]).method(); // $ExpectType Function<(object: any) => any> + _(["a", 0]).method(anything, anything, anything); // $ExpectType Function<(object: any) => any> + + _.chain("a.0").method(); // $ExpectType FunctionChain<(object: any) => any> + _.chain("a.0").method(anything, anything, anything); // $ExpectType FunctionChain<(object: any) => any> + _.chain(["a", 0]).method(); // $ExpectType FunctionChain<(object: any) => any> + _.chain(["a", 0]).method(anything, anything, anything); // $ExpectType FunctionChain<(object: any) => any> + + fp.method("a.0"); // $ExpectType (object: any) => any + fp.method(["a", 0]); // $ExpectType (object: any) => any + fp.method(Symbol.replace); // $ExpectType (object: any) => any +} + +// _.methodOf +{ + _.methodOf(abcObject) as (path: _.Many<_.PropertyName>) => any; + _.methodOf(abcObject, anything, anything, anything) as (path: _.Many<_.PropertyName>) => any; + _(abcObject).methodOf() as _.LoDashImplicitWrapper<(path: _.Many<_.PropertyName>) => any>; + _(abcObject).methodOf(anything, anything, anything) as _.LoDashImplicitWrapper<(path: _.Many<_.PropertyName>) => any>; + _.chain(abcObject).methodOf() as _.LoDashExplicitWrapper<(path: _.Many<_.PropertyName>) => any>; + _.chain(abcObject).methodOf(anything, anything, anything) as _.LoDashExplicitWrapper<(path: _.Many<_.PropertyName>) => any>; + fp.methodOf(abcObject) as (path: _.Many<_.PropertyName>) => any; +} + +// _.mixin +{ + const source: _.Dictionary<(...args: any[]) => any> = {}; + const dest: AbcObject = anything; + const options: {chain?: boolean} = {}; + + _.mixin(source); // $ExpectType LoDashStatic + _.mixin(source, options); // $ExpectType LoDashStatic + _.mixin(dest, source); // $ExpectType AbcObject + _.mixin(dest, source, options); // $ExpectType AbcObject + + _(source).mixin(); // $ExpectType LoDashImplicitWrapper + _(source).mixin(options); // $ExpectType LoDashImplicitWrapper + _(dest).mixin(source); // $ExpectType Object + _(dest).mixin(source, options); // $ExpectType Object + + _.chain(source).mixin(); // $ExpectType LoDashExplicitWrapper + _.chain(source).mixin(options); // $ExpectType LoDashExplicitWrapper + _.chain(dest).mixin(source); // $ExpectType ObjectChain + _.chain(dest).mixin(source, options); // $ExpectType ObjectChain +} + +// _.noConflict +{ + _.noConflict(); // $ExpectType LoDashStatic + _(42).noConflict(); // $ExpectType LoDashStatic + _.chain(42).noConflict(); // $ExpectType LoDashExplicitWrapper + fp.noConflict(); // $ExpectType LoDashFp +} + +// _.noop +{ + _.noop(); // $ExpectType void + _.noop(1); // $ExpectType void + _.noop(true, "a", 1); // $ExpectType void + _("a").noop(true, "a", 1); // $ExpectType void + _.chain("a").noop(true, "a", 1); // $ExpectType PrimitiveChain + + fp.noop(); // $ExpectType void + fp.noop(1); // $ExpectType void + fp.noop(true, "a", 1); // $ExpectType void +} + +{ + _.nthArg(); // $ExpectType (...args: any[]) => any + _.nthArg(1); // $ExpectType (...args: any[]) => any + _(1).nthArg(); // $ExpectType Function<(...args: any[]) => any> + _.chain(1).nthArg(); // $ExpectType FunctionChain<(...args: any[]) => any> + fp.nthArg(1); // $ExpectType (...args: any[]) => any +} + +// _.over +{ + _.over(Math.max); // $ExpectType (...args: any[]) => number[] + _.over(Math.max, Math.min); // $ExpectType (...args: any[]) => number[] + _.over([Math.max]); // $ExpectType (...args: any[]) => number[] + _.over([Math.max], [Math.min]); // $ExpectType (...args: any[]) => number[] + + _(Math.max).over(); // $ExpectType Function<(...args: any[]) => number[]> + _(Math.max).over(Math.min); // $ExpectType Function<(...args: any[]) => number[]> + _([Math.max]).over(); // $ExpectType Function<(...args: any[]) => number[]> + _([Math.max]).over([Math.min]); // $ExpectType Function<(...args: any[]) => number[]> + + _.chain(Math.max).over(); // $ExpectType FunctionChain<(...args: any[]) => number[]> + _.chain(Math.max).over(Math.min); // $ExpectType FunctionChain<(...args: any[]) => number[]> + _.chain([Math.max]).over(); // $ExpectType FunctionChain<(...args: any[]) => number[]> + _.chain([Math.max]).over([Math.min]); // $ExpectType FunctionChain<(...args: any[]) => number[]> + + fp.over(Math.max); // $ExpectType (...args: any[]) => number[] + fp.over([Math.max, Math.min]); // $ExpectType (...args: any[]) => number[] +} + +// _.overEvery +// _.overSome +{ + _.overEvery((number: number) => true); // $ExpectType (...args: number[]) => boolean + _.overEvery((number: number) => true, (number: number) => true); // $ExpectType (...args: number[]) => boolean + _.overEvery([(number: number) => true]); // $ExpectType (...args: number[]) => boolean + _.overEvery([(number: number) => true], [(number: number) => true]); // $ExpectType (...args: number[]) => boolean + + _(Math.max).overEvery(); // $ExpectType Function<(...args: number[]) => boolean> + _(Math.max).overEvery((number: number) => true); // $ExpectType Function<(...args: number[]) => boolean> + _([Math.max]).overEvery([(number: number) => true]); // $ExpectType Function<(...args: number[]) => boolean> + + _.chain(Math.max).overEvery(); // $ExpectType FunctionChain<(...args: number[]) => boolean> + _.chain(Math.max).overEvery((number: number) => true); // $ExpectType FunctionChain<(...args: number[]) => boolean> + _.chain([Math.max]).overEvery([(number: number) => true]); // $ExpectType FunctionChain<(...args: number[]) => boolean> + + fp.overEvery((number: number) => true); // $ExpectType (...args: number[]) => boolean + fp.overEvery([(number: number) => true, (number: number) => true]); // $ExpectType (...args: number[]) => boolean + + _.overSome((number: number) => true); // $ExpectType (...args: number[]) => boolean + _.overSome((number: number) => true, (number: number) => true); // $ExpectType (...args: number[]) => boolean + _.overSome([(number: number) => true]); // $ExpectType (...args: number[]) => boolean + _.overSome([(number: number) => true], [(number: number) => true]); // $ExpectType (...args: number[]) => boolean + + _(Math.max).overSome(); // $ExpectType Function<(...args: number[]) => boolean> + _(Math.max).overSome((number: number) => true); // $ExpectType Function<(...args: number[]) => boolean> + _([Math.max]).overSome([(number: number) => true]); // $ExpectType Function<(...args: number[]) => boolean> + + _.chain(Math.max).overSome(); // $ExpectType FunctionChain<(...args: number[]) => boolean> + _.chain(Math.max).overSome((number: number) => true); // $ExpectType FunctionChain<(...args: number[]) => boolean> + _.chain([Math.max]).overSome([(number: number) => true]); // $ExpectType FunctionChain<(...args: number[]) => boolean> + + fp.overSome((number: number) => true); // $ExpectType (...args: number[]) => boolean + fp.overSome([(number: number) => true, (number: number) => true]); // $ExpectType (...args: number[]) => boolean +} + +// _.property +{ + interface SampleObject { + a: { + b: number[]; + }; + } + + _.property("a.b[0]"); // $ExpectType (obj: SampleObject) => number + _.property(["a", "b", 0]); // $ExpectType (obj: SampleObject) => number + _("a.b[0]").property(); // $ExpectType Function<(obj: SampleObject) => number> + _(["a", "b", 0]).property(); // $ExpectType Function<(obj: SampleObject) => number> + _.chain("a.b[0]").property(); // $ExpectType FunctionChain<(obj: SampleObject) => number> + _.chain(["a", "b", 0]).property(); // $ExpectType FunctionChain<(obj: SampleObject) => number> + fp.property(Symbol.iterator)([]); // $ExpectType any + fp.property([Symbol.iterator], []); // $ExpectType any + fp.property(1)("abc"); // $ExpectType string +} + +// _.propertyOf +{ + _.propertyOf({}) as (path: _.Many<_.PropertyName>) => any; + _({}).propertyOf() as _.LoDashImplicitWrapper<(path: _.Many<_.PropertyName>) => any>; + _.chain({}).propertyOf() as _.LoDashExplicitWrapper<(path: _.Many<_.PropertyName>) => any>; + + fp.propertyOf(Symbol.iterator)([]); // $ExpectType any + fp.propertyOf([Symbol.iterator], []); // $ExpectType any + fp.propertyOf(1)("abc"); // $ExpectType string +} + +// _.range +// _.rangeRight +{ + _.range(10); // $ExpectType number[] + _.range(1, 11); // $ExpectType number[] + _.range(0, 30, 5); // $ExpectType number[] + _(10).range(); // $ExpectType Collection + _(1).range(11); // $ExpectType Collection + _(0).range(30, 5); // $ExpectType Collection + _.chain(10).range(); // $ExpectType CollectionChain + _.chain(1).range(11); // $ExpectType CollectionChain + _.chain(0).range(30, 5); // $ExpectType CollectionChain + fp.range(1, 11); // $ExpectType number[] + fp.range(1)(11); // $ExpectType number[] + + _.rangeRight(10); // $ExpectType number[] + _.rangeRight(1, 11); // $ExpectType number[] + _.rangeRight(0, 30, 5); // $ExpectType number[] + _(10).rangeRight(); // $ExpectType Collection + _(1).rangeRight(11); // $ExpectType Collection + _(0).rangeRight(30, 5); // $ExpectType Collection + _.chain(10).rangeRight(); // $ExpectType CollectionChain + _.chain(1).rangeRight(11); // $ExpectType CollectionChain + _.chain(0).rangeRight(30, 5); // $ExpectType CollectionChain + fp.rangeRight(1, 11); // $ExpectType number[] + fp.rangeRight(1)(11); // $ExpectType number[] + + _.map([5, 5], _.range); // $ExpectType number[][] + _.map([5, 5], _.rangeRight); // $ExpectType number[][] +} + +// _.runInContext +{ + _.runInContext(); // $ExpectType LoDashStatic + _.runInContext({}); // $ExpectType LoDashStatic + _({}).runInContext(); // $ExpectType LoDashStatic + fp.runInContext({}); // $ExpectType LoDashStatic +} + +// _.stubArray +{ + _.stubArray(); // $ExpectType any[] + _(anything).stubArray(); // $ExpectType any[] + _.chain(anything).stubArray(); // $ExpectType CollectionChain + fp.stubArray(); // $ExpectType any[] +} + +// _.stubFalse +{ + _.stubFalse(); // $ExpectType false + _(anything).stubFalse(); // $ExpectType false + _.chain(anything).stubFalse(); // $ExpectType PrimitiveChain + fp.stubFalse(); // $ExpectType false +} + +// _.stubObject +{ + _.stubObject(); // $ExpectType any + _(anything).stubObject(); // $ExpectType any + _.chain(anything).stubObject(); // $ExpectType LoDashExplicitWrapper + fp.stubObject(); // $ExpectType any +} + +// _.stubString +{ + _.stubString(); // $ExpectType string + _(anything).stubString(); // $ExpectType string + _.chain(anything).stubString(); // $ExpectType StringChain + fp.stubString(); // $ExpectType string +} + +// _.stubTrue +{ + _.stubTrue(); // $ExpectType true + _(anything).stubTrue(); // $ExpectType true + _.chain(anything).stubTrue(); // $ExpectType PrimitiveChain + fp.stubTrue(); // $ExpectType true +} + +// _.times +{ + const iteratee = (num: number): AbcObject => ({ a: 1, b: "", c: true }); + + _.times(42); // $ExpectType number[] + _.times(42, iteratee); // $ExpectType AbcObject[] + _(42).times(); // $ExpectType number[] + _(42).times(iteratee); // $ExpectType AbcObject[] + _.chain(42).times(); // $ExpectType CollectionChain + _.chain(42).times(iteratee); // $ExpectType CollectionChain + fp.times(iteratee, 42); // $ExpectType AbcObject[] + fp.times(iteratee)(42); // $ExpectType AbcObject[] +} + +// _.toPath +{ + _.toPath(1); // $ExpectType string[] + _.toPath("a[0].b.c"); // $ExpectType string[] + _.toPath(["a", 1]); // $ExpectType string[] + _(1).toPath(); // $ExpectType Collection + _("a[0].b.c").toPath(); // $ExpectType Collection + _(["a", 1]).toPath(); // $ExpectType Collection + _.chain(1).toPath(); // $ExpectType CollectionChain + _.chain("a[0].b.c").toPath(); // $ExpectType CollectionChain + _.chain(["a", 1]).toPath(); // $ExpectType CollectionChain + fp.toPath(true); // $ExpectType string[] + fp.toPath(1); // $ExpectType string[] + fp.toPath("a"); // $ExpectType string[] + fp.toPath(["a"]); // $ExpectType string[] + fp.toPath({}); // $ExpectType string[] +} + +// _.uniqueId +{ + _.uniqueId(); // $ExpectType string + _.uniqueId(""); // $ExpectType string + _("").uniqueId(); // $ExpectType string + _.chain("").uniqueId(); // $ExpectType StringChain + fp.uniqueId(""); // $ExpectType string +} + +_.VERSION; // $ExpectType string +_.templateSettings; // $ExpectType TemplateSettings + +// _.partial & _.partialRight +{ + const func0 = (): number => { + return 42; + }; + const func1 = (arg1: number): number => { + return arg1 * 2; + }; + const func2 = (arg1: number, arg2: string): number => { + return arg1 * arg2.length; + }; + const func3 = (arg1: number, arg2: string, arg3: boolean): number => { + return arg1 * arg2.length + (arg3 ? 1 : 0); + }; + + // with arity 0 function + _.partial(func0); // $ExpectType () => number + // with arity 1 function + _.partial(func1, 42); // $ExpectType () => number + _.partial(func1); // $ExpectType (arg1: number) => number + // with arity 2 function + _.partial(func2); // $ExpectType (arg1: number, arg2: string) => number + _.partial(func2, 42); // $ExpectType (arg2: string) => number + _.partial(func2, _, "foo"); // $ExpectType Function1 + _.partial(func2, _.partial.placeholder, "foo"); // $ExpectType Function1 + _.partial(func2, 42, "foo"); // $ExpectType () => number + // with arity 3 function + _.partial(func3, 42, _, true); + + // with arity 0 function + _.partialRight(func0); // $ExpectType Function0 + // with arity 1 function + _.partialRight(func1, 42); // $ExpectType Function0 + _.partialRight(func1); // $ExpectType Function1 + // with arity 2 function + _.partialRight(func2); // $ExpectType Function2 + _.partialRight(func2, 42, _); // $ExpectType Function1 + _.partialRight(func2, 42, _.partialRight.placeholder); // $ExpectType Function1 + _.partialRight(func2, "foo"); // $ExpectType Function1 + _.partialRight(func2, 42, "foo"); // $ExpectType Function0 + // with arity 3 function + _.partialRight(func3, 42, _, true); + + fp.partial(func1, [42]); // $ExpectType () => number + fp.partial<[], number, number>(func1)([42]); // $ExpectType () => number + fp.partial(func2)([fp.partial.placeholder, "foo"]); // $ExpectType Function1 + fp.partialRight(func1, [42]); // $ExpectType Function0 + fp.partialRight(func1)([42]); // $ExpectType Function0 + fp.partialRight(func2)([42, fp.partialRight.placeholder]); // $ExpectType Function1 +} diff --git a/types/lodash/ts3.1/lowerCase.d.ts b/types/lodash/ts3.1/lowerCase.d.ts new file mode 100644 index 0000000000..475297d8cf --- /dev/null +++ b/types/lodash/ts3.1/lowerCase.d.ts @@ -0,0 +1,2 @@ +import { lowerCase } from "./index"; +export = lowerCase; diff --git a/types/lodash/ts3.1/lowerFirst.d.ts b/types/lodash/ts3.1/lowerFirst.d.ts new file mode 100644 index 0000000000..0836228fcc --- /dev/null +++ b/types/lodash/ts3.1/lowerFirst.d.ts @@ -0,0 +1,2 @@ +import { lowerFirst } from "./index"; +export = lowerFirst; diff --git a/types/lodash/ts3.1/lt.d.ts b/types/lodash/ts3.1/lt.d.ts new file mode 100644 index 0000000000..92cd4e26f8 --- /dev/null +++ b/types/lodash/ts3.1/lt.d.ts @@ -0,0 +1,2 @@ +import { lt } from "./index"; +export = lt; diff --git a/types/lodash/ts3.1/lte.d.ts b/types/lodash/ts3.1/lte.d.ts new file mode 100644 index 0000000000..7c80f37c01 --- /dev/null +++ b/types/lodash/ts3.1/lte.d.ts @@ -0,0 +1,2 @@ +import { lte } from "./index"; +export = lte; diff --git a/types/lodash/ts3.1/map.d.ts b/types/lodash/ts3.1/map.d.ts new file mode 100644 index 0000000000..2f783cb7f5 --- /dev/null +++ b/types/lodash/ts3.1/map.d.ts @@ -0,0 +1,2 @@ +import { map } from "./index"; +export = map; diff --git a/types/lodash/ts3.1/mapKeys.d.ts b/types/lodash/ts3.1/mapKeys.d.ts new file mode 100644 index 0000000000..7c7e1b5ce6 --- /dev/null +++ b/types/lodash/ts3.1/mapKeys.d.ts @@ -0,0 +1,2 @@ +import { mapKeys } from "./index"; +export = mapKeys; diff --git a/types/lodash/ts3.1/mapValues.d.ts b/types/lodash/ts3.1/mapValues.d.ts new file mode 100644 index 0000000000..3e87ea61ef --- /dev/null +++ b/types/lodash/ts3.1/mapValues.d.ts @@ -0,0 +1,2 @@ +import { mapValues } from "./index"; +export = mapValues; diff --git a/types/lodash/ts3.1/matches.d.ts b/types/lodash/ts3.1/matches.d.ts new file mode 100644 index 0000000000..5bb3cc2686 --- /dev/null +++ b/types/lodash/ts3.1/matches.d.ts @@ -0,0 +1,2 @@ +import { matches } from "./index"; +export = matches; diff --git a/types/lodash/ts3.1/matchesProperty.d.ts b/types/lodash/ts3.1/matchesProperty.d.ts new file mode 100644 index 0000000000..7378498533 --- /dev/null +++ b/types/lodash/ts3.1/matchesProperty.d.ts @@ -0,0 +1,2 @@ +import { matchesProperty } from "./index"; +export = matchesProperty; diff --git a/types/lodash/ts3.1/max.d.ts b/types/lodash/ts3.1/max.d.ts new file mode 100644 index 0000000000..36d0646138 --- /dev/null +++ b/types/lodash/ts3.1/max.d.ts @@ -0,0 +1,2 @@ +import { max } from "./index"; +export = max; diff --git a/types/lodash/ts3.1/maxBy.d.ts b/types/lodash/ts3.1/maxBy.d.ts new file mode 100644 index 0000000000..d483d95f95 --- /dev/null +++ b/types/lodash/ts3.1/maxBy.d.ts @@ -0,0 +1,2 @@ +import { maxBy } from "./index"; +export = maxBy; diff --git a/types/lodash/ts3.1/mean.d.ts b/types/lodash/ts3.1/mean.d.ts new file mode 100644 index 0000000000..983ad77282 --- /dev/null +++ b/types/lodash/ts3.1/mean.d.ts @@ -0,0 +1,2 @@ +import { mean } from "./index"; +export = mean; diff --git a/types/lodash/ts3.1/meanBy.d.ts b/types/lodash/ts3.1/meanBy.d.ts new file mode 100644 index 0000000000..67aebbbe82 --- /dev/null +++ b/types/lodash/ts3.1/meanBy.d.ts @@ -0,0 +1,2 @@ +import { meanBy } from "./index"; +export = meanBy; diff --git a/types/lodash/ts3.1/memoize.d.ts b/types/lodash/ts3.1/memoize.d.ts new file mode 100644 index 0000000000..6ff535b91e --- /dev/null +++ b/types/lodash/ts3.1/memoize.d.ts @@ -0,0 +1,2 @@ +import { memoize } from "./index"; +export = memoize; diff --git a/types/lodash/ts3.1/merge.d.ts b/types/lodash/ts3.1/merge.d.ts new file mode 100644 index 0000000000..eb8bd95e8a --- /dev/null +++ b/types/lodash/ts3.1/merge.d.ts @@ -0,0 +1,2 @@ +import { merge } from "./index"; +export = merge; diff --git a/types/lodash/ts3.1/mergeWith.d.ts b/types/lodash/ts3.1/mergeWith.d.ts new file mode 100644 index 0000000000..a58dd908b4 --- /dev/null +++ b/types/lodash/ts3.1/mergeWith.d.ts @@ -0,0 +1,2 @@ +import { mergeWith } from "./index"; +export = mergeWith; diff --git a/types/lodash/ts3.1/method.d.ts b/types/lodash/ts3.1/method.d.ts new file mode 100644 index 0000000000..cc3058870f --- /dev/null +++ b/types/lodash/ts3.1/method.d.ts @@ -0,0 +1,2 @@ +import { method } from "./index"; +export = method; diff --git a/types/lodash/ts3.1/methodOf.d.ts b/types/lodash/ts3.1/methodOf.d.ts new file mode 100644 index 0000000000..af7f19aa6b --- /dev/null +++ b/types/lodash/ts3.1/methodOf.d.ts @@ -0,0 +1,2 @@ +import { methodOf } from "./index"; +export = methodOf; diff --git a/types/lodash/ts3.1/min.d.ts b/types/lodash/ts3.1/min.d.ts new file mode 100644 index 0000000000..e8ba597cd6 --- /dev/null +++ b/types/lodash/ts3.1/min.d.ts @@ -0,0 +1,2 @@ +import { min } from "./index"; +export = min; diff --git a/types/lodash/ts3.1/minBy.d.ts b/types/lodash/ts3.1/minBy.d.ts new file mode 100644 index 0000000000..74860f9082 --- /dev/null +++ b/types/lodash/ts3.1/minBy.d.ts @@ -0,0 +1,2 @@ +import { minBy } from "./index"; +export = minBy; diff --git a/types/lodash/ts3.1/mixin.d.ts b/types/lodash/ts3.1/mixin.d.ts new file mode 100644 index 0000000000..7984246792 --- /dev/null +++ b/types/lodash/ts3.1/mixin.d.ts @@ -0,0 +1,2 @@ +import { mixin } from "./index"; +export = mixin; diff --git a/types/lodash/ts3.1/negate.d.ts b/types/lodash/ts3.1/negate.d.ts new file mode 100644 index 0000000000..46d0596446 --- /dev/null +++ b/types/lodash/ts3.1/negate.d.ts @@ -0,0 +1,2 @@ +import { negate } from "./index"; +export = negate; diff --git a/types/lodash/ts3.1/noConflict.d.ts b/types/lodash/ts3.1/noConflict.d.ts new file mode 100644 index 0000000000..78b3c921b4 --- /dev/null +++ b/types/lodash/ts3.1/noConflict.d.ts @@ -0,0 +1,2 @@ +import { noConflict } from "./index"; +export = noConflict; diff --git a/types/lodash/ts3.1/noop.d.ts b/types/lodash/ts3.1/noop.d.ts new file mode 100644 index 0000000000..bfaeb880d0 --- /dev/null +++ b/types/lodash/ts3.1/noop.d.ts @@ -0,0 +1,2 @@ +import { noop } from "./index"; +export = noop; diff --git a/types/lodash/ts3.1/now.d.ts b/types/lodash/ts3.1/now.d.ts new file mode 100644 index 0000000000..00f807eb50 --- /dev/null +++ b/types/lodash/ts3.1/now.d.ts @@ -0,0 +1,2 @@ +import { now } from "./index"; +export = now; diff --git a/types/lodash/ts3.1/nth.d.ts b/types/lodash/ts3.1/nth.d.ts new file mode 100644 index 0000000000..ce1013f23b --- /dev/null +++ b/types/lodash/ts3.1/nth.d.ts @@ -0,0 +1,2 @@ +import { nth } from "./index"; +export = nth; diff --git a/types/lodash/ts3.1/nthArg.d.ts b/types/lodash/ts3.1/nthArg.d.ts new file mode 100644 index 0000000000..2729d70e08 --- /dev/null +++ b/types/lodash/ts3.1/nthArg.d.ts @@ -0,0 +1,2 @@ +import { nthArg } from "./index"; +export = nthArg; diff --git a/types/lodash/ts3.1/omit.d.ts b/types/lodash/ts3.1/omit.d.ts new file mode 100644 index 0000000000..5868a07bf9 --- /dev/null +++ b/types/lodash/ts3.1/omit.d.ts @@ -0,0 +1,2 @@ +import { omit } from "./index"; +export = omit; diff --git a/types/lodash/ts3.1/omitBy.d.ts b/types/lodash/ts3.1/omitBy.d.ts new file mode 100644 index 0000000000..41bf6b48ac --- /dev/null +++ b/types/lodash/ts3.1/omitBy.d.ts @@ -0,0 +1,2 @@ +import { omitBy } from "./index"; +export = omitBy; diff --git a/types/lodash/ts3.1/once.d.ts b/types/lodash/ts3.1/once.d.ts new file mode 100644 index 0000000000..4340e88050 --- /dev/null +++ b/types/lodash/ts3.1/once.d.ts @@ -0,0 +1,2 @@ +import { once } from "./index"; +export = once; diff --git a/types/lodash/ts3.1/orderBy.d.ts b/types/lodash/ts3.1/orderBy.d.ts new file mode 100644 index 0000000000..02320d506d --- /dev/null +++ b/types/lodash/ts3.1/orderBy.d.ts @@ -0,0 +1,2 @@ +import { orderBy } from "./index"; +export = orderBy; diff --git a/types/lodash/ts3.1/over.d.ts b/types/lodash/ts3.1/over.d.ts new file mode 100644 index 0000000000..172c822bd8 --- /dev/null +++ b/types/lodash/ts3.1/over.d.ts @@ -0,0 +1,2 @@ +import { over } from "./index"; +export = over; diff --git a/types/lodash/ts3.1/overArgs.d.ts b/types/lodash/ts3.1/overArgs.d.ts new file mode 100644 index 0000000000..f8518f68d1 --- /dev/null +++ b/types/lodash/ts3.1/overArgs.d.ts @@ -0,0 +1,2 @@ +import { overArgs } from "./index"; +export = overArgs; diff --git a/types/lodash/ts3.1/overEvery.d.ts b/types/lodash/ts3.1/overEvery.d.ts new file mode 100644 index 0000000000..b8328fb520 --- /dev/null +++ b/types/lodash/ts3.1/overEvery.d.ts @@ -0,0 +1,2 @@ +import { overEvery } from "./index"; +export = overEvery; diff --git a/types/lodash/ts3.1/overSome.d.ts b/types/lodash/ts3.1/overSome.d.ts new file mode 100644 index 0000000000..2f172581ca --- /dev/null +++ b/types/lodash/ts3.1/overSome.d.ts @@ -0,0 +1,2 @@ +import { overSome } from "./index"; +export = overSome; diff --git a/types/lodash/ts3.1/pad.d.ts b/types/lodash/ts3.1/pad.d.ts new file mode 100644 index 0000000000..552667ada9 --- /dev/null +++ b/types/lodash/ts3.1/pad.d.ts @@ -0,0 +1,2 @@ +import { pad } from "./index"; +export = pad; diff --git a/types/lodash/ts3.1/padEnd.d.ts b/types/lodash/ts3.1/padEnd.d.ts new file mode 100644 index 0000000000..c81a7b0e13 --- /dev/null +++ b/types/lodash/ts3.1/padEnd.d.ts @@ -0,0 +1,2 @@ +import { padEnd } from "./index"; +export = padEnd; diff --git a/types/lodash/ts3.1/padStart.d.ts b/types/lodash/ts3.1/padStart.d.ts new file mode 100644 index 0000000000..c119c3584d --- /dev/null +++ b/types/lodash/ts3.1/padStart.d.ts @@ -0,0 +1,2 @@ +import { padStart } from "./index"; +export = padStart; diff --git a/types/lodash/ts3.1/parseInt.d.ts b/types/lodash/ts3.1/parseInt.d.ts new file mode 100644 index 0000000000..de59e7be9a --- /dev/null +++ b/types/lodash/ts3.1/parseInt.d.ts @@ -0,0 +1,2 @@ +import { parseInt } from "./index"; +export = parseInt; diff --git a/types/lodash/ts3.1/partial.d.ts b/types/lodash/ts3.1/partial.d.ts new file mode 100644 index 0000000000..d764f6e057 --- /dev/null +++ b/types/lodash/ts3.1/partial.d.ts @@ -0,0 +1,2 @@ +import { partial } from "./index"; +export = partial; diff --git a/types/lodash/ts3.1/partialRight.d.ts b/types/lodash/ts3.1/partialRight.d.ts new file mode 100644 index 0000000000..ed60160c62 --- /dev/null +++ b/types/lodash/ts3.1/partialRight.d.ts @@ -0,0 +1,2 @@ +import { partialRight } from "./index"; +export = partialRight; diff --git a/types/lodash/ts3.1/partition.d.ts b/types/lodash/ts3.1/partition.d.ts new file mode 100644 index 0000000000..f26ab15a5a --- /dev/null +++ b/types/lodash/ts3.1/partition.d.ts @@ -0,0 +1,2 @@ +import { partition } from "./index"; +export = partition; diff --git a/types/lodash/ts3.1/pick.d.ts b/types/lodash/ts3.1/pick.d.ts new file mode 100644 index 0000000000..6d346f8f6b --- /dev/null +++ b/types/lodash/ts3.1/pick.d.ts @@ -0,0 +1,2 @@ +import { pick } from "./index"; +export = pick; diff --git a/types/lodash/ts3.1/pickBy.d.ts b/types/lodash/ts3.1/pickBy.d.ts new file mode 100644 index 0000000000..5285ead8f7 --- /dev/null +++ b/types/lodash/ts3.1/pickBy.d.ts @@ -0,0 +1,2 @@ +import { pickBy } from "./index"; +export = pickBy; diff --git a/types/lodash/ts3.1/property.d.ts b/types/lodash/ts3.1/property.d.ts new file mode 100644 index 0000000000..3ff96f0e18 --- /dev/null +++ b/types/lodash/ts3.1/property.d.ts @@ -0,0 +1,2 @@ +import { property } from "./index"; +export = property; diff --git a/types/lodash/ts3.1/propertyOf.d.ts b/types/lodash/ts3.1/propertyOf.d.ts new file mode 100644 index 0000000000..27c628fa9d --- /dev/null +++ b/types/lodash/ts3.1/propertyOf.d.ts @@ -0,0 +1,2 @@ +import { propertyOf } from "./index"; +export = propertyOf; diff --git a/types/lodash/ts3.1/pull.d.ts b/types/lodash/ts3.1/pull.d.ts new file mode 100644 index 0000000000..b496ebde8d --- /dev/null +++ b/types/lodash/ts3.1/pull.d.ts @@ -0,0 +1,2 @@ +import { pull } from "./index"; +export = pull; diff --git a/types/lodash/ts3.1/pullAll.d.ts b/types/lodash/ts3.1/pullAll.d.ts new file mode 100644 index 0000000000..22c81c48af --- /dev/null +++ b/types/lodash/ts3.1/pullAll.d.ts @@ -0,0 +1,2 @@ +import { pullAll } from "./index"; +export = pullAll; diff --git a/types/lodash/ts3.1/pullAllBy.d.ts b/types/lodash/ts3.1/pullAllBy.d.ts new file mode 100644 index 0000000000..e0629ce99c --- /dev/null +++ b/types/lodash/ts3.1/pullAllBy.d.ts @@ -0,0 +1,2 @@ +import { pullAllBy } from "./index"; +export = pullAllBy; diff --git a/types/lodash/ts3.1/pullAllWith.d.ts b/types/lodash/ts3.1/pullAllWith.d.ts new file mode 100644 index 0000000000..d3ce829804 --- /dev/null +++ b/types/lodash/ts3.1/pullAllWith.d.ts @@ -0,0 +1,2 @@ +import { pullAllWith } from "./index"; +export = pullAllWith; diff --git a/types/lodash/ts3.1/pullAt.d.ts b/types/lodash/ts3.1/pullAt.d.ts new file mode 100644 index 0000000000..47be38253c --- /dev/null +++ b/types/lodash/ts3.1/pullAt.d.ts @@ -0,0 +1,2 @@ +import { pullAt } from "./index"; +export = pullAt; diff --git a/types/lodash/ts3.1/random.d.ts b/types/lodash/ts3.1/random.d.ts new file mode 100644 index 0000000000..a68cc27202 --- /dev/null +++ b/types/lodash/ts3.1/random.d.ts @@ -0,0 +1,2 @@ +import { random } from "./index"; +export = random; diff --git a/types/lodash/ts3.1/range.d.ts b/types/lodash/ts3.1/range.d.ts new file mode 100644 index 0000000000..8f737ca5e0 --- /dev/null +++ b/types/lodash/ts3.1/range.d.ts @@ -0,0 +1,2 @@ +import { range } from "./index"; +export = range; diff --git a/types/lodash/ts3.1/rangeRight.d.ts b/types/lodash/ts3.1/rangeRight.d.ts new file mode 100644 index 0000000000..cabd0ed7c4 --- /dev/null +++ b/types/lodash/ts3.1/rangeRight.d.ts @@ -0,0 +1,2 @@ +import { rangeRight } from "./index"; +export = rangeRight; diff --git a/types/lodash/ts3.1/rearg.d.ts b/types/lodash/ts3.1/rearg.d.ts new file mode 100644 index 0000000000..7684e867bf --- /dev/null +++ b/types/lodash/ts3.1/rearg.d.ts @@ -0,0 +1,2 @@ +import { rearg } from "./index"; +export = rearg; diff --git a/types/lodash/ts3.1/reduce.d.ts b/types/lodash/ts3.1/reduce.d.ts new file mode 100644 index 0000000000..4765fcd909 --- /dev/null +++ b/types/lodash/ts3.1/reduce.d.ts @@ -0,0 +1,2 @@ +import { reduce } from "./index"; +export = reduce; diff --git a/types/lodash/ts3.1/reduceRight.d.ts b/types/lodash/ts3.1/reduceRight.d.ts new file mode 100644 index 0000000000..1cfdb5f802 --- /dev/null +++ b/types/lodash/ts3.1/reduceRight.d.ts @@ -0,0 +1,2 @@ +import { reduceRight } from "./index"; +export = reduceRight; diff --git a/types/lodash/ts3.1/reject.d.ts b/types/lodash/ts3.1/reject.d.ts new file mode 100644 index 0000000000..aabc141319 --- /dev/null +++ b/types/lodash/ts3.1/reject.d.ts @@ -0,0 +1,2 @@ +import { reject } from "./index"; +export = reject; diff --git a/types/lodash/ts3.1/remove.d.ts b/types/lodash/ts3.1/remove.d.ts new file mode 100644 index 0000000000..dca471886f --- /dev/null +++ b/types/lodash/ts3.1/remove.d.ts @@ -0,0 +1,2 @@ +import { remove } from "./index"; +export = remove; diff --git a/types/lodash/ts3.1/repeat.d.ts b/types/lodash/ts3.1/repeat.d.ts new file mode 100644 index 0000000000..ca3c7fcb26 --- /dev/null +++ b/types/lodash/ts3.1/repeat.d.ts @@ -0,0 +1,2 @@ +import { repeat } from "./index"; +export = repeat; diff --git a/types/lodash/ts3.1/replace.d.ts b/types/lodash/ts3.1/replace.d.ts new file mode 100644 index 0000000000..7015411267 --- /dev/null +++ b/types/lodash/ts3.1/replace.d.ts @@ -0,0 +1,2 @@ +import { replace } from "./index"; +export = replace; diff --git a/types/lodash/ts3.1/rest.d.ts b/types/lodash/ts3.1/rest.d.ts new file mode 100644 index 0000000000..433a4fde72 --- /dev/null +++ b/types/lodash/ts3.1/rest.d.ts @@ -0,0 +1,2 @@ +import { rest } from "./index"; +export = rest; diff --git a/types/lodash/ts3.1/result.d.ts b/types/lodash/ts3.1/result.d.ts new file mode 100644 index 0000000000..65786428e3 --- /dev/null +++ b/types/lodash/ts3.1/result.d.ts @@ -0,0 +1,2 @@ +import { result } from "./index"; +export = result; diff --git a/types/lodash/ts3.1/reverse.d.ts b/types/lodash/ts3.1/reverse.d.ts new file mode 100644 index 0000000000..ecef17389c --- /dev/null +++ b/types/lodash/ts3.1/reverse.d.ts @@ -0,0 +1,2 @@ +import { reverse } from "./index"; +export = reverse; diff --git a/types/lodash/ts3.1/round.d.ts b/types/lodash/ts3.1/round.d.ts new file mode 100644 index 0000000000..ed2c179266 --- /dev/null +++ b/types/lodash/ts3.1/round.d.ts @@ -0,0 +1,2 @@ +import { round } from "./index"; +export = round; diff --git a/types/lodash/ts3.1/runInContext.d.ts b/types/lodash/ts3.1/runInContext.d.ts new file mode 100644 index 0000000000..9ee01f324f --- /dev/null +++ b/types/lodash/ts3.1/runInContext.d.ts @@ -0,0 +1,2 @@ +import { runInContext } from "./index"; +export = runInContext; diff --git a/types/lodash/ts3.1/sample.d.ts b/types/lodash/ts3.1/sample.d.ts new file mode 100644 index 0000000000..c225178692 --- /dev/null +++ b/types/lodash/ts3.1/sample.d.ts @@ -0,0 +1,2 @@ +import { sample } from "./index"; +export = sample; diff --git a/types/lodash/ts3.1/sampleSize.d.ts b/types/lodash/ts3.1/sampleSize.d.ts new file mode 100644 index 0000000000..0f1ed89ee7 --- /dev/null +++ b/types/lodash/ts3.1/sampleSize.d.ts @@ -0,0 +1,2 @@ +import { sampleSize } from "./index"; +export = sampleSize; diff --git a/types/lodash/ts3.1/scripts/generate-all.sh b/types/lodash/ts3.1/scripts/generate-all.sh new file mode 100644 index 0000000000..a07bf37932 --- /dev/null +++ b/types/lodash/ts3.1/scripts/generate-all.sh @@ -0,0 +1,16 @@ +# If some one want to update lodash modules, you must run this script under the same dir where it lives. +# Or you can run them(generate-modules.ts) separately by hand +#!/usr/bin/env bash + +npm i ts-node -g + +ts-node ./generate-modules.ts +ts-node ./generate-fp.ts + +cd ../../../ + +npm i prettier -D + +cd types/lodash-es/scripts + +ts-node ./generate-modules.ts diff --git a/types/lodash/ts3.1/scripts/generate-fp.ts b/types/lodash/ts3.1/scripts/generate-fp.ts new file mode 100644 index 0000000000..ecd9c97ab4 --- /dev/null +++ b/types/lodash/ts3.1/scripts/generate-fp.ts @@ -0,0 +1,912 @@ +// Script for converting the lodash types into functional programming (FP) format. +// The convertion is done based on this guide: https://github.com/lodash/lodash/wiki/FP-Guide + +// Assumptions: +// - All functions are defined in one of the files in the "common" subfolder +// - All functions are defined inside of the LoDashStatic interface (although functions like _.partial may refer to another interface in the same file) +// - Consistent indentation is used for the start and end of the above interface +// - Consistent spacing is used for interface definitions: interface MyInterface { +// - Consistent line breaks (\n, \r, or \r\n) are used in all files +// - All overloads of a given function are defined in the same file + +import fs from "fs"; +import _ from "lodash"; +import convert from "lodash/fp/convert"; +import path from "path"; +import { readFile, getLineBreak, tab, getLineNumber } from "./utils"; + +interface Definition { + name: string; + overloads: Overload[]; + constants: string[]; + jsdoc: string; +} +interface InterfaceGroup { + functionName: string; + interfaces: Interface[]; +} +interface Interface { + name: string; + typeParams: TypeParam[]; + overloads: Overload[]; + constants: string[]; +} +interface Overload { + typeParams: TypeParam[]; + params: string[]; + returnType: string; + jsdoc: string; + tslintDisable?: string; +} +interface TypeParam { + name: string; + extends?: string; + equals?: string; +} + +let lineBreak = "\n"; +async function main() { + lineBreak = await getLineBreak(); + const commonTypes: string[] = []; + + // Read each function definition and fp-ify it + const subfolders = ["common"]; + const promises: Array> = []; + for (const subfolder of subfolders) { + promises.push(new Promise((resolve, reject) => { + fs.readdir(path.join("..", subfolder), (err, files) => { + if (err) { + console.error(`failed to list directory contents for '${subfolder}': `, err); + reject(err); + return; + } + const filePaths = files.map(f => path.join("..", subfolder, f)); + try { + resolve(processDefinitions(filePaths, commonTypes)); + } catch (e) { + console.error(`failed to process files in '${subfolder}': `, e); + reject(e); + } + }); + })); + } + + let interfaceGroups: InterfaceGroup[]; + try { + interfaceGroups = _.flatten(await Promise.all(promises)); + } catch (err) { + console.error("Failed to parse all functions: ", err); + return; + } + interfaceGroups = _.sortBy(interfaceGroups, g => _.toLower(g.functionName)); + for (const interfaceGroup of interfaceGroups) { + // Rename interfaces for different versions of the same function with different arity (to avoid name conflicts). + // Don't rename aliases - instead they will be removed from the output when interfaces are written. + const interfaceName = interfaceGroup.interfaces[0].name; + const conflicts = interfaceGroups.filter(g => g.interfaces[0].name === interfaceName); + if (conflicts.length > 1 && _.some(conflicts, c => !_.isEqual(c.interfaces, conflicts[0].interfaces))) { + for (const conflict of conflicts) { + const oldName = conflict.interfaces[0].name; + const newName = getInterfaceBaseName(conflict.functionName); + for (const interfaceDef of conflict.interfaces) { + interfaceDef.name = interfaceDef.name.replace(oldName, newName); + for (const overload of interfaceDef.overloads) + overload.returnType = overload.returnType.replace(oldName, newName); + } + } + } + } + const interfaces = _.uniqBy(_.flatMap(interfaceGroups, g => g.interfaces), i => i.name); + const commonTypeSearch = new RegExp(`\\b(${commonTypes.join("|")})\\b`, "g"); + const interfaceStrings = _(interfaces) + .map(i => tab(interfaceToString(i), 1)) + .join(lineBreak) + .replace(commonTypeSearch, match => `lodash.${match}`); + const fpFile = [ + "// AUTO-GENERATED: do not modify this file directly.", + "// If you need to make changes, modify generate-fp.ts (if necessary), then open a terminal in types/lodash/scripts, and do:", + "// npm install && npm run generate", + "", + 'import lodash = require("./index");', + "", + "export = _;", + "", + "declare const _: _.LoDashFp;", + "declare namespace _ {", + interfaceStrings, + "", + " interface LoDashFp {", + ...interfaceGroups.map(g => ` ${g.functionName}: ${g.interfaces[0].name};`), + " __: lodash.__;", + " placeholder: lodash.__;", + " }", + "}", + "", + ].join(lineBreak); + fs.writeFile(path.join("..", "fp.d.ts"), fpFile, (err) => { + if (err) + console.error("Failed to write fp.d.ts: ", err); + }); + + // Make sure the generated files are listed in tsconfig.json, so they are included in the lint checks + const tsconfigPath = path.join("..", "tsconfig.json"); + const tsconfigFile = await readFile(tsconfigPath); + const tsconfig = tsconfigFile.split(lineBreak).filter(row => !row.includes("fp/") || row.includes("fp/convert.d.ts")); + const newRows = interfaceGroups.map(g => ` "fp/${g.functionName}.d.ts",`) + .concat(["__", "placeholder"].map(p => ` "fp/${p}.d.ts",`)); + newRows[newRows.length - 1] = newRows[newRows.length - 1].replace(",", ""); + + const insertIndex = _.findLastIndex(tsconfig, row => row.trim() === "]"); // Assume "files" is the last array + if (!tsconfig[insertIndex - 1].endsWith(",")) + tsconfig[insertIndex - 1] += ","; + tsconfig.splice(insertIndex, 0, ...newRows); + + fs.writeFile(tsconfigPath, tsconfig.join(lineBreak), (err) => { + if (err) + console.error(`Failed to write ${tsconfigPath}: `, err); + }); +} + +async function processDefinitions(filePaths: string[], commonTypes: string[]): Promise { + const builder: { [name: string]: (...args: number[][]) => () => Interface[] } = {}; + const unconvertedBuilder: { [name: string]: (...args: number[][]) => () => Interface[] } = {}; + for (const filePath of filePaths) { + const definitions = await parseFile(filePath, commonTypes); + for (const definition of definitions) { + definition.overloads = definition.overloads.filter(o => !o.params.some(p => p.includes('StringIterator'))); + if (definition.overloads.every(o => o.params.length <= 1 && (o.returnType === "typeof _" || o.returnType === "LoDashStatic"))) { + // Our convert technique doesn't work well on "typeof _" functions (or at least runInContext) + // Plus, if there are 0-1 parameters, there's nothing to curry anyways. + unconvertedBuilder[definition.name] = (...args: number[][]) => { + return () => curryDefinition(definition, args[0] || [], -1, false); + }; + } else { + builder[definition.name] = (...args: Array) => { + // args were originally passed in as [0], [1], [2], [3], [4]. If they changed order, that indicates how the functoin was re-arged + // Return a function because some definitons (like rearg) expect to have a function return value + + // If any argument is a number instead of an array, then the argument at that index is being spread (e.g. assignAll, invokeArgs, partial, without) + const spreadIndex = args.findIndex(a => typeof a === "number"); + let isFixed = true; + if (spreadIndex !== -1) { + // If there's a spread parameter, convert() won't cap the number of arguments, so we need to do it manually + const arity = Math.max(spreadIndex, args[spreadIndex] as number) + 1; + args = args.slice(0, arity); + } else if (args.length > 4 || definition.name === "flow" || definition.name === "flowRight") { + // Arity wasn't fixed by convert() + isFixed = false; + } + // For some reason, convert() doesn't seems to tell us which functions have unchanged argument order. + // So we have to hard-code it. + const unchangedOrders = ["add", "assign", "assignIn", "bind", "bindKey", "concat", "difference", "divide", "eq", + "gt", "gte", "isEqual", "lt", "lte", "matchesProperty", "merge", "multiply", "overArgs", "partial", "partialRight", + "propertyOf", "random", "range", "rangeRight", "subtract", "zip", "zipObject", "zipObjectDeep"]; + if (unchangedOrders.includes(definition.name)) + args = _.sortBy(args, a => typeof a === "number" ? a : a[0]); + + return () => curryDefinition(definition, _.flatten(args), spreadIndex, isFixed); + }; + } + } + } + + // Use convert() to tell us how functions will be rearged and aliased + const builderFp = convert(builder, { rearg: true, fixed: true, immutable: false, curry: false, cap: false }); + _.defaults(builderFp, unconvertedBuilder); + + const functionNames = Object.keys(builderFp).filter(key => key !== "convert" && typeof builderFp[key] === "function"); + const interfaceGroups: InterfaceGroup[] = functionNames.map((functionName): InterfaceGroup => ({ + functionName, + // Assuming the maximum arity is 4. Pass one more arg than the max arity so we can detect if arguments weren't fixed. + interfaces: builderFp[functionName]([0], [1], [2], [3], [4])([0], [1], [2], [3], [4]), + })); + for (const functionName of functionNames) { + const output = [ + `import { ${functionName} } from "../fp";`, + `export = ${functionName};`, + "", + ].join(lineBreak); + const targetFile = `../fp/${functionName}.d.ts`; + fs.writeFile(targetFile, output, (err) => { + if (err) + console.error(`failed to write file: ${targetFile}`, err); + }); + } + return interfaceGroups; +} + +async function parseFile(filePath: string, commonTypes: string[]): Promise { + const definitionString = await readFile(filePath); + const newCommonTypeRegExp = / (?:type|interface) ([A-Za-z0-9_]+)/g; + let newCommonType = newCommonTypeRegExp.exec(definitionString); + while (newCommonType) { + if (!commonTypes.includes(newCommonType[1])) + commonTypes.push(newCommonType[1]); + newCommonType = newCommonTypeRegExp.exec(definitionString); + } + + const definitons: Definition[] = []; + const lodashStaticRegExp = /( *)interface LoDashStatic {/g; + let lodashStaticMatch = lodashStaticRegExp.exec(definitionString); + while (lodashStaticMatch) { + const startIndex = lodashStaticMatch.index; + const endIndex = definitionString.indexOf(`${lineBreak}${lodashStaticMatch[1]}}`, startIndex); + if (endIndex === -1) { + const lineNumber = getLineNumber(definitionString, startIndex); + console.warn(`Failed to find end of interface 'LoDashStatic' (starting at ${filePath} line ${lineNumber}).`); + break; + } + const parsedDefinitions = parseDefinitions(definitionString, startIndex + lodashStaticMatch[0].length, endIndex, filePath, commonTypes); + definitons.push(...parsedDefinitions); + lodashStaticMatch = lodashStaticRegExp.exec(definitionString); + } + return definitons; +} + +function parseDefinitions(definitionString: string, startIndex: number, endIndex: number, filePath: string, commonTypes: string[], name?: string): Definition[] { + const parentName = name; + const overloadRegExp = name ? / [<(]/g : / (\w+)[<(:]/g; + overloadRegExp.lastIndex = startIndex; + let overloadMatch = overloadRegExp.exec(definitionString); + if (!overloadMatch) { + const lineNumber = getLineNumber(definitionString, startIndex); + console.warn(`No function definitions were found in interface at ${filePath} line ${lineNumber}.`); + return []; + } + const definitons: Definition[] = []; + let currentDefinition: Definition | undefined; + for (; overloadMatch && overloadMatch.index < endIndex; overloadMatch = overloadRegExp.exec(definitionString)) { + name = overloadMatch[1] || name!; + + const overloadStartIndex = overloadMatch.index; + if (!currentDefinition || name !== currentDefinition.name) { + if (currentDefinition && !_.isEmpty(currentDefinition.overloads)) + definitons.push(currentDefinition); + currentDefinition = { name, overloads: [], constants: [], jsdoc: "" }; + const jsdocStartIndex = definitionString.lastIndexOf("/**", overloadStartIndex); + const jsdocEndIndex = definitionString.indexOf("*/", jsdocStartIndex); + if (jsdocStartIndex !== -1 && jsdocStartIndex > startIndex && jsdocEndIndex !== -1 && jsdocEndIndex < overloadStartIndex) { + // Verify that the comment is for this overload + const overloadTestIndex = definitionString.indexOf(" " + name, jsdocEndIndex); + if (overloadTestIndex === overloadStartIndex) + currentDefinition.jsdoc = definitionString.substring(jsdocStartIndex, jsdocEndIndex + 2).replace(/ /g, ""); + } + } + let overloadEndIndex = definitionString.indexOf(";", overloadStartIndex); + if (overloadEndIndex === -1 || overloadEndIndex > endIndex) { + const lineNumber = getLineNumber(definitionString, overloadStartIndex); + console.warn(`Overload does not end with semicolon! ${filePath} line ${lineNumber}`); + break; + } + overloadRegExp.lastIndex = overloadEndIndex; + if (name === "chain" || name === "mixin" || name.startsWith("prototype.")) + continue; + + const overloadString = definitionString.substring(overloadStartIndex, overloadEndIndex); + let paramStartIndex = overloadString.indexOf("("); + if (paramStartIndex !== -1) { + const overload: Overload = { typeParams: [], params: [], returnType: "", jsdoc: currentDefinition.jsdoc }; + + const previousLine = getPreviousLine(definitionString, overloadStartIndex).trim(); + if (previousLine.startsWith("// tslint:disable")) + overload.tslintDisable = previousLine; + + const typeParamStartIndex = overloadString.indexOf("<"); + if (typeParamStartIndex !== -1 && typeParamStartIndex < paramStartIndex) { + const typeParamEndIndex = overloadString.indexOf(">(", typeParamStartIndex); + if (typeParamEndIndex !== -1) { + paramStartIndex = typeParamEndIndex + 1; + overload.typeParams = overloadString + .substring(typeParamStartIndex + 1, typeParamEndIndex) + .split(",") + .map((tpString): TypeParam => { + const typeParam: TypeParam = { name: tpString }; + let parts = tpString.split(/=[^>]/); + if (parts[1]) + typeParam.equals = parts[1].trim(); + parts = tpString.split(" extends "); + if (parts[1]) + typeParam.extends = parts[1].trim(); + typeParam.name = parts[0].trim(); + return typeParam; + }); + } + } + const paramEndIndex = overloadString.indexOf("):", paramStartIndex); + if (paramEndIndex === -1) { + console.warn(`Failed to find parameter end position in overload for '${name}' (${filePath}).`); + continue; + } + overload.params = overloadString + .substring(paramStartIndex + 1, paramEndIndex) + .split(/,(?=[^,]+:)(?=(?:[^()]*|.*\(.*\).*)$)/m) // split on commas, but ignore Generic and (a, b) => c + .map(_.trim) + .map(o => _.trim(o, ",")) + .filter(o => !!o); + overload.returnType = overloadString.substring(paramEndIndex + 2).trim(); + // Special case for unset: the return type should be the input type, not bolean. See https://github.com/DefinitelyTyped/DefinitelyTyped/issues/25361 + if (name === "unset") { + overload.typeParams = [{ name: "T" }]; + overload.params[0] = overload.params[0].replace(/\bany\b/, "T"); + overload.returnType = "T"; + } + currentDefinition.overloads.push(overload); + } else { + // This overload actually points to an interface. Try to find said interface and get the overloads from there. + const overloadParts = overloadString.split(":"); + const interfaceName = overloadParts[1].trim(); + if (interfaceName.startsWith("typeof ") || interfaceName.startsWith("LoDashStatic[")) { + // This is an alias (e.g. first: typeof _.head, or first: LoDashStatic['head']). + // Ignore it since convert() will create this alias based on the original function. + continue; + } + let interfaceStartIndex: number; + let interfaceEndIndex: number; + if (!interfaceName.startsWith("{")) { + const ignoreInterfaceNames = ["string", "TemplateSettings", "MapCacheConstructor"]; + if (ignoreInterfaceNames.includes(interfaceName)) + continue; + const interfaceRegExp = new RegExp(`( *)interface ${interfaceName} {`); + const interfaceMatch = interfaceRegExp.exec(definitionString); + if (!interfaceMatch) { + const lineNumber = getLineNumber(definitionString, overloadStartIndex); + console.warn(`Failed to parse function '${name}': interface '${interfaceName}' not found. (${filePath} line ${lineNumber})`); + continue; + } + interfaceStartIndex = interfaceMatch.index + interfaceMatch[0].length; + interfaceEndIndex = definitionString.indexOf(`${lineBreak}${interfaceMatch[1]}}`, interfaceStartIndex); + if (interfaceEndIndex === -1) { + const lineNumber = getLineNumber(definitionString, interfaceStartIndex); + console.warn(`Failed to find end of interface '${interfaceName}' (starting at ${filePath} line ${lineNumber}).`); + continue; + } + _.pull(commonTypes, interfaceName); + } else { + // This is an inline type definition + interfaceStartIndex = definitionString.indexOf("{", overloadStartIndex + overloadParts[0].length) + 1; + interfaceEndIndex = definitionString.indexOf("}", interfaceStartIndex); + if (interfaceEndIndex === -1 || interfaceEndIndex >= endIndex) { + console.warn(`Failed to find closing '}' character for property '${name}' (${filePath}).`); + continue; + } + overloadEndIndex = definitionString.indexOf(";", interfaceEndIndex); + if (overloadEndIndex === -1 || overloadEndIndex >= endIndex) { + const lineNumber = getLineNumber(definitionString, overloadStartIndex); + console.warn(`Overload does not end with semicolon! ${filePath} line ${lineNumber}`); + continue; + } + overloadRegExp.lastIndex = overloadEndIndex; + } + const [definition] = parseDefinitions(definitionString, interfaceStartIndex, interfaceEndIndex, filePath, commonTypes, name); + if (definition) { + if (currentDefinition.jsdoc) + for (const overload of definition.overloads) + overload.jsdoc = currentDefinition.jsdoc; + currentDefinition.overloads.push(...definition.overloads); + currentDefinition.constants.push(...definition.constants); + } + } + } + if (parentName && currentDefinition) { + const constantRexExp = / (\w+): *([^()\r\n]+);[\r\n]/g; + constantRexExp.lastIndex = startIndex; + for (let constantMatch = constantRexExp.exec(definitionString); constantMatch && constantMatch.index < endIndex; constantMatch = constantRexExp.exec(definitionString)) { + currentDefinition.constants.push(`${constantMatch[1]}: ${constantMatch[2]}`); + } + } + + if (currentDefinition && !_.isEmpty(currentDefinition.overloads)) + definitons.push(currentDefinition); + return definitons; +} + +function curryDefinition(definition: Definition, paramOrder: number[], spreadIndex: number, isFixed: boolean): Interface[] { + // Remove any duplicate/redundant overloads + let overloads = _.uniqWith(_.cloneDeep(definition.overloads), + (a, b) => _.isEqual(a.params, b.params) && _.isEqual(getUsedTypeParams(a.params, a.typeParams), getUsedTypeParams(b.params, b.typeParams))); + const functionName = definition.name; + // Remove unused type parameters + for (const overload of overloads) { + for (let i = 0; i < overload.typeParams.length; ++i) { + const typeParam = overload.typeParams[i]; + const search = new RegExp(`\\b${typeParam.name}\\b`); + if (overload.params.every(p => !search.test(p)) && !search.test(overload.returnType)) { + // overload.returnType = overload.returnType.replace(search, typeParam.extends || "any"); + overload.typeParams.splice(i, 1); + --i; + } + } + } + + if (!isFixed) { + // Non-fixed arity functions cannot be curried. + for (const overload of overloads) + overload.params = overload.params.map(p => p.replace(/\?:/g, ":")); // No optional parameters + return [{ + name: getInterfaceBaseName(functionName), + typeParams: [], + overloads, + constants: definition.constants, + }]; + } + paramOrder = paramOrder.filter(p => typeof p === "number"); + const arity = paramOrder.length; + + if (spreadIndex !== -1) { + // The parameter at this index is an array that will be spread when passed down to the actual function (e.g. assignAll, invokeArgs, partial, without). + // For these parameters, we expect the input to be an array (so remove the "...") + + // Spread/rest parameters could be in any of the following formats: + // 1. The rest parameter is at spreadIndex, and it is the last parameter. + // 2. The rest parameter is immediately after spreadIndex, e.g. assign(object, ...sources[]). In this case, convert it to assignAll(...object[]) + // 3. The overload defines no rest parameters, e.g. mergeAll(T1, T2, T3) + // 4. The rest parameter is not the last parameter, e.g. assignWith(object, ...sources[], customizer) + if (spreadIndex === arity - 1) { + for (let i = 0; i < overloads.length; ++i) { + const overload = overloads[i]; + if (overload.params.length === arity && overload.params[spreadIndex] && overload.params[spreadIndex].startsWith("...")) { + // case 1 + overload.params[spreadIndex] = overload.params[spreadIndex].replace("...", ""); + } else if (overload.params.length === arity + 1 && overload.params[spreadIndex + 1] && overload.params[spreadIndex + 1].startsWith("...")) { + // case 2 + overload.params.splice(spreadIndex + 1, 1); + const parts = overload.params[spreadIndex].split(":").map(_.trim); + parts[1] = `ReadonlyArray<${parts[1]}>`; + overload.params[spreadIndex] = `${parts[0]}: ${parts[1]}`; + } else if (overload.params.length >= arity && overload.params[spreadIndex] && !overload.params.some(p => p.startsWith("..."))) { + // case 3 + const paramName = getParamName(overload.params[spreadIndex]); + const spreadParamTypes = overload.params.slice(spreadIndex).map(getParamType); + overload.params = overload.params.slice(0, spreadIndex); + overload.params.push(`${paramName}: [${spreadParamTypes.join(", ")}]`); + } else { + _.pull(overloads, overload); + --i; + } + } + } else { + // case 4 + const overload = overloads[0]; + overloads = [{ + jsdoc: overload.jsdoc, + typeParams: [], + params: [ + ...overload.params.slice(0, spreadIndex), + "args: ReadonlyArray", + ...overload.params.slice(overload.params.length - (arity - spreadIndex - 1)), + ], + returnType: "any", + }]; + } + } + + let filteredOverloads = overloads.filter(o => o.params.length >= arity && o.params.slice(arity).every(p => p.includes("?") && !p.startsWith("iteratee")) + && o.params.every(p => !p.startsWith("...") && !p.startsWith("guard:"))); + if (filteredOverloads.length === 0) + filteredOverloads = overloads.filter(o => o.params.length >= arity && o.params.slice(arity).every(p => p.includes("?") || p.startsWith("...")) + && o.params.every(p => !p.startsWith("guard:"))); + if (filteredOverloads.length === 0) + filteredOverloads = overloads.filter(o => o.params.length > 0 && o.params.length <= arity + 1 && o.params[o.params.length - 1].startsWith("...")); + if (filteredOverloads.length === 0) + console.warn(`No matching overloads found for ${functionName} with arity ${arity}`); + + const restOverloads = overloads.filter(o => o.params.length > 0 && o.params[o.params.length - 1].startsWith("...")); + for (const restOverload of restOverloads) { + restOverload.params[restOverload.params.length - 1] = restOverload.params[restOverload.params.length - 1] + .substring(3) + .replace(/\[\]$/, "") + .replace(/: Array<(.+)>$/, ": $1"); + if (restOverload.params.length < arity) { + const paramToCopy = restOverload.params[restOverload.params.length - 1]; + const copiedParams = _.range(2, arity - restOverload.params.length + 2).map(i => paramToCopy.replace(/(^.+?):/, `$1${i}:`)); + restOverload.params.push(...copiedParams); + } + } + + for (const overload of filteredOverloads) + preProcessOverload(overload, functionName, arity); + + const interfaces = _.flatMap(filteredOverloads, (o, i) => { + const reargParams = o.params.map((p, i) => o.params[paramOrder.indexOf(i)]); + return curryOverload({ + typeParams: o.typeParams, + params: reargParams, + returnType: o.returnType, + jsdoc: o.jsdoc, + }, functionName, i + 1); + }); + if (interfaces.length === 0) + return []; + // Merge interfaces with the same name + const mainInterface = interfaces[0]; + const interfacesToMerge = interfaces.filter(i => i.name === mainInterface.name); + mergeInterfaces(interfacesToMerge); + _.remove(interfaces, i => i !== mainInterface && interfacesToMerge.includes(i)); + // Check for any non-main interfaces that should now be merged + for (const overload of mainInterface.overloads) { + const others = mainInterface.overloads.filter(o2 => o2 !== overload + && _.isEqual(overload.typeParams, o2.typeParams) + && _.isEqual(overload.params.map(getParamType), o2.params.map(getParamType))); + const returnInterface = interfaces.find(i => new RegExp(`\\b${i.name}\\b`).test(overload.returnType)); + for (const otherOverload of others) { + for (let i = 0; i < overload.params.length; ++i) { + const paramNames = _.uniq([overload].concat(others).map(o => getParamName(o.params[i]))); + if (paramNames.length > 1) { + // Some param names are different. Merge them. + const paramType = getParamType(overload.params[i]); + overload.params[i] = `${paramNames[0]}Or${paramNames.slice(1).map(_.upperFirst).join("Or")}: ${paramType}`; + } + } + if (otherOverload.returnType === overload.returnType) { + // Exact duplicate - remove the second overload + _.pull(mainInterface.overloads, otherOverload); + } else { + // Duplicate except for the return type. If the return types are both known interfaces, + // merge the interfaces so we can remove the second overload + const otherReturnInterface = interfaces.find(i => new RegExp(`\\b${i.name}\\b`).test(otherOverload.returnType)); + if (returnInterface && otherReturnInterface) { + _.remove(otherReturnInterface.overloads, o => new RegExp(`\\b${otherReturnInterface.name}\\b`).test(o.returnType)); + mergeInterfaces([returnInterface, otherReturnInterface]); + _.pull(interfaces, otherReturnInterface); + // Rename any other references to the removed interface(s) + for (const overload of _.flatMap(interfaces, i => i.overloads)) + overload.returnType = overload.returnType.replace(new RegExp(`\\b${otherReturnInterface.name}\\b`), returnInterface.name); + } + } + } + _.pull(mainInterface.overloads, ...others); + } + for (const interfaceDef of interfaces) + interfaceDef.overloads = mergeSimilarOverloads(interfaceDef.overloads); + interfaces[0].constants = definition.constants; + return interfaces; +} + +function getParamName(param: string) { + return param.split(":", 1)[0]; +} + +function getParamType(param: string) { + const index = param.indexOf(":"); + return index !== -1 ? param.substring(index + 1).trim() : "any"; +} + +function isPlaceholder(param: string) { + return param.endsWith("__"); +} + +function preProcessOverload(overload: Overload, functionName: string, arity: number): void { + overload.params = overload.params + .slice(0, arity) + .map(p => p + .replace(/\?:/g, ":") // No optional parameters + .replace(/: *(?:Array<(.+)>|([^ |]+)\[\]|\((.+)\)\[\])$/, ": ReadonlyArray<$1$2$3>")); // Convert Array to ReadonlyArray because lodash/fp treats everything as immutable + // Cap the number of callback arguments + for (let i = 0; i < overload.params.length; ++i) + overload.params[i] = capCallback(overload.params[i], functionName); +} + +function capCallback(parameter: string, functionName: string): string { + // We don't support capping these callbacks yet, so flag them if detected + if (functionName !== "zipWith" && functionName !== "unzipWith" && /(?:iteratee|predicate|callback): *\((?:[^,)]+,[^)]+| *\.\.\..+)\) ?=>/.test(parameter)) + console.warn(`${functionName}: Failed to cap callback: ${parameter}`); + + // Special case for mapKeys: callback is capped to the key parameter only + if (functionName === "mapKeys") { + parameter = parameter + .replace(/(iteratee|predicate|callback): *(?:Array|List|NumericDictionary|String)Iteratee<(.+)>$/g, "$1: ValueIteratee") + .replace(/(iteratee|predicate|callback): *(?:Dictionary|Object)Iteratee<(.+)>$/g, "$1: ValueIteratee") + .replace(/(iteratee|predicate|callback): *(?:Array|List|NumericDictionary|String)Iteratee(?:Custom)?<(.+?),(.+)>$/g, "$1: ValueIterateeCustom") + .replace(/(iteratee|predicate|callback): *(?:Dictionary|Object)Iteratee(?:Custom)?<(.+?),(.+)>$/g, "$1: ValueIterateeCustom"); + } + + // Special case for reduceRight: callback argument order of (b, a) + if (functionName === "reduceRight") { + parameter = parameter + .replace(/(iteratee|predicate|callback): *Memo(Void)?(?:List|Object|Dictionary)Iterator<([^,>]+),([^,>]+)(?:,[^,>]+?()?)?>/g, "$1: Memo$2IteratorCappedRight<$3,$4>"); + } + + return parameter + .replace(/(iteratee|predicate|callback): *(?:Array|List|Dictionary|NumericDictionary|String)Iteratee<(.+)>$/g, "$1: ValueIteratee<$2>") + .replace(/(iteratee|predicate|callback): *(?:Array|List|Dictionary|NumericDictionary|String)Iteratee(?:Custom)?<(.+?),(.+)>$/g, "$1: ValueIterateeCustom<$2,$3>") + .replace(/(iteratee|predicate|callback): *(?:Array|List|Dictionary|NumericDictionary|String)IteratorTypeGuard<(.+?),(.+)>$/g, "$1: ValueIteratorTypeGuard<$2,$3>") + .replace(/(iteratee|predicate|callback): *ObjectIteratee<(.+)>$/g, "$1: ValueIteratee<$2[keyof $2]>") + .replace(/(iteratee|predicate|callback): *ObjectIterateeCustom<(.+?),(.+)>$/g, "$1: ValueIterateeCustom<$2[keyof $2],$3>") + .replace(/(iteratee|predicate|callback): *ObjectIteratorTypeGuard<(.+?),(.+)>$/g, "$1: ValueIteratorTypeGuard<$2[keyof $2],$3>") + .replace(/(iteratee|predicate|callback): *(?:Array|List|Dictionary|NumericDictionary)Iterator<(.+?), *(.+)>$/g, "$1: (value: $2) => $3") + .replace(/(iteratee|predicate|callback): *StringIterator<(.+)>$/g, "$1: (value: string) => $2") + .replace(/(iteratee|predicate|callback): *ObjectIterator<(.+?), *(.+?)>$/g, "$1: (value: $2[keyof $2]) => $3") + .replace(/(iteratee|predicate|callback): *Memo(Void)?(?:Array|List|Object|Dictionary)Iterator<([^,>]+),([^,>]+)(?:,[^,>]+?()?)?>/g, "$1: Memo$2IteratorCapped<$3,$4>") + .replace(/(iteratees|predicates|callbacks): *Many<(?:Array|List|Dictionary|NumericDictionary|String)Iteratee<(.+?)>>/g, "$1: Many>") + .replace(/(iteratees|predicates|callbacks): *Many>/g, "$1: Many>") + .replace(/(iteratees|predicates|callbacks): *Many<(?:Array|List|Dictionary|NumericDictionary)Iterator<(.+?), *(.+?)>>/g, "$1: Many<(value: $2) => $3>") + .replace(/(iteratees|predicates|callbacks): *Many>/g, "$1: Many<(value: $2[keyof $2]) => $3>"); +} + +function curryOverload(overload: Overload, functionName: string, overloadId: number): Interface[] { + const baseName = getInterfaceBaseName(functionName); + if (overload.params.length <= 1) { + // Functions with 0 or 1 arguments are not curried. Just use a basic function type. + return [{ + name: baseName, + overloads: [overload], + typeParams: [], + constants: [], + }]; + } + + // Create a separate interface for each possible combination of parameters that could be passed. + // i = binary representation of which parameters were passed to result in this interface (reversed), e.g. + // 1 = 0001 = 1st parameter was passed; 2nd-4th remain + // 6 = 1010 = 2nd and 4th parameters were passed; 1st and 3rd remain + const interfaces: Interface[] = []; + const interfaceCount = (1 << overload.params.length) - 1; + for (let i = 0; i < interfaceCount; ++i) { + const interfaceDef = curryParams(baseName, overloadId, overload, i); + interfaces.push(interfaceDef); + } + // The T[keyof T] constraint doesn't work so well if it's the only constraint. Convert to a plain old T constraint so it can be merged with + // other ValueIteratee overloads + for (const interfaceDef of interfaces) { + for (const overload of interfaceDef.overloads) { + const objectTypeParam = overload.typeParams.find(tp => tp.name === "T" && (tp.extends === "object" || !tp.extends)); + if (objectTypeParam && overload.params.some(p => p.includes("T[keyof T]")) && !overload.params.some(p => /T(?!]|\[keyof T])/.test(p))) { + delete objectTypeParam.extends; + overload.params = overload.params.map(p => p.replace(/\bArray/g, " T[]").replace(/\bT\[keyof T]/g, "T")); + const fixInterfaceName = overload.returnType.split("<")[0]; + const fixInterface = interfaces.find(i => i.name === fixInterfaceName); + if (fixInterface) { + const fixTypeParam = fixInterface.typeParams.find(tp => tp.name === objectTypeParam.name && (tp.extends === "object" || !tp.extends)); + if (fixTypeParam) { + delete fixTypeParam.extends; + for (const fixOverload of fixInterface.overloads) { + // This overload has T referring to a whole object. But now T refers to a single element, so fix it. + // If there's only 1 usage, replace it with 'object'. If there are multiple, create a new type constraint. + const typeParamSearch = new RegExp(`\\b${fixTypeParam.name}\\b(?:(?!(?:\\[keyof ${fixTypeParam.name})?\\])|$)`); + const matches = fixOverload.params.concat(fixOverload.returnType).filter(value => typeParamSearch.test(value)); + let replacement = "object"; + if (matches.length >= 2) { + let i = 1; + const newTypeParam: TypeParam = { name: "T" + i, extends: replacement }; + while (fixInterface.typeParams.some(t => t.name === newTypeParam.name) || fixOverload.typeParams.some(t => t.name === newTypeParam.name)) + newTypeParam.name = "T" + (++i); + fixOverload.typeParams.push(newTypeParam); + replacement = newTypeParam.name; + } + fixOverload.params = fixOverload.params + .map(p => p.replace(new RegExp(typeParamSearch, "g"), replacement) + .replace(new RegExp(`\\bArray<${fixTypeParam.name}\\[keyof ${fixTypeParam.name}]>`, "g"), fixTypeParam.name + "[]") + .replace(new RegExp(`\\b${fixTypeParam.name}\\[keyof ${fixTypeParam.name}]`, "g"), fixTypeParam.name)); + if (!new RegExp(`\\b${baseName}[0-9]+x[0-9]+\\b`).test(fixOverload.returnType)) { + fixOverload.returnType = fixOverload.returnType + .replace(new RegExp(typeParamSearch, "g"), replacement) + .replace(new RegExp(`\\bArray<${fixTypeParam.name}\\[keyof ${fixTypeParam.name}]>`, "g"), fixTypeParam.name + "[]") + .replace(new RegExp(`\\b${fixTypeParam.name}\\[keyof ${fixTypeParam.name}]`, "g"), fixTypeParam.name); + } + } + } + } else { + console.warn(`Fixed T[keyof T] overload, but could not find corresponding interface '${fixInterfaceName}'.`); + } + } + } + } + return interfaces; +} + +function curryParams( + baseName: string, + sourceOverloadId: number, + sourceOverload: Overload, + interfaceIndex: number, +): Interface { + const params = getInterfaceParams(sourceOverload, interfaceIndex); + const interfaceTypeParams = getInterfaceTypeParams(sourceOverload, interfaceIndex); + + const prevParams = _.without(sourceOverload.params, ...params); + const prevTypeParams = getUsedTypeParams(prevParams, sourceOverload.typeParams); + const typeParams = _.without(sourceOverload.typeParams, ...prevTypeParams); + // 1st overload takes no parameters and just returns the same interface (effectively a no-op) + // HACK: omit the parameterless overload because it's not very useful, and it causes the build to run out of memory + // This assumes params.length > 0, which is true because curryParams is only called when params.length >= 2. + /*const overloads: Overload[] = [{ + typeParams: [], + params: [], + returnType: getInterfaceName(baseName, sourceOverloadId, interfaceIndex, interfaceTypeParams), + jsdoc: sourceOverload.jsdoc, + }];*/ + const overloads: Overload[] = []; + const lastOverload = (1 << params.length) - 1; + for (let i = 1; i <= lastOverload; ++i) { + // xxxx i = number of parameters used by this overload + // const totalCombinations = nCk(params.length, i); + // i = binary representation of which parameters are used for this overload (reversed), e.g. + // 1 = 0001 -> 1000 = 1st parameter + // 6 = 1010 -> 0101 = 2nd and 4th parameters + const currentParams = params.map((p, j) => (i & (1 << j)) ? p : `${getParamName(p)}: __`); + while (currentParams.length > 0 && _.last(currentParams)!.endsWith("__")) + currentParams.pop(); // There's no point in passing a placeholder as the last parameter, so don't allow it. + + const usedTypeParams = i < lastOverload ? getUsedTypeParams(currentParams, typeParams) : typeParams; + const combinedIndex = combineIndexes(interfaceIndex, i); + const passTypeParams = getInterfaceTypeParams(sourceOverload, combinedIndex); + const currentReturnType = i < lastOverload ? getInterfaceName(baseName, sourceOverloadId, combinedIndex, passTypeParams) : sourceOverload.returnType; + + overloads.push({ + typeParams: _.cloneDeep(usedTypeParams), + params: currentParams, + returnType: currentReturnType, + jsdoc: interfaceIndex === 0 ? sourceOverload.jsdoc : "", + }); + } + const interfaceDef: Interface = { + name: getInterfaceName(baseName, sourceOverloadId, interfaceIndex, []), + typeParams: _.cloneDeep(interfaceTypeParams), + overloads, + constants: [], + }; + // Remove the `extends` constraint from interface type parameters, because sometimes they extend things that aren't passed to the interface. + for (const typeParam of interfaceDef.typeParams) { + // 1. retain `extends keyof X` constraints so that TObject[TKey] still works. + // 2. retain `any[]` constraints so that variadic generics work. + if (!_.startsWith(typeParam.extends, "keyof ") && typeParam.extends !== "any[]") + delete typeParam.extends; + } + return interfaceDef; +} + +function getInterfaceBaseName(functionName: string) { + return "Lodash" + _.upperFirst(functionName); +} + +function getInterfaceParams(overload: Overload, interfaceIndex: number) { + return overload.params.filter((p, j) => !(interfaceIndex & (1 << j))); +} + +function getUsedTypeParams(params: string[], typeParams: TypeParam[]) { + const usedTypeParams = typeParams.filter(tp => params.some(p => new RegExp(`\\b${tp.name}\\b`).test(p))); + usedTypeParams.unshift(...typeParams.filter(tp => + !usedTypeParams.includes(tp) && usedTypeParams.some(tp2 => !!tp2.extends && new RegExp(`\\b${tp.name}\\b`).test(tp2.extends)))); + return usedTypeParams; +} + +function getInterfaceTypeParams(overload: Overload, interfaceIndex: number) { + const currentParams = getInterfaceParams(overload, interfaceIndex); + const passedParams = _.without(overload.params, ...currentParams); + const passedTypeParams = getUsedTypeParams(passedParams, overload.typeParams); + const interfaceTypeParams = passedTypeParams.filter(tp => currentParams.concat(overload.returnType).some(p => new RegExp(`\\b${tp.name}\\b`).test(p))); + interfaceTypeParams.unshift(...overload.typeParams.filter(tp => + !interfaceTypeParams.includes(tp) && interfaceTypeParams.some(tp2 => !!tp2.extends && new RegExp(`^keyof ${tp.name}\\b`).test(tp2.extends)))); + return interfaceTypeParams; +} + +function mergeInterfaces(interfaces: Interface[]): void { + const mainInterface = interfaces[0]; + if (!mainInterface) + return; + mainInterface.overloads = _.uniqWith(_.flatMap(interfaces, i => i.overloads), _.isEqual); +} + +function mergeSimilarOverloads(overloads: Overload[]): Overload[] { + const newOverloads = _.cloneDeep(overloads); + for (const overload of newOverloads) { + // We can merge if all param types are the same except one, and the return types are the same. + // Also, we can't merge a placeholder param with a non-placeholder. + const others = newOverloads.filter(o2 => o2 !== overload + && _.isEqual(overload.typeParams, o2.typeParams) + && overload.params.length === o2.params.length + && overload.params.length >= 1 + && overload.params.every((p, i) => isPlaceholder(p) === isPlaceholder(o2.params[i])) + && overload.params.filter((p, i) => getParamType(p) !== getParamType(o2.params[i])).length <= 1 + && overload.returnType === o2.returnType); + if (_.isEmpty(others)) + continue; + + const differingParamIndexes = _(others) + .map(o2 => overload.params.findIndex((p, i) => getParamType(p) !== getParamType(o2.params[i]))) + .filter(i => i !== -1) + .uniq() + .value(); + if (differingParamIndexes.length > 1) + continue; // Only one param is different, but it's a different param for some overloads, so we can't merge + const similarOverloads = [overload].concat(others); + for (let i = 0; i < overload.params.length; ++i) { + const paramNames = _.uniq(similarOverloads.map(o => getParamName(o.params[i]))); + const newParamName = (paramNames.length > 1) ? `${paramNames[0]}Or${paramNames.slice(1).map(_.upperFirst).join("Or")}` : paramNames[0]; + + const newParamType = _(similarOverloads) + .map(o => o.params[i]) + .flatMap(p => getParamType(p).split("|")) + .map(_.trim) + .uniq() + .sortBy(type => type === "undefined" ? 2 : (type === "null" ? 1 : 0)) + .join(" | "); + overload.params[i] = `${newParamName}: ${newParamType}`; + } + _.pull(newOverloads, ...others); + } + return newOverloads; +} + +function combineIndexes(i1: number, i2: number): number { + let result = i1; + let resultMask = 1; + for (let i2mask = 1; i2mask <= i2; i2mask <<= 1) { + while (result & resultMask) + resultMask <<= 1; + if (i2 & i2mask) + result += resultMask; + resultMask <<= 1; + } + return result; +} + +function getInterfaceName(baseName: string, overloadId: number, index: number, typeParams: TypeParam[]): string { + let interfaceName = baseName; + if (index > 0) + interfaceName += `${overloadId}x${index}${typeParamsToString(typeParams, false)}`; + return interfaceName; +} + +function interfaceToString(interfaceDef: Interface): string { + if (_.isEmpty(interfaceDef.overloads)) { + // No point in creating an empty interface + return ""; + } else if (interfaceDef.overloads.length === 1 && _.isEmpty(interfaceDef.constants)) { + // Don't create an interface for a single type. Instead use a basic type def. + const overload = interfaceDef.overloads[0]; + // HACK: omit jsdoc comments because they cause the build to run out of memory + // const jsdoc = overload.jsdoc; + const jsdoc = ""; + overload.jsdoc = ""; + let overloadString = overloadToString(overload, true); + overloadString = jsdoc ? lineBreak + tab(jsdoc + lineBreak + overloadString, 1) : " " + overloadString; + return `type ${interfaceDef.name}${typeParamsToString(interfaceDef.typeParams)} =${overloadString}`; + } else { + const overloadStrings = interfaceDef.overloads.map(o => lineBreak + tab(overloadToString(o), 1)).join("") + + interfaceDef.constants.map(c => `${lineBreak}${tab(c, 1)};`).join(""); + return `interface ${interfaceDef.name}${typeParamsToString(interfaceDef.typeParams)} {${overloadStrings}${lineBreak}}`; + } +} + +function overloadToString(overload: Overload, arrowSyntax = false): string { + const joinedParams = overload.params.join(", "); + // HACK: omit jsdoc comments because they cause the build to run out of memory + // let jsdoc = overload.jsdoc; + let jsdoc = ""; + if (jsdoc) + jsdoc += lineBreak; + if (overload.tslintDisable) + jsdoc += overload.tslintDisable + lineBreak; + return `${jsdoc}${typeParamsToString(overload.typeParams)}(${joinedParams})${arrowSyntax ? " =>" : ":"} ${overload.returnType};`; +} + +function typeParamsToString(typeParams: TypeParam[], includeConstraints = true): string { + return typeParams.length > 0 ? `<${typeParams.map(tp => + tp.name + + (includeConstraints && tp.extends ? " extends " + tp.extends : "") + + (includeConstraints && tp.equals ? " = " + tp.equals : "") + ).join(", ")}>` : ""; +} + +function getPreviousLine(s: string, index: number): string { + const eol = s.lastIndexOf(lineBreak, index); + if (eol === -1) + return ""; + const bol = s.lastIndexOf(lineBreak, eol - 1); + if (bol === -1) + return ""; + return s.substring(bol + 1, eol); +} + +function indexOfAny(source: string, values: string[], position?: number): number { + const indexes: number[] = []; + for (const value of values) { + const index = source.indexOf(value, position); + if (index !== -1) + indexes.push(index); + } + return indexes.length > 0 ? _.min(indexes)! : -1; +} + +main(); diff --git a/types/lodash/ts3.1/scripts/generate-modules.ts b/types/lodash/ts3.1/scripts/generate-modules.ts new file mode 100644 index 0000000000..6965242937 --- /dev/null +++ b/types/lodash/ts3.1/scripts/generate-modules.ts @@ -0,0 +1,440 @@ +// Usage: ts-node generate-modules.ts + +/// + +import * as fs from "fs"; +import { get, STATUS_CODES } from "http"; +import * as path from "path"; + +main().catch(console.error); + +async function main(): Promise { + const all = allModuleNames(); + const allSet = new Set(allModuleNames()); + const notOnNpm = new Set(modulesNotOnNpm()); + for (const n of notOnNpm) { + if (!allSet.has(n)) { + throw new Error(n); + } + } + + // Generate lodash/tsconfig.json + fs.writeFileSync(path.join("..", "tsconfig.json"), lodashTsconfig(all)); + + for (const module of all) { + console.log(module); + + // Generate local module + fs.writeFileSync(path.join("..", `${module}.d.ts`), `import { ${module} } from "./index";\nexport = ${module};\n`); + + // Generate `lodash.foo` module + if (!notOnNpm.has(module)) { + const dir = path.join("..", "..", `lodash.${module.toLowerCase()}`); + ensureDir(dir); + fs.writeFileSync(path.join(dir, "index.d.ts"), await globalDefinitionText(module)); + fs.writeFileSync(path.join(dir, "tsconfig.json"), lodashDotFooTsconfig()); + fs.writeFileSync(path.join(dir, "tslint.json"), tslint()); + } + } +} + +function ensureDir(dir: string): void { + if (!fs.existsSync(dir)) { + fs.mkdirSync(dir); + } +} + +async function globalDefinitionText(moduleName: string): Promise { + const fullName = "lodash." + moduleName; + const url = `http://registry.npmjs.org/${fullName.toLowerCase()}`; + const npmInfo = JSON.parse(await loadString(url)); + const fullVersion = npmInfo["dist-tags"].latest; + const majorMinor = fullVersion.split(".").slice(0, 2).join("."); + + return ` +// Type definitions for ${fullName} ${majorMinor} +// Project: http://lodash.com/ +// Definitions by: Brian Zengel , Ilya Mochalov , Stepan Mikhaylyuk +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +// TypeScript Version: 2.8 + +// Generated from https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/lodash/scripts/generate-modules.ts + +import { ${moduleName} } from "lodash"; +export = ${moduleName}; +`.trim() + "\n"; +} + +function compilerOptions(): object { + return { + "module": "commonjs", + "lib": [ + "es6" + ], + "noImplicitAny": true, + "noImplicitThis": true, + "strictNullChecks": true, + "strictFunctionTypes": true, + "baseUrl": "../", + "typeRoots": [ + "../" + ], + "types": [], + "noEmit": true, + "forceConsistentCasingInFileNames": true + }; +} + +function lodashTsconfig(moduleNames: ReadonlyArray): string { + return JSON.stringify({ + compilerOptions: compilerOptions(), + files: [ + "index.d.ts", + "lodash-tests.ts", + ...moduleNames.map(m => `${m}.d.ts`), + ] + }, undefined, 4); +} + +function lodashDotFooTsconfig(): string { + return JSON.stringify({ + compilerOptions: compilerOptions(), + files: ["index.d.ts"], + }, undefined, 4); +} + +function tslint(): string { + return `{ "extends": "dtslint/dt.json" }\n`; +} + +function loadString(url: string): Promise { + return new Promise((resolve, reject) => { + get(url, (res) => { + if (res.statusCode !== 200) { + return reject(new Error(`HTTP Error ${res.statusCode}: ${STATUS_CODES[res.statusCode || 500]} for ${url}`)) + } + let rawData = "" + res.on("data", chunk => rawData += chunk) + res.on("end", () => resolve(rawData)) + }).on("error", e => reject(e)) + }) +} + +function modulesNotOnNpm(): string[] { + return [ + "chain", + "each", + "eachRight", + "entries", + "entriesIn", + "extend", + "extendWith", + "noConflict", + "runInContext", + "tap", + "thru", + ]; +} + +// Note: "fb" is not a usual module, so it is made by hand. + +function allModuleNames(): string[] { + return [ + "add", + "after", + "ary", + "assign", + "assignIn", + "assignInWith", + "assignWith", + "at", + "attempt", + "before", + "bind", + "bindAll", + "bindKey", + "camelCase", + "capitalize", + "castArray", + "ceil", + "chain", + "chunk", + "clamp", + "clone", + "cloneDeep", + "cloneDeepWith", + "cloneWith", + "compact", + "concat", + "cond", + "constant", + "countBy", + "create", + "curry", + "curryRight", + "debounce", + "deburr", + "defaults", + "defaultsDeep", + "defer", + "delay", + "difference", + "differenceBy", + "differenceWith", + "divide", + "drop", + "dropRight", + "dropRightWhile", + "dropWhile", + "each", + "eachRight", + "endsWith", + "entries", + "entriesIn", + "eq", + "escape", + "escapeRegExp", + "every", + "extend", + "extendWith", + "fill", + "filter", + "find", + "findIndex", + "findKey", + "findLast", + "findLastIndex", + "findLastKey", + "first", + "flatMap", + "flatMapDeep", + "flatMapDepth", + "flatten", + "flattenDeep", + "flattenDepth", + "flip", + "floor", + "flow", + "flowRight", + "forEach", + "forEachRight", + "forIn", + "forInRight", + "forOwn", + "forOwnRight", + "fromPairs", + "functions", + "functionsIn", + "get", + "groupBy", + "gt", + "gte", + "has", + "hasIn", + "head", + "identity", + "includes", + "indexOf", + "initial", + "inRange", + "intersection", + "intersectionBy", + "intersectionWith", + "invert", + "invertBy", + "invoke", + "invokeMap", + "isArguments", + "isArray", + "isArrayBuffer", + "isArrayLike", + "isArrayLikeObject", + "isBoolean", + "isBuffer", + "isDate", + "isElement", + "isEmpty", + "isEqual", + "isEqualWith", + "isError", + "isFinite", + "isFunction", + "isInteger", + "isLength", + "isMap", + "isMatch", + "isMatchWith", + "isNaN", + "isNative", + "isNil", + "isNull", + "isNumber", + "isObject", + "isObjectLike", + "isPlainObject", + "isRegExp", + "isSafeInteger", + "isSet", + "isString", + "isSymbol", + "isTypedArray", + "isUndefined", + "isWeakMap", + "isWeakSet", + "iteratee", + "join", + "kebabCase", + "keyBy", + "keys", + "keysIn", + "last", + "lastIndexOf", + "lowerCase", + "lowerFirst", + "lt", + "lte", + "map", + "mapKeys", + "mapValues", + "matches", + "matchesProperty", + "max", + "maxBy", + "mean", + "meanBy", + "memoize", + "merge", + "mergeWith", + "method", + "methodOf", + "min", + "minBy", + "mixin", + "negate", + "noConflict", + "noop", + "now", + "nth", + "nthArg", + "omit", + "omitBy", + "once", + "orderBy", + "over", + "overArgs", + "overEvery", + "overSome", + "pad", + "padEnd", + "padStart", + "parseInt", + "partial", + "partialRight", + "partition", + "pick", + "pickBy", + "property", + "propertyOf", + "pull", + "pullAll", + "pullAllBy", + "pullAllWith", + "pullAt", + "random", + "range", + "rangeRight", + "rearg", + "reduce", + "reduceRight", + "reject", + "remove", + "repeat", + "replace", + "rest", + "result", + "reverse", + "round", + "runInContext", + "sample", + "sampleSize", + "set", + "setWith", + "shuffle", + "size", + "slice", + "snakeCase", + "some", + "sortBy", + "sortedIndex", + "sortedIndexBy", + "sortedIndexOf", + "sortedLastIndex", + "sortedLastIndexBy", + "sortedLastIndexOf", + "sortedUniq", + "sortedUniqBy", + "split", + "spread", + "startCase", + "startsWith", + "subtract", + "sum", + "sumBy", + "tail", + "take", + "takeRight", + "takeRightWhile", + "takeWhile", + "tap", + "template", + "throttle", + "thru", + "times", + "toArray", + "toFinite", + "toInteger", + "toLength", + "toLower", + "toNumber", + "toPairs", + "toPairsIn", + "toPath", + "toPlainObject", + "toSafeInteger", + "toString", + "toUpper", + "transform", + "trim", + "trimEnd", + "trimStart", + "truncate", + "unary", + "unescape", + "union", + "unionBy", + "unionWith", + "uniq", + "uniqBy", + "uniqueId", + "uniqWith", + "unset", + "unzip", + "unzipWith", + "update", + "updateWith", + "upperCase", + "upperFirst", + "values", + "valuesIn", + "without", + "words", + "wrap", + "xor", + "xorBy", + "xorWith", + "zip", + "zipObject", + "zipObjectDeep", + "zipWith" + ]; +} diff --git a/types/lodash/ts3.1/scripts/package.json b/types/lodash/ts3.1/scripts/package.json new file mode 100644 index 0000000000..8df14b85cc --- /dev/null +++ b/types/lodash/ts3.1/scripts/package.json @@ -0,0 +1,18 @@ +{ + "private": true, + "name": "lodash-scripts", + "version": "0.0.1", + "scripts": { + "generate": "ts-node generate-fp", + "fp": "ts-node generate-fp", + }, + "devDependencies": { + "lodash": "^4.17.11", + "ts-node": "^4.1.0", + "typescript": "^2.7.1" + }, + "dependencies": { + "@types/lodash": "^4.14.123", + "@types/node": "^11.13.9" + } +} diff --git a/types/lodash/ts3.1/scripts/tsconfig.json b/types/lodash/ts3.1/scripts/tsconfig.json new file mode 100644 index 0000000000..e6077b42a7 --- /dev/null +++ b/types/lodash/ts3.1/scripts/tsconfig.json @@ -0,0 +1,18 @@ +{ + "compilerOptions": { + "target": "es2017", + "module": "commonjs", + "baseUrl": "../..", + "esModuleInterop": true, + "noEmit": false, + "noImplicitAny": true, + "pretty": true, + "strict": true, + "typeRoots": [ + "../../" + ], + "types": [ + "node" + ] + } +} diff --git a/types/lodash/ts3.1/scripts/utils.ts b/types/lodash/ts3.1/scripts/utils.ts new file mode 100644 index 0000000000..59bdd448a9 --- /dev/null +++ b/types/lodash/ts3.1/scripts/utils.ts @@ -0,0 +1,38 @@ +import fs from "fs"; +import _ from "lodash"; +import path from "path"; + +export function readFile(filePath: string): Promise { + return new Promise((resolve, reject) => { + fs.readFile(filePath, "utf8", (err, data) => { + if (err) { + reject(err); + return; + } + try { + resolve(data); + } catch (e) { + reject(e); + } + }); + }); +} + +let lineBreak = "\n"; + +/** Gets the correct line break for the current OS (git for windows will generally convert \n to \r\n during checkout) */ +export async function getLineBreak(): Promise { + const tsconfigPath = path.join("..", "tsconfig.json"); + const tsconfigFile = await readFile(tsconfigPath); + lineBreak = _.find(["\r\n", "\n", "\r"], x => tsconfigFile.includes(x)) || "\n"; + return lineBreak; +} + +export function getLineNumber(fileContents: string, index: number) { + return fileContents.substring(0, index).split(/\r\n|\n|\r/g).length + 1; +} + +export function tab(s: string, count: number) { + const prepend: string = " ".repeat(count * 4); + return (s[0] === "\n" || s[0] === "\r" ? "" : prepend) + s.replace(/(?:\r\n|\n|\r)(.)/g, `${lineBreak}${prepend}$1`); +} diff --git a/types/lodash/ts3.1/set.d.ts b/types/lodash/ts3.1/set.d.ts new file mode 100644 index 0000000000..09d0c24706 --- /dev/null +++ b/types/lodash/ts3.1/set.d.ts @@ -0,0 +1,2 @@ +import { set } from "./index"; +export = set; diff --git a/types/lodash/ts3.1/setWith.d.ts b/types/lodash/ts3.1/setWith.d.ts new file mode 100644 index 0000000000..d4e319a051 --- /dev/null +++ b/types/lodash/ts3.1/setWith.d.ts @@ -0,0 +1,2 @@ +import { setWith } from "./index"; +export = setWith; diff --git a/types/lodash/ts3.1/shuffle.d.ts b/types/lodash/ts3.1/shuffle.d.ts new file mode 100644 index 0000000000..ff96f884bc --- /dev/null +++ b/types/lodash/ts3.1/shuffle.d.ts @@ -0,0 +1,2 @@ +import { shuffle } from "./index"; +export = shuffle; diff --git a/types/lodash/ts3.1/size.d.ts b/types/lodash/ts3.1/size.d.ts new file mode 100644 index 0000000000..13d492f390 --- /dev/null +++ b/types/lodash/ts3.1/size.d.ts @@ -0,0 +1,2 @@ +import { size } from "./index"; +export = size; diff --git a/types/lodash/ts3.1/slice.d.ts b/types/lodash/ts3.1/slice.d.ts new file mode 100644 index 0000000000..311d2fa5d8 --- /dev/null +++ b/types/lodash/ts3.1/slice.d.ts @@ -0,0 +1,2 @@ +import { slice } from "./index"; +export = slice; diff --git a/types/lodash/ts3.1/snakeCase.d.ts b/types/lodash/ts3.1/snakeCase.d.ts new file mode 100644 index 0000000000..8245a7da1d --- /dev/null +++ b/types/lodash/ts3.1/snakeCase.d.ts @@ -0,0 +1,2 @@ +import { snakeCase } from "./index"; +export = snakeCase; diff --git a/types/lodash/ts3.1/some.d.ts b/types/lodash/ts3.1/some.d.ts new file mode 100644 index 0000000000..90ef478bbe --- /dev/null +++ b/types/lodash/ts3.1/some.d.ts @@ -0,0 +1,2 @@ +import { some } from "./index"; +export = some; diff --git a/types/lodash/ts3.1/sortBy.d.ts b/types/lodash/ts3.1/sortBy.d.ts new file mode 100644 index 0000000000..5f3d4f2a7b --- /dev/null +++ b/types/lodash/ts3.1/sortBy.d.ts @@ -0,0 +1,2 @@ +import { sortBy } from "./index"; +export = sortBy; diff --git a/types/lodash/ts3.1/sortedIndex.d.ts b/types/lodash/ts3.1/sortedIndex.d.ts new file mode 100644 index 0000000000..c9c79114d0 --- /dev/null +++ b/types/lodash/ts3.1/sortedIndex.d.ts @@ -0,0 +1,2 @@ +import { sortedIndex } from "./index"; +export = sortedIndex; diff --git a/types/lodash/ts3.1/sortedIndexBy.d.ts b/types/lodash/ts3.1/sortedIndexBy.d.ts new file mode 100644 index 0000000000..fdbedac570 --- /dev/null +++ b/types/lodash/ts3.1/sortedIndexBy.d.ts @@ -0,0 +1,2 @@ +import { sortedIndexBy } from "./index"; +export = sortedIndexBy; diff --git a/types/lodash/ts3.1/sortedIndexOf.d.ts b/types/lodash/ts3.1/sortedIndexOf.d.ts new file mode 100644 index 0000000000..a076c4a40e --- /dev/null +++ b/types/lodash/ts3.1/sortedIndexOf.d.ts @@ -0,0 +1,2 @@ +import { sortedIndexOf } from "./index"; +export = sortedIndexOf; diff --git a/types/lodash/ts3.1/sortedLastIndex.d.ts b/types/lodash/ts3.1/sortedLastIndex.d.ts new file mode 100644 index 0000000000..808c2c0ff2 --- /dev/null +++ b/types/lodash/ts3.1/sortedLastIndex.d.ts @@ -0,0 +1,2 @@ +import { sortedLastIndex } from "./index"; +export = sortedLastIndex; diff --git a/types/lodash/ts3.1/sortedLastIndexBy.d.ts b/types/lodash/ts3.1/sortedLastIndexBy.d.ts new file mode 100644 index 0000000000..9f23b9b83f --- /dev/null +++ b/types/lodash/ts3.1/sortedLastIndexBy.d.ts @@ -0,0 +1,2 @@ +import { sortedLastIndexBy } from "./index"; +export = sortedLastIndexBy; diff --git a/types/lodash/ts3.1/sortedLastIndexOf.d.ts b/types/lodash/ts3.1/sortedLastIndexOf.d.ts new file mode 100644 index 0000000000..abdeba0246 --- /dev/null +++ b/types/lodash/ts3.1/sortedLastIndexOf.d.ts @@ -0,0 +1,2 @@ +import { sortedLastIndexOf } from "./index"; +export = sortedLastIndexOf; diff --git a/types/lodash/ts3.1/sortedUniq.d.ts b/types/lodash/ts3.1/sortedUniq.d.ts new file mode 100644 index 0000000000..257d35aeaa --- /dev/null +++ b/types/lodash/ts3.1/sortedUniq.d.ts @@ -0,0 +1,2 @@ +import { sortedUniq } from "./index"; +export = sortedUniq; diff --git a/types/lodash/ts3.1/sortedUniqBy.d.ts b/types/lodash/ts3.1/sortedUniqBy.d.ts new file mode 100644 index 0000000000..316156ec2a --- /dev/null +++ b/types/lodash/ts3.1/sortedUniqBy.d.ts @@ -0,0 +1,2 @@ +import { sortedUniqBy } from "./index"; +export = sortedUniqBy; diff --git a/types/lodash/ts3.1/split.d.ts b/types/lodash/ts3.1/split.d.ts new file mode 100644 index 0000000000..8879eb004d --- /dev/null +++ b/types/lodash/ts3.1/split.d.ts @@ -0,0 +1,2 @@ +import { split } from "./index"; +export = split; diff --git a/types/lodash/ts3.1/spread.d.ts b/types/lodash/ts3.1/spread.d.ts new file mode 100644 index 0000000000..4f816b2ab4 --- /dev/null +++ b/types/lodash/ts3.1/spread.d.ts @@ -0,0 +1,2 @@ +import { spread } from "./index"; +export = spread; diff --git a/types/lodash/ts3.1/startCase.d.ts b/types/lodash/ts3.1/startCase.d.ts new file mode 100644 index 0000000000..c201a11c6d --- /dev/null +++ b/types/lodash/ts3.1/startCase.d.ts @@ -0,0 +1,2 @@ +import { startCase } from "./index"; +export = startCase; diff --git a/types/lodash/ts3.1/startsWith.d.ts b/types/lodash/ts3.1/startsWith.d.ts new file mode 100644 index 0000000000..a18b54f584 --- /dev/null +++ b/types/lodash/ts3.1/startsWith.d.ts @@ -0,0 +1,2 @@ +import { startsWith } from "./index"; +export = startsWith; diff --git a/types/lodash/ts3.1/subtract.d.ts b/types/lodash/ts3.1/subtract.d.ts new file mode 100644 index 0000000000..6502fe2f44 --- /dev/null +++ b/types/lodash/ts3.1/subtract.d.ts @@ -0,0 +1,2 @@ +import { subtract } from "./index"; +export = subtract; diff --git a/types/lodash/ts3.1/sum.d.ts b/types/lodash/ts3.1/sum.d.ts new file mode 100644 index 0000000000..4e01cb4aad --- /dev/null +++ b/types/lodash/ts3.1/sum.d.ts @@ -0,0 +1,2 @@ +import { sum } from "./index"; +export = sum; diff --git a/types/lodash/ts3.1/sumBy.d.ts b/types/lodash/ts3.1/sumBy.d.ts new file mode 100644 index 0000000000..92c4342aad --- /dev/null +++ b/types/lodash/ts3.1/sumBy.d.ts @@ -0,0 +1,2 @@ +import { sumBy } from "./index"; +export = sumBy; diff --git a/types/lodash/ts3.1/tail.d.ts b/types/lodash/ts3.1/tail.d.ts new file mode 100644 index 0000000000..2d80b444b1 --- /dev/null +++ b/types/lodash/ts3.1/tail.d.ts @@ -0,0 +1,2 @@ +import { tail } from "./index"; +export = tail; diff --git a/types/lodash/ts3.1/take.d.ts b/types/lodash/ts3.1/take.d.ts new file mode 100644 index 0000000000..be9912245d --- /dev/null +++ b/types/lodash/ts3.1/take.d.ts @@ -0,0 +1,2 @@ +import { take } from "./index"; +export = take; diff --git a/types/lodash/ts3.1/takeRight.d.ts b/types/lodash/ts3.1/takeRight.d.ts new file mode 100644 index 0000000000..9d78866478 --- /dev/null +++ b/types/lodash/ts3.1/takeRight.d.ts @@ -0,0 +1,2 @@ +import { takeRight } from "./index"; +export = takeRight; diff --git a/types/lodash/ts3.1/takeRightWhile.d.ts b/types/lodash/ts3.1/takeRightWhile.d.ts new file mode 100644 index 0000000000..3b293de7ae --- /dev/null +++ b/types/lodash/ts3.1/takeRightWhile.d.ts @@ -0,0 +1,2 @@ +import { takeRightWhile } from "./index"; +export = takeRightWhile; diff --git a/types/lodash/ts3.1/takeWhile.d.ts b/types/lodash/ts3.1/takeWhile.d.ts new file mode 100644 index 0000000000..088234a8a0 --- /dev/null +++ b/types/lodash/ts3.1/takeWhile.d.ts @@ -0,0 +1,2 @@ +import { takeWhile } from "./index"; +export = takeWhile; diff --git a/types/lodash/ts3.1/tap.d.ts b/types/lodash/ts3.1/tap.d.ts new file mode 100644 index 0000000000..e15a13cf43 --- /dev/null +++ b/types/lodash/ts3.1/tap.d.ts @@ -0,0 +1,2 @@ +import { tap } from "./index"; +export = tap; diff --git a/types/lodash/ts3.1/template.d.ts b/types/lodash/ts3.1/template.d.ts new file mode 100644 index 0000000000..854e7539bd --- /dev/null +++ b/types/lodash/ts3.1/template.d.ts @@ -0,0 +1,2 @@ +import { template } from "./index"; +export = template; diff --git a/types/lodash/ts3.1/throttle.d.ts b/types/lodash/ts3.1/throttle.d.ts new file mode 100644 index 0000000000..2650896a0a --- /dev/null +++ b/types/lodash/ts3.1/throttle.d.ts @@ -0,0 +1,2 @@ +import { throttle } from "./index"; +export = throttle; diff --git a/types/lodash/ts3.1/thru.d.ts b/types/lodash/ts3.1/thru.d.ts new file mode 100644 index 0000000000..0447e1271e --- /dev/null +++ b/types/lodash/ts3.1/thru.d.ts @@ -0,0 +1,2 @@ +import { thru } from "./index"; +export = thru; diff --git a/types/lodash/ts3.1/times.d.ts b/types/lodash/ts3.1/times.d.ts new file mode 100644 index 0000000000..7fda4de03b --- /dev/null +++ b/types/lodash/ts3.1/times.d.ts @@ -0,0 +1,2 @@ +import { times } from "./index"; +export = times; diff --git a/types/lodash/ts3.1/toArray.d.ts b/types/lodash/ts3.1/toArray.d.ts new file mode 100644 index 0000000000..dd94c8a967 --- /dev/null +++ b/types/lodash/ts3.1/toArray.d.ts @@ -0,0 +1,2 @@ +import { toArray } from "./index"; +export = toArray; diff --git a/types/lodash/ts3.1/toFinite.d.ts b/types/lodash/ts3.1/toFinite.d.ts new file mode 100644 index 0000000000..c575b47847 --- /dev/null +++ b/types/lodash/ts3.1/toFinite.d.ts @@ -0,0 +1,2 @@ +import { toFinite } from "./index"; +export = toFinite; diff --git a/types/lodash/ts3.1/toInteger.d.ts b/types/lodash/ts3.1/toInteger.d.ts new file mode 100644 index 0000000000..021a9c0891 --- /dev/null +++ b/types/lodash/ts3.1/toInteger.d.ts @@ -0,0 +1,2 @@ +import { toInteger } from "./index"; +export = toInteger; diff --git a/types/lodash/ts3.1/toLength.d.ts b/types/lodash/ts3.1/toLength.d.ts new file mode 100644 index 0000000000..41a4098c2e --- /dev/null +++ b/types/lodash/ts3.1/toLength.d.ts @@ -0,0 +1,2 @@ +import { toLength } from "./index"; +export = toLength; diff --git a/types/lodash/ts3.1/toLower.d.ts b/types/lodash/ts3.1/toLower.d.ts new file mode 100644 index 0000000000..766c173ee6 --- /dev/null +++ b/types/lodash/ts3.1/toLower.d.ts @@ -0,0 +1,2 @@ +import { toLower } from "./index"; +export = toLower; diff --git a/types/lodash/ts3.1/toNumber.d.ts b/types/lodash/ts3.1/toNumber.d.ts new file mode 100644 index 0000000000..a6c5e1fc0d --- /dev/null +++ b/types/lodash/ts3.1/toNumber.d.ts @@ -0,0 +1,2 @@ +import { toNumber } from "./index"; +export = toNumber; diff --git a/types/lodash/ts3.1/toPairs.d.ts b/types/lodash/ts3.1/toPairs.d.ts new file mode 100644 index 0000000000..4a7846ed29 --- /dev/null +++ b/types/lodash/ts3.1/toPairs.d.ts @@ -0,0 +1,2 @@ +import { toPairs } from "./index"; +export = toPairs; diff --git a/types/lodash/ts3.1/toPairsIn.d.ts b/types/lodash/ts3.1/toPairsIn.d.ts new file mode 100644 index 0000000000..82d71b3f49 --- /dev/null +++ b/types/lodash/ts3.1/toPairsIn.d.ts @@ -0,0 +1,2 @@ +import { toPairsIn } from "./index"; +export = toPairsIn; diff --git a/types/lodash/ts3.1/toPath.d.ts b/types/lodash/ts3.1/toPath.d.ts new file mode 100644 index 0000000000..ff354e5d32 --- /dev/null +++ b/types/lodash/ts3.1/toPath.d.ts @@ -0,0 +1,2 @@ +import { toPath } from "./index"; +export = toPath; diff --git a/types/lodash/ts3.1/toPlainObject.d.ts b/types/lodash/ts3.1/toPlainObject.d.ts new file mode 100644 index 0000000000..0561ab6cd8 --- /dev/null +++ b/types/lodash/ts3.1/toPlainObject.d.ts @@ -0,0 +1,2 @@ +import { toPlainObject } from "./index"; +export = toPlainObject; diff --git a/types/lodash/ts3.1/toSafeInteger.d.ts b/types/lodash/ts3.1/toSafeInteger.d.ts new file mode 100644 index 0000000000..6bb24d8952 --- /dev/null +++ b/types/lodash/ts3.1/toSafeInteger.d.ts @@ -0,0 +1,2 @@ +import { toSafeInteger } from "./index"; +export = toSafeInteger; diff --git a/types/lodash/ts3.1/toString.d.ts b/types/lodash/ts3.1/toString.d.ts new file mode 100644 index 0000000000..7765d108af --- /dev/null +++ b/types/lodash/ts3.1/toString.d.ts @@ -0,0 +1,2 @@ +import { toString } from "./index"; +export = toString; diff --git a/types/lodash/ts3.1/toUpper.d.ts b/types/lodash/ts3.1/toUpper.d.ts new file mode 100644 index 0000000000..af43041229 --- /dev/null +++ b/types/lodash/ts3.1/toUpper.d.ts @@ -0,0 +1,2 @@ +import { toUpper } from "./index"; +export = toUpper; diff --git a/types/lodash/ts3.1/transform.d.ts b/types/lodash/ts3.1/transform.d.ts new file mode 100644 index 0000000000..05e6543410 --- /dev/null +++ b/types/lodash/ts3.1/transform.d.ts @@ -0,0 +1,2 @@ +import { transform } from "./index"; +export = transform; diff --git a/types/lodash/ts3.1/trim.d.ts b/types/lodash/ts3.1/trim.d.ts new file mode 100644 index 0000000000..7d0bf90b77 --- /dev/null +++ b/types/lodash/ts3.1/trim.d.ts @@ -0,0 +1,2 @@ +import { trim } from "./index"; +export = trim; diff --git a/types/lodash/ts3.1/trimEnd.d.ts b/types/lodash/ts3.1/trimEnd.d.ts new file mode 100644 index 0000000000..b80c844814 --- /dev/null +++ b/types/lodash/ts3.1/trimEnd.d.ts @@ -0,0 +1,2 @@ +import { trimEnd } from "./index"; +export = trimEnd; diff --git a/types/lodash/ts3.1/trimStart.d.ts b/types/lodash/ts3.1/trimStart.d.ts new file mode 100644 index 0000000000..a040712eb1 --- /dev/null +++ b/types/lodash/ts3.1/trimStart.d.ts @@ -0,0 +1,2 @@ +import { trimStart } from "./index"; +export = trimStart; diff --git a/types/lodash/ts3.1/truncate.d.ts b/types/lodash/ts3.1/truncate.d.ts new file mode 100644 index 0000000000..0ae065b303 --- /dev/null +++ b/types/lodash/ts3.1/truncate.d.ts @@ -0,0 +1,2 @@ +import { truncate } from "./index"; +export = truncate; diff --git a/types/lodash/ts3.1/tsconfig.json b/types/lodash/ts3.1/tsconfig.json new file mode 100644 index 0000000000..0ed8121a5e --- /dev/null +++ b/types/lodash/ts3.1/tsconfig.json @@ -0,0 +1,721 @@ +{ + "compilerOptions": { + "module": "commonjs", + "lib": [ + "es6" + ], + "noImplicitAny": true, + "noImplicitThis": true, + "strictFunctionTypes": true, + "strictNullChecks": true, + "baseUrl": "../../", + "typeRoots": [ + "../../" + ], + "types": [], + "noEmit": true, + "forceConsistentCasingInFileNames": true, + "esModuleInterop": true + }, + "files": [ + "index.d.ts", + "lodash-tests.ts", + "add.d.ts", + "after.d.ts", + "ary.d.ts", + "assign.d.ts", + "assignIn.d.ts", + "assignInWith.d.ts", + "assignWith.d.ts", + "at.d.ts", + "attempt.d.ts", + "before.d.ts", + "bind.d.ts", + "bindAll.d.ts", + "bindKey.d.ts", + "camelCase.d.ts", + "capitalize.d.ts", + "castArray.d.ts", + "ceil.d.ts", + "chain.d.ts", + "chunk.d.ts", + "clamp.d.ts", + "clone.d.ts", + "cloneDeep.d.ts", + "cloneDeepWith.d.ts", + "cloneWith.d.ts", + "compact.d.ts", + "concat.d.ts", + "cond.d.ts", + "conformsTo.d.ts", + "constant.d.ts", + "countBy.d.ts", + "create.d.ts", + "curry.d.ts", + "curryRight.d.ts", + "debounce.d.ts", + "deburr.d.ts", + "defaults.d.ts", + "defaultsDeep.d.ts", + "defaultTo.d.ts", + "defer.d.ts", + "delay.d.ts", + "difference.d.ts", + "differenceBy.d.ts", + "differenceWith.d.ts", + "divide.d.ts", + "drop.d.ts", + "dropRight.d.ts", + "dropRightWhile.d.ts", + "dropWhile.d.ts", + "each.d.ts", + "eachRight.d.ts", + "endsWith.d.ts", + "entries.d.ts", + "entriesIn.d.ts", + "eq.d.ts", + "escape.d.ts", + "escapeRegExp.d.ts", + "every.d.ts", + "extend.d.ts", + "extendWith.d.ts", + "fill.d.ts", + "filter.d.ts", + "find.d.ts", + "findIndex.d.ts", + "findKey.d.ts", + "findLast.d.ts", + "findLastIndex.d.ts", + "findLastKey.d.ts", + "first.d.ts", + "flatMap.d.ts", + "flatMapDeep.d.ts", + "flatMapDepth.d.ts", + "flatten.d.ts", + "flattenDeep.d.ts", + "flattenDepth.d.ts", + "flip.d.ts", + "floor.d.ts", + "flow.d.ts", + "flowRight.d.ts", + "forEach.d.ts", + "forEachRight.d.ts", + "forIn.d.ts", + "forInRight.d.ts", + "forOwn.d.ts", + "forOwnRight.d.ts", + "fp.d.ts", + "fromPairs.d.ts", + "functions.d.ts", + "functionsIn.d.ts", + "get.d.ts", + "groupBy.d.ts", + "gt.d.ts", + "gte.d.ts", + "has.d.ts", + "hasIn.d.ts", + "head.d.ts", + "identity.d.ts", + "includes.d.ts", + "indexOf.d.ts", + "initial.d.ts", + "inRange.d.ts", + "intersection.d.ts", + "intersectionBy.d.ts", + "intersectionWith.d.ts", + "invert.d.ts", + "invertBy.d.ts", + "invoke.d.ts", + "invokeMap.d.ts", + "isArguments.d.ts", + "isArray.d.ts", + "isArrayBuffer.d.ts", + "isArrayLike.d.ts", + "isArrayLikeObject.d.ts", + "isBoolean.d.ts", + "isBuffer.d.ts", + "isDate.d.ts", + "isElement.d.ts", + "isEmpty.d.ts", + "isEqual.d.ts", + "isEqualWith.d.ts", + "isError.d.ts", + "isFinite.d.ts", + "isFunction.d.ts", + "isInteger.d.ts", + "isLength.d.ts", + "isMap.d.ts", + "isMatch.d.ts", + "isMatchWith.d.ts", + "isNaN.d.ts", + "isNative.d.ts", + "isNil.d.ts", + "isNull.d.ts", + "isNumber.d.ts", + "isObject.d.ts", + "isObjectLike.d.ts", + "isPlainObject.d.ts", + "isRegExp.d.ts", + "isSafeInteger.d.ts", + "isSet.d.ts", + "isString.d.ts", + "isSymbol.d.ts", + "isTypedArray.d.ts", + "isUndefined.d.ts", + "isWeakMap.d.ts", + "isWeakSet.d.ts", + "iteratee.d.ts", + "join.d.ts", + "kebabCase.d.ts", + "keyBy.d.ts", + "keys.d.ts", + "keysIn.d.ts", + "last.d.ts", + "lastIndexOf.d.ts", + "lowerCase.d.ts", + "lowerFirst.d.ts", + "lt.d.ts", + "lte.d.ts", + "map.d.ts", + "mapKeys.d.ts", + "mapValues.d.ts", + "matches.d.ts", + "matchesProperty.d.ts", + "max.d.ts", + "maxBy.d.ts", + "mean.d.ts", + "meanBy.d.ts", + "memoize.d.ts", + "merge.d.ts", + "mergeWith.d.ts", + "method.d.ts", + "methodOf.d.ts", + "min.d.ts", + "minBy.d.ts", + "mixin.d.ts", + "negate.d.ts", + "noConflict.d.ts", + "noop.d.ts", + "now.d.ts", + "nth.d.ts", + "nthArg.d.ts", + "omit.d.ts", + "omitBy.d.ts", + "once.d.ts", + "orderBy.d.ts", + "over.d.ts", + "overArgs.d.ts", + "overEvery.d.ts", + "overSome.d.ts", + "pad.d.ts", + "padEnd.d.ts", + "padStart.d.ts", + "parseInt.d.ts", + "partial.d.ts", + "partialRight.d.ts", + "partition.d.ts", + "pick.d.ts", + "pickBy.d.ts", + "property.d.ts", + "propertyOf.d.ts", + "pull.d.ts", + "pullAll.d.ts", + "pullAllBy.d.ts", + "pullAllWith.d.ts", + "pullAt.d.ts", + "random.d.ts", + "range.d.ts", + "rangeRight.d.ts", + "rearg.d.ts", + "reduce.d.ts", + "reduceRight.d.ts", + "reject.d.ts", + "remove.d.ts", + "repeat.d.ts", + "replace.d.ts", + "rest.d.ts", + "result.d.ts", + "reverse.d.ts", + "round.d.ts", + "runInContext.d.ts", + "sample.d.ts", + "sampleSize.d.ts", + "set.d.ts", + "setWith.d.ts", + "shuffle.d.ts", + "size.d.ts", + "slice.d.ts", + "snakeCase.d.ts", + "some.d.ts", + "sortBy.d.ts", + "sortedIndex.d.ts", + "sortedIndexBy.d.ts", + "sortedIndexOf.d.ts", + "sortedLastIndex.d.ts", + "sortedLastIndexBy.d.ts", + "sortedLastIndexOf.d.ts", + "sortedUniq.d.ts", + "sortedUniqBy.d.ts", + "split.d.ts", + "spread.d.ts", + "startCase.d.ts", + "startsWith.d.ts", + "subtract.d.ts", + "sum.d.ts", + "sumBy.d.ts", + "tail.d.ts", + "take.d.ts", + "takeRight.d.ts", + "takeRightWhile.d.ts", + "takeWhile.d.ts", + "tap.d.ts", + "template.d.ts", + "throttle.d.ts", + "thru.d.ts", + "times.d.ts", + "toArray.d.ts", + "toFinite.d.ts", + "toInteger.d.ts", + "toLength.d.ts", + "toLower.d.ts", + "toNumber.d.ts", + "toPairs.d.ts", + "toPairsIn.d.ts", + "toPath.d.ts", + "toPlainObject.d.ts", + "toSafeInteger.d.ts", + "toString.d.ts", + "toUpper.d.ts", + "transform.d.ts", + "trim.d.ts", + "trimEnd.d.ts", + "trimStart.d.ts", + "truncate.d.ts", + "unary.d.ts", + "unescape.d.ts", + "union.d.ts", + "unionBy.d.ts", + "unionWith.d.ts", + "uniq.d.ts", + "uniqBy.d.ts", + "uniqueId.d.ts", + "uniqWith.d.ts", + "unset.d.ts", + "unzip.d.ts", + "unzipWith.d.ts", + "update.d.ts", + "updateWith.d.ts", + "upperCase.d.ts", + "upperFirst.d.ts", + "values.d.ts", + "valuesIn.d.ts", + "without.d.ts", + "words.d.ts", + "wrap.d.ts", + "xor.d.ts", + "xorBy.d.ts", + "xorWith.d.ts", + "zip.d.ts", + "zipObject.d.ts", + "zipObjectDeep.d.ts", + "zipWith.d.ts", + "common/array.d.ts", + "common/collection.d.ts", + "common/common.d.ts", + "common/date.d.ts", + "common/function.d.ts", + "common/lang.d.ts", + "common/math.d.ts", + "common/number.d.ts", + "common/object.d.ts", + "common/seq.d.ts", + "common/string.d.ts", + "common/util.d.ts", + "fp/convert.d.ts", + "fp/add.d.ts", + "fp/after.d.ts", + "fp/all.d.ts", + "fp/allPass.d.ts", + "fp/always.d.ts", + "fp/any.d.ts", + "fp/anyPass.d.ts", + "fp/apply.d.ts", + "fp/ary.d.ts", + "fp/assign.d.ts", + "fp/assignAll.d.ts", + "fp/assignAllWith.d.ts", + "fp/assignIn.d.ts", + "fp/assignInAll.d.ts", + "fp/assignInAllWith.d.ts", + "fp/assignInWith.d.ts", + "fp/assignWith.d.ts", + "fp/assoc.d.ts", + "fp/assocPath.d.ts", + "fp/at.d.ts", + "fp/attempt.d.ts", + "fp/before.d.ts", + "fp/bind.d.ts", + "fp/bindAll.d.ts", + "fp/bindKey.d.ts", + "fp/camelCase.d.ts", + "fp/capitalize.d.ts", + "fp/castArray.d.ts", + "fp/ceil.d.ts", + "fp/chunk.d.ts", + "fp/clamp.d.ts", + "fp/clone.d.ts", + "fp/cloneDeep.d.ts", + "fp/cloneDeepWith.d.ts", + "fp/cloneWith.d.ts", + "fp/compact.d.ts", + "fp/complement.d.ts", + "fp/compose.d.ts", + "fp/concat.d.ts", + "fp/cond.d.ts", + "fp/conforms.d.ts", + "fp/conformsTo.d.ts", + "fp/constant.d.ts", + "fp/contains.d.ts", + "fp/countBy.d.ts", + "fp/create.d.ts", + "fp/curry.d.ts", + "fp/curryN.d.ts", + "fp/curryRight.d.ts", + "fp/curryRightN.d.ts", + "fp/debounce.d.ts", + "fp/deburr.d.ts", + "fp/defaults.d.ts", + "fp/defaultsAll.d.ts", + "fp/defaultsDeep.d.ts", + "fp/defaultsDeepAll.d.ts", + "fp/defaultTo.d.ts", + "fp/defer.d.ts", + "fp/delay.d.ts", + "fp/difference.d.ts", + "fp/differenceBy.d.ts", + "fp/differenceWith.d.ts", + "fp/dissoc.d.ts", + "fp/dissocPath.d.ts", + "fp/divide.d.ts", + "fp/drop.d.ts", + "fp/dropLast.d.ts", + "fp/dropLastWhile.d.ts", + "fp/dropRight.d.ts", + "fp/dropRightWhile.d.ts", + "fp/dropWhile.d.ts", + "fp/each.d.ts", + "fp/eachRight.d.ts", + "fp/endsWith.d.ts", + "fp/entries.d.ts", + "fp/entriesIn.d.ts", + "fp/eq.d.ts", + "fp/equals.d.ts", + "fp/escape.d.ts", + "fp/escapeRegExp.d.ts", + "fp/every.d.ts", + "fp/extend.d.ts", + "fp/extendAll.d.ts", + "fp/extendAllWith.d.ts", + "fp/extendWith.d.ts", + "fp/F.d.ts", + "fp/fill.d.ts", + "fp/filter.d.ts", + "fp/find.d.ts", + "fp/findFrom.d.ts", + "fp/findIndex.d.ts", + "fp/findIndexFrom.d.ts", + "fp/findKey.d.ts", + "fp/findLast.d.ts", + "fp/findLastFrom.d.ts", + "fp/findLastIndex.d.ts", + "fp/findLastIndexFrom.d.ts", + "fp/findLastKey.d.ts", + "fp/first.d.ts", + "fp/flatMap.d.ts", + "fp/flatMapDeep.d.ts", + "fp/flatMapDepth.d.ts", + "fp/flatten.d.ts", + "fp/flattenDeep.d.ts", + "fp/flattenDepth.d.ts", + "fp/flip.d.ts", + "fp/floor.d.ts", + "fp/flow.d.ts", + "fp/flowRight.d.ts", + "fp/forEach.d.ts", + "fp/forEachRight.d.ts", + "fp/forIn.d.ts", + "fp/forInRight.d.ts", + "fp/forOwn.d.ts", + "fp/forOwnRight.d.ts", + "fp/fromPairs.d.ts", + "fp/functions.d.ts", + "fp/functionsIn.d.ts", + "fp/get.d.ts", + "fp/getOr.d.ts", + "fp/groupBy.d.ts", + "fp/gt.d.ts", + "fp/gte.d.ts", + "fp/has.d.ts", + "fp/hasIn.d.ts", + "fp/head.d.ts", + "fp/identical.d.ts", + "fp/identity.d.ts", + "fp/includes.d.ts", + "fp/includesFrom.d.ts", + "fp/indexBy.d.ts", + "fp/indexOf.d.ts", + "fp/indexOfFrom.d.ts", + "fp/init.d.ts", + "fp/initial.d.ts", + "fp/inRange.d.ts", + "fp/intersection.d.ts", + "fp/intersectionBy.d.ts", + "fp/intersectionWith.d.ts", + "fp/invert.d.ts", + "fp/invertBy.d.ts", + "fp/invertObj.d.ts", + "fp/invoke.d.ts", + "fp/invokeArgs.d.ts", + "fp/invokeArgsMap.d.ts", + "fp/invokeMap.d.ts", + "fp/isArguments.d.ts", + "fp/isArray.d.ts", + "fp/isArrayBuffer.d.ts", + "fp/isArrayLike.d.ts", + "fp/isArrayLikeObject.d.ts", + "fp/isBoolean.d.ts", + "fp/isBuffer.d.ts", + "fp/isDate.d.ts", + "fp/isElement.d.ts", + "fp/isEmpty.d.ts", + "fp/isEqual.d.ts", + "fp/isEqualWith.d.ts", + "fp/isError.d.ts", + "fp/isFinite.d.ts", + "fp/isFunction.d.ts", + "fp/isInteger.d.ts", + "fp/isLength.d.ts", + "fp/isMap.d.ts", + "fp/isMatch.d.ts", + "fp/isMatchWith.d.ts", + "fp/isNaN.d.ts", + "fp/isNative.d.ts", + "fp/isNil.d.ts", + "fp/isNull.d.ts", + "fp/isNumber.d.ts", + "fp/isObject.d.ts", + "fp/isObjectLike.d.ts", + "fp/isPlainObject.d.ts", + "fp/isRegExp.d.ts", + "fp/isSafeInteger.d.ts", + "fp/isSet.d.ts", + "fp/isString.d.ts", + "fp/isSymbol.d.ts", + "fp/isTypedArray.d.ts", + "fp/isUndefined.d.ts", + "fp/isWeakMap.d.ts", + "fp/isWeakSet.d.ts", + "fp/iteratee.d.ts", + "fp/join.d.ts", + "fp/juxt.d.ts", + "fp/kebabCase.d.ts", + "fp/keyBy.d.ts", + "fp/keys.d.ts", + "fp/keysIn.d.ts", + "fp/last.d.ts", + "fp/lastIndexOf.d.ts", + "fp/lastIndexOfFrom.d.ts", + "fp/lowerCase.d.ts", + "fp/lowerFirst.d.ts", + "fp/lt.d.ts", + "fp/lte.d.ts", + "fp/map.d.ts", + "fp/mapKeys.d.ts", + "fp/mapValues.d.ts", + "fp/matches.d.ts", + "fp/matchesProperty.d.ts", + "fp/max.d.ts", + "fp/maxBy.d.ts", + "fp/mean.d.ts", + "fp/meanBy.d.ts", + "fp/memoize.d.ts", + "fp/merge.d.ts", + "fp/mergeAll.d.ts", + "fp/mergeAllWith.d.ts", + "fp/mergeWith.d.ts", + "fp/method.d.ts", + "fp/methodOf.d.ts", + "fp/min.d.ts", + "fp/minBy.d.ts", + "fp/multiply.d.ts", + "fp/nAry.d.ts", + "fp/negate.d.ts", + "fp/noConflict.d.ts", + "fp/noop.d.ts", + "fp/now.d.ts", + "fp/nth.d.ts", + "fp/nthArg.d.ts", + "fp/omit.d.ts", + "fp/omitAll.d.ts", + "fp/omitBy.d.ts", + "fp/once.d.ts", + "fp/orderBy.d.ts", + "fp/over.d.ts", + "fp/overArgs.d.ts", + "fp/overEvery.d.ts", + "fp/overSome.d.ts", + "fp/pad.d.ts", + "fp/padChars.d.ts", + "fp/padCharsEnd.d.ts", + "fp/padCharsStart.d.ts", + "fp/padEnd.d.ts", + "fp/padStart.d.ts", + "fp/parseInt.d.ts", + "fp/partial.d.ts", + "fp/partialRight.d.ts", + "fp/partition.d.ts", + "fp/path.d.ts", + "fp/pathEq.d.ts", + "fp/pathOr.d.ts", + "fp/paths.d.ts", + "fp/pick.d.ts", + "fp/pickAll.d.ts", + "fp/pickBy.d.ts", + "fp/pipe.d.ts", + "fp/pluck.d.ts", + "fp/prop.d.ts", + "fp/propEq.d.ts", + "fp/property.d.ts", + "fp/propertyOf.d.ts", + "fp/propOr.d.ts", + "fp/props.d.ts", + "fp/pull.d.ts", + "fp/pullAll.d.ts", + "fp/pullAllBy.d.ts", + "fp/pullAllWith.d.ts", + "fp/pullAt.d.ts", + "fp/random.d.ts", + "fp/range.d.ts", + "fp/rangeRight.d.ts", + "fp/rangeStep.d.ts", + "fp/rangeStepRight.d.ts", + "fp/rearg.d.ts", + "fp/reduce.d.ts", + "fp/reduceRight.d.ts", + "fp/reject.d.ts", + "fp/remove.d.ts", + "fp/repeat.d.ts", + "fp/replace.d.ts", + "fp/rest.d.ts", + "fp/restFrom.d.ts", + "fp/result.d.ts", + "fp/reverse.d.ts", + "fp/round.d.ts", + "fp/runInContext.d.ts", + "fp/sample.d.ts", + "fp/sampleSize.d.ts", + "fp/set.d.ts", + "fp/setWith.d.ts", + "fp/shuffle.d.ts", + "fp/size.d.ts", + "fp/slice.d.ts", + "fp/snakeCase.d.ts", + "fp/some.d.ts", + "fp/sortBy.d.ts", + "fp/sortedIndex.d.ts", + "fp/sortedIndexBy.d.ts", + "fp/sortedIndexOf.d.ts", + "fp/sortedLastIndex.d.ts", + "fp/sortedLastIndexBy.d.ts", + "fp/sortedLastIndexOf.d.ts", + "fp/sortedUniq.d.ts", + "fp/sortedUniqBy.d.ts", + "fp/split.d.ts", + "fp/spread.d.ts", + "fp/spreadFrom.d.ts", + "fp/startCase.d.ts", + "fp/startsWith.d.ts", + "fp/stubArray.d.ts", + "fp/stubFalse.d.ts", + "fp/stubObject.d.ts", + "fp/stubString.d.ts", + "fp/stubTrue.d.ts", + "fp/subtract.d.ts", + "fp/sum.d.ts", + "fp/sumBy.d.ts", + "fp/symmetricDifference.d.ts", + "fp/symmetricDifferenceBy.d.ts", + "fp/symmetricDifferenceWith.d.ts", + "fp/T.d.ts", + "fp/tail.d.ts", + "fp/take.d.ts", + "fp/takeLast.d.ts", + "fp/takeLastWhile.d.ts", + "fp/takeRight.d.ts", + "fp/takeRightWhile.d.ts", + "fp/takeWhile.d.ts", + "fp/tap.d.ts", + "fp/template.d.ts", + "fp/throttle.d.ts", + "fp/thru.d.ts", + "fp/times.d.ts", + "fp/toArray.d.ts", + "fp/toFinite.d.ts", + "fp/toInteger.d.ts", + "fp/toLength.d.ts", + "fp/toLower.d.ts", + "fp/toNumber.d.ts", + "fp/toPairs.d.ts", + "fp/toPairsIn.d.ts", + "fp/toPath.d.ts", + "fp/toPlainObject.d.ts", + "fp/toSafeInteger.d.ts", + "fp/toString.d.ts", + "fp/toUpper.d.ts", + "fp/transform.d.ts", + "fp/trim.d.ts", + "fp/trimChars.d.ts", + "fp/trimCharsEnd.d.ts", + "fp/trimCharsStart.d.ts", + "fp/trimEnd.d.ts", + "fp/trimStart.d.ts", + "fp/truncate.d.ts", + "fp/unapply.d.ts", + "fp/unary.d.ts", + "fp/unescape.d.ts", + "fp/union.d.ts", + "fp/unionBy.d.ts", + "fp/unionWith.d.ts", + "fp/uniq.d.ts", + "fp/uniqBy.d.ts", + "fp/uniqueId.d.ts", + "fp/uniqWith.d.ts", + "fp/unnest.d.ts", + "fp/unset.d.ts", + "fp/unzip.d.ts", + "fp/unzipWith.d.ts", + "fp/update.d.ts", + "fp/updateWith.d.ts", + "fp/upperCase.d.ts", + "fp/upperFirst.d.ts", + "fp/useWith.d.ts", + "fp/values.d.ts", + "fp/valuesIn.d.ts", + "fp/where.d.ts", + "fp/whereEq.d.ts", + "fp/without.d.ts", + "fp/words.d.ts", + "fp/wrap.d.ts", + "fp/xor.d.ts", + "fp/xorBy.d.ts", + "fp/xorWith.d.ts", + "fp/zip.d.ts", + "fp/zipAll.d.ts", + "fp/zipObj.d.ts", + "fp/zipObject.d.ts", + "fp/zipObjectDeep.d.ts", + "fp/zipWith.d.ts", + "fp/__.d.ts", + "fp/placeholder.d.ts" + ] +} diff --git a/types/lodash/ts3.1/tslint.json b/types/lodash/ts3.1/tslint.json new file mode 100644 index 0000000000..d9ee10ad6a --- /dev/null +++ b/types/lodash/ts3.1/tslint.json @@ -0,0 +1,12 @@ +{ + "extends": "dtslint/dt.json", + "rules": { + "ban-types": false, + // All are TODOs + "jsdoc-format": false, + "max-line-length": [false], + "no-unnecessary-generics": false, + "typedef-whitespace": [false], + "unified-signatures": false + } +} diff --git a/types/lodash/ts3.1/unary.d.ts b/types/lodash/ts3.1/unary.d.ts new file mode 100644 index 0000000000..44569978f7 --- /dev/null +++ b/types/lodash/ts3.1/unary.d.ts @@ -0,0 +1,2 @@ +import { unary } from "./index"; +export = unary; diff --git a/types/lodash/ts3.1/unescape.d.ts b/types/lodash/ts3.1/unescape.d.ts new file mode 100644 index 0000000000..71ba85d89f --- /dev/null +++ b/types/lodash/ts3.1/unescape.d.ts @@ -0,0 +1,2 @@ +import { unescape } from "./index"; +export = unescape; diff --git a/types/lodash/ts3.1/union.d.ts b/types/lodash/ts3.1/union.d.ts new file mode 100644 index 0000000000..7b12e92f6d --- /dev/null +++ b/types/lodash/ts3.1/union.d.ts @@ -0,0 +1,2 @@ +import { union } from "./index"; +export = union; diff --git a/types/lodash/ts3.1/unionBy.d.ts b/types/lodash/ts3.1/unionBy.d.ts new file mode 100644 index 0000000000..0cb199245f --- /dev/null +++ b/types/lodash/ts3.1/unionBy.d.ts @@ -0,0 +1,2 @@ +import { unionBy } from "./index"; +export = unionBy; diff --git a/types/lodash/ts3.1/unionWith.d.ts b/types/lodash/ts3.1/unionWith.d.ts new file mode 100644 index 0000000000..9888092f8d --- /dev/null +++ b/types/lodash/ts3.1/unionWith.d.ts @@ -0,0 +1,2 @@ +import { unionWith } from "./index"; +export = unionWith; diff --git a/types/lodash/ts3.1/uniq.d.ts b/types/lodash/ts3.1/uniq.d.ts new file mode 100644 index 0000000000..6c105ac3ea --- /dev/null +++ b/types/lodash/ts3.1/uniq.d.ts @@ -0,0 +1,2 @@ +import { uniq } from "./index"; +export = uniq; diff --git a/types/lodash/ts3.1/uniqBy.d.ts b/types/lodash/ts3.1/uniqBy.d.ts new file mode 100644 index 0000000000..7101b0e306 --- /dev/null +++ b/types/lodash/ts3.1/uniqBy.d.ts @@ -0,0 +1,2 @@ +import { uniqBy } from "./index"; +export = uniqBy; diff --git a/types/lodash/ts3.1/uniqWith.d.ts b/types/lodash/ts3.1/uniqWith.d.ts new file mode 100644 index 0000000000..72c3f8fc13 --- /dev/null +++ b/types/lodash/ts3.1/uniqWith.d.ts @@ -0,0 +1,2 @@ +import { uniqWith } from "./index"; +export = uniqWith; diff --git a/types/lodash/ts3.1/uniqueId.d.ts b/types/lodash/ts3.1/uniqueId.d.ts new file mode 100644 index 0000000000..4ea55f92f3 --- /dev/null +++ b/types/lodash/ts3.1/uniqueId.d.ts @@ -0,0 +1,2 @@ +import { uniqueId } from "./index"; +export = uniqueId; diff --git a/types/lodash/ts3.1/unset.d.ts b/types/lodash/ts3.1/unset.d.ts new file mode 100644 index 0000000000..1eac8ddb72 --- /dev/null +++ b/types/lodash/ts3.1/unset.d.ts @@ -0,0 +1,2 @@ +import { unset } from "./index"; +export = unset; diff --git a/types/lodash/ts3.1/unzip.d.ts b/types/lodash/ts3.1/unzip.d.ts new file mode 100644 index 0000000000..7e320a27f2 --- /dev/null +++ b/types/lodash/ts3.1/unzip.d.ts @@ -0,0 +1,2 @@ +import { unzip } from "./index"; +export = unzip; diff --git a/types/lodash/ts3.1/unzipWith.d.ts b/types/lodash/ts3.1/unzipWith.d.ts new file mode 100644 index 0000000000..2bf5394b29 --- /dev/null +++ b/types/lodash/ts3.1/unzipWith.d.ts @@ -0,0 +1,2 @@ +import { unzipWith } from "./index"; +export = unzipWith; diff --git a/types/lodash/ts3.1/update.d.ts b/types/lodash/ts3.1/update.d.ts new file mode 100644 index 0000000000..d072c0fe94 --- /dev/null +++ b/types/lodash/ts3.1/update.d.ts @@ -0,0 +1,2 @@ +import { update } from "./index"; +export = update; diff --git a/types/lodash/ts3.1/updateWith.d.ts b/types/lodash/ts3.1/updateWith.d.ts new file mode 100644 index 0000000000..44175423ec --- /dev/null +++ b/types/lodash/ts3.1/updateWith.d.ts @@ -0,0 +1,2 @@ +import { updateWith } from "./index"; +export = updateWith; diff --git a/types/lodash/ts3.1/upperCase.d.ts b/types/lodash/ts3.1/upperCase.d.ts new file mode 100644 index 0000000000..c33598a935 --- /dev/null +++ b/types/lodash/ts3.1/upperCase.d.ts @@ -0,0 +1,2 @@ +import { upperCase } from "./index"; +export = upperCase; diff --git a/types/lodash/ts3.1/upperFirst.d.ts b/types/lodash/ts3.1/upperFirst.d.ts new file mode 100644 index 0000000000..1f1b2a798a --- /dev/null +++ b/types/lodash/ts3.1/upperFirst.d.ts @@ -0,0 +1,2 @@ +import { upperFirst } from "./index"; +export = upperFirst; diff --git a/types/lodash/ts3.1/values.d.ts b/types/lodash/ts3.1/values.d.ts new file mode 100644 index 0000000000..2015ebf8ac --- /dev/null +++ b/types/lodash/ts3.1/values.d.ts @@ -0,0 +1,2 @@ +import { values } from "./index"; +export = values; diff --git a/types/lodash/ts3.1/valuesIn.d.ts b/types/lodash/ts3.1/valuesIn.d.ts new file mode 100644 index 0000000000..6f8d6a3efa --- /dev/null +++ b/types/lodash/ts3.1/valuesIn.d.ts @@ -0,0 +1,2 @@ +import { valuesIn } from "./index"; +export = valuesIn; diff --git a/types/lodash/ts3.1/without.d.ts b/types/lodash/ts3.1/without.d.ts new file mode 100644 index 0000000000..bbdfe163e5 --- /dev/null +++ b/types/lodash/ts3.1/without.d.ts @@ -0,0 +1,2 @@ +import { without } from "./index"; +export = without; diff --git a/types/lodash/ts3.1/words.d.ts b/types/lodash/ts3.1/words.d.ts new file mode 100644 index 0000000000..22da6cb943 --- /dev/null +++ b/types/lodash/ts3.1/words.d.ts @@ -0,0 +1,2 @@ +import { words } from "./index"; +export = words; diff --git a/types/lodash/ts3.1/wrap.d.ts b/types/lodash/ts3.1/wrap.d.ts new file mode 100644 index 0000000000..3c20f28ed2 --- /dev/null +++ b/types/lodash/ts3.1/wrap.d.ts @@ -0,0 +1,2 @@ +import { wrap } from "./index"; +export = wrap; diff --git a/types/lodash/ts3.1/xor.d.ts b/types/lodash/ts3.1/xor.d.ts new file mode 100644 index 0000000000..894735c45d --- /dev/null +++ b/types/lodash/ts3.1/xor.d.ts @@ -0,0 +1,2 @@ +import { xor } from "./index"; +export = xor; diff --git a/types/lodash/ts3.1/xorBy.d.ts b/types/lodash/ts3.1/xorBy.d.ts new file mode 100644 index 0000000000..6a08c6a874 --- /dev/null +++ b/types/lodash/ts3.1/xorBy.d.ts @@ -0,0 +1,2 @@ +import { xorBy } from "./index"; +export = xorBy; diff --git a/types/lodash/ts3.1/xorWith.d.ts b/types/lodash/ts3.1/xorWith.d.ts new file mode 100644 index 0000000000..7cdcaf339f --- /dev/null +++ b/types/lodash/ts3.1/xorWith.d.ts @@ -0,0 +1,2 @@ +import { xorWith } from "./index"; +export = xorWith; diff --git a/types/lodash/ts3.1/zip.d.ts b/types/lodash/ts3.1/zip.d.ts new file mode 100644 index 0000000000..e7467cdf96 --- /dev/null +++ b/types/lodash/ts3.1/zip.d.ts @@ -0,0 +1,2 @@ +import { zip } from "./index"; +export = zip; diff --git a/types/lodash/ts3.1/zipObject.d.ts b/types/lodash/ts3.1/zipObject.d.ts new file mode 100644 index 0000000000..ad049fd153 --- /dev/null +++ b/types/lodash/ts3.1/zipObject.d.ts @@ -0,0 +1,2 @@ +import { zipObject } from "./index"; +export = zipObject; diff --git a/types/lodash/ts3.1/zipObjectDeep.d.ts b/types/lodash/ts3.1/zipObjectDeep.d.ts new file mode 100644 index 0000000000..2a483e8393 --- /dev/null +++ b/types/lodash/ts3.1/zipObjectDeep.d.ts @@ -0,0 +1,2 @@ +import { zipObjectDeep } from "./index"; +export = zipObjectDeep; diff --git a/types/lodash/ts3.1/zipWith.d.ts b/types/lodash/ts3.1/zipWith.d.ts new file mode 100644 index 0000000000..48693742fb --- /dev/null +++ b/types/lodash/ts3.1/zipWith.d.ts @@ -0,0 +1,2 @@ +import { zipWith } from "./index"; +export = zipWith; diff --git a/types/lowdb/_lodash.d.ts b/types/lowdb/_lodash.d.ts deleted file mode 100644 index 17cdf43548..0000000000 --- a/types/lowdb/_lodash.d.ts +++ /dev/null @@ -1,3206 +0,0 @@ -// AUTO-GENERATED: do not modify this file directly. -// If you need to make changes, modify types/lodash/scripts/generate-lowdb.ts (if necessary), then open a terminal in types/lodash/scripts, and do: -// npm install && npm run generate - -import _ = require("lodash"); -declare module "./index" { - interface LoDashExplicitSyncWrapper { - chunk( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - size?: number, - ): LoDashExplicitSyncWrapper; - compact(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - concat(this: LoDashExplicitSyncWrapper<_.Many>, ...values: Array<_.Many>): LoDashExplicitSyncWrapper; - difference( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - ...values: Array<_.List> - ): LoDashExplicitSyncWrapper; - differenceBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - differenceBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - differenceBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - values3: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - differenceBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - values3: _.List, - values4: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - differenceBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - values3: _.List, - values4: _.List, - values5: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - differenceBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - values3: _.List, - values4: _.List, - values5: _.List, - ...values: Array<_.List | _.ValueIteratee> - ): LoDashExplicitSyncWrapper; - differenceBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - ...values: Array<_.List> - ): LoDashExplicitSyncWrapper; - differenceWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values: _.List, - comparator: _.Comparator2 - ): LoDashExplicitSyncWrapper; - differenceWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - comparator: _.Comparator2 - ): LoDashExplicitSyncWrapper; - differenceWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - ...values: Array<_.List | _.Comparator2> - ): LoDashExplicitSyncWrapper; - differenceWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - ...values: Array<_.List> - ): LoDashExplicitSyncWrapper; - drop(this: LoDashExplicitSyncWrapper<_.List | null | undefined>, n?: number): LoDashExplicitSyncWrapper; - dropRight(this: LoDashExplicitSyncWrapper<_.List | null | undefined>, n?: number): LoDashExplicitSyncWrapper; - dropRightWhile( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate?: _.ListIteratee - ): LoDashExplicitSyncWrapper; - dropWhile( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate?: _.ListIteratee - ): LoDashExplicitSyncWrapper; - fill( - this: LoDashExplicitSyncWrapper, - value: T - ): LoDashExplicitSyncWrapper; - fill( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - value: T - ): LoDashExplicitSyncWrapper<_.List>; - fill( - this: LoDashExplicitSyncWrapper, - value: T, - start?: number, - end?: number - ): LoDashExplicitSyncWrapper>; - fill( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - value: T, - start?: number, - end?: number - ): LoDashExplicitSyncWrapper<_.List>; - findIndex( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom, - fromIndex?: number - ): LoDashExplicitSyncWrapper; - findLastIndex( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom, - fromIndex?: number - ): LoDashExplicitSyncWrapper; - first(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - flatten(this: LoDashExplicitSyncWrapper<_.List<_.Many> | null | undefined>): LoDashExplicitSyncWrapper; - flattenDeep(this: LoDashExplicitSyncWrapper<_.ListOfRecursiveArraysOrValues | null | undefined>): LoDashExplicitSyncWrapper; - flattenDepth(this: LoDashExplicitSyncWrapper<_.ListOfRecursiveArraysOrValues | null | undefined>, depth?: number): LoDashExplicitSyncWrapper; - fromPairs( - this: LoDashExplicitSyncWrapper<_.List<[_.PropertyName, T]> | null | undefined> - ): LoDashExplicitSyncWrapper<_.Dictionary>; - fromPairs( - this: LoDashExplicitSyncWrapper<_.List | null | undefined> - ): LoDashExplicitSyncWrapper<_.Dictionary>; - head(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - indexOf( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - value: T, - fromIndex?: number - ): LoDashExplicitSyncWrapper; - initial(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - intersection( - this: LoDashExplicitSyncWrapper<_.List>, - ...arrays: Array<_.List> - ): LoDashExplicitSyncWrapper; - intersectionBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - intersectionBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - intersectionBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - ...values: Array<_.List | _.ValueIteratee> - ): LoDashExplicitSyncWrapper; - intersectionBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - ...values: Array<_.List> - ): LoDashExplicitSyncWrapper; - intersectionWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values: _.List, - comparator: _.Comparator2 - ): LoDashExplicitSyncWrapper; - intersectionWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - comparator: _.Comparator2 - ): LoDashExplicitSyncWrapper; - intersectionWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - ...values: Array<_.List | _.Comparator2> - ): LoDashExplicitSyncWrapper; - intersectionWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - ...values: Array<_.List> - ): LoDashExplicitSyncWrapper; - join(separator?: string): LoDashExplicitSyncWrapper; - last(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - lastIndexOf( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - value: T, - fromIndex?: true|number - ): LoDashExplicitSyncWrapper; - nth( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - n?: number - ): LoDashExplicitSyncWrapper; - pull( - this: LoDashExplicitSyncWrapper<_.List>, - ...values: T[] - ): this; - pullAll( - this: LoDashExplicitSyncWrapper<_.List>, - values?: _.List - ): this; - remove( - this: LoDashExplicitSyncWrapper<_.List>, - predicate?: _.ListIteratee - ): LoDashExplicitSyncWrapper; - slice( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - start?: number, - end?: number - ): LoDashExplicitSyncWrapper; - sortedIndex( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - value: T - ): LoDashExplicitSyncWrapper; - sortedIndex( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - value: T - ): LoDashExplicitSyncWrapper; - sortedIndexBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - value: T, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - sortedIndexOf( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - value: T - ): LoDashExplicitSyncWrapper; - sortedLastIndex( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - value: T - ): LoDashExplicitSyncWrapper; - sortedLastIndexBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - value: T, - iteratee: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - sortedLastIndexOf( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - value: T - ): LoDashExplicitSyncWrapper; - sortedUniq(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - sortedUniqBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - tail(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - take( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - n?: number - ): LoDashExplicitSyncWrapper; - takeRight( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - n?: number - ): LoDashExplicitSyncWrapper; - takeRightWhile( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate?: _.ListIteratee - ): LoDashExplicitSyncWrapper; - takeWhile( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate?: _.ListIteratee - ): LoDashExplicitSyncWrapper; - union( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - ...arrays: Array<_.List | null | undefined> - ): LoDashExplicitSyncWrapper; - unionBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - unionBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - unionBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - arrays3: _.List | null | undefined, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - unionBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - arrays3: _.List | null | undefined, - arrays4: _.List | null | undefined, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - unionBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - arrays3: _.List | null | undefined, - arrays4: _.List | null | undefined, - arrays5: _.List | null | undefined, - ...iteratee: Array<_.ValueIteratee | _.List | null | undefined> - ): LoDashExplicitSyncWrapper; - unionWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - comparator?: _.Comparator - ): LoDashExplicitSyncWrapper; - unionWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - comparator?: _.Comparator - ): LoDashExplicitSyncWrapper; - unionWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - arrays3: _.List | null | undefined, - ...comparator: Array<_.Comparator | _.List | null | undefined> - ): LoDashExplicitSyncWrapper; - uniq(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - uniqBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - uniqWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - comparator?: _.Comparator - ): LoDashExplicitSyncWrapper; - unzip(this: LoDashExplicitSyncWrapper> | null | undefined>): LoDashExplicitSyncWrapper; - unzipWith( - this: LoDashExplicitSyncWrapper<_.List<_.List> | null | undefined>, - iteratee: (...values: T[]) => TResult - ): LoDashExplicitSyncWrapper; - unzipWith( - this: LoDashExplicitSyncWrapper<_.List<_.List> | null | undefined> - ): LoDashExplicitSyncWrapper; - without( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - ...values: T[] - ): LoDashExplicitSyncWrapper; - xor( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - ...arrays: Array<_.List | null | undefined> - ): LoDashExplicitSyncWrapper; - xorBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - xorBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - xorBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - arrays3: _.List | null | undefined, - ...iteratee: Array<_.ValueIteratee | _.List | null | undefined> - ): LoDashExplicitSyncWrapper; - xorWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - comparator?: _.Comparator - ): LoDashExplicitSyncWrapper; - xorWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - comparator?: _.Comparator - ): LoDashExplicitSyncWrapper; - xorWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - arrays3: _.List | null | undefined, - ...comparator: Array<_.Comparator | _.List | null | undefined> - ): LoDashExplicitSyncWrapper; - zip( - this: LoDashExplicitSyncWrapper<_.List>, - arrays2: _.List, - ): LoDashExplicitSyncWrapper>; - zip( - this: LoDashExplicitSyncWrapper<_.List>, - arrays2: _.List, - arrays3: _.List, - ): LoDashExplicitSyncWrapper>; - zip( - this: LoDashExplicitSyncWrapper<_.List>, - arrays2: _.List, - arrays3: _.List, - arrays4: _.List, - ): LoDashExplicitSyncWrapper>; - zip( - this: LoDashExplicitSyncWrapper<_.List>, - arrays2: _.List, - arrays3: _.List, - arrays4: _.List, - arrays5: _.List, - ): LoDashExplicitSyncWrapper>; - zip( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - ...arrays: Array<_.List | null | undefined> - ): LoDashExplicitSyncWrapper>>; - zipObject( - this: LoDashExplicitSyncWrapper<_.List<_.PropertyName>>, - values: _.List - ): LoDashExplicitSyncWrapper<_.Dictionary>; - zipObject( - this: LoDashExplicitSyncWrapper<_.List<_.PropertyName>> - ): LoDashExplicitSyncWrapper<_.Dictionary>; - zipObjectDeep( - this: LoDashExplicitSyncWrapper<_.List<_.PropertyPath>>, - values?: _.List - ): LoDashExplicitSyncWrapper; - zipWith( - this: LoDashExplicitSyncWrapper<_.List>, - iteratee: (value1: T) => TResult - ): LoDashExplicitSyncWrapper; - zipWith( - this: LoDashExplicitSyncWrapper<_.List>, - arrays2: _.List, - iteratee: (value1: T1, value2: T2) => TResult - ): LoDashExplicitSyncWrapper; - zipWith( - this: LoDashExplicitSyncWrapper<_.List>, - arrays2: _.List, - arrays3: _.List, - iteratee: (value1: T1, value2: T2, value3: T3) => TResult - ): LoDashExplicitSyncWrapper; - zipWith( - this: LoDashExplicitSyncWrapper<_.List>, - arrays2: _.List, - arrays3: _.List, - arrays4: _.List, - iteratee: (value1: T1, value2: T2, value3: T3, value4: T4) => TResult - ): LoDashExplicitSyncWrapper; - zipWith( - this: LoDashExplicitSyncWrapper<_.List>, - arrays2: _.List, - arrays3: _.List, - arrays4: _.List, - arrays5: _.List, - iteratee: (value1: T1, value2: T2, value3: T3, value4: T4, value5: T5) => TResult - ): LoDashExplicitSyncWrapper; - zipWith( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - ...iteratee: Array<((...group: T[]) => TResult) | _.List | null | undefined> - ): LoDashExplicitSyncWrapper; - countBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper<_.Dictionary>; - countBy( - this: LoDashExplicitSyncWrapper, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper<_.Dictionary>; - every( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom - ): LoDashExplicitSyncWrapper; - every( - this: LoDashExplicitSyncWrapper, - predicate?: _.ObjectIterateeCustom - ): LoDashExplicitSyncWrapper; - filter( - this: LoDashExplicitSyncWrapper, - predicate?: _.StringIterator - ): LoDashExplicitSyncWrapper; - filter( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate: _.ListIteratorTypeGuard - ): LoDashExplicitSyncWrapper; - filter( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom - ): LoDashExplicitSyncWrapper; - filter( - this: LoDashExplicitSyncWrapper, - predicate: _.ObjectIteratorTypeGuard - ): LoDashExplicitSyncWrapper; - filter( - this: LoDashExplicitSyncWrapper, - predicate?: _.ObjectIterateeCustom - ): LoDashExplicitSyncWrapper>; - find( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate: _.ListIteratorTypeGuard, - fromIndex?: number - ): LoDashExplicitSyncWrapper; - find( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom, - fromIndex?: number - ): LoDashExplicitSyncWrapper; - find( - this: LoDashExplicitSyncWrapper, - predicate: _.ObjectIteratorTypeGuard, - fromIndex?: number - ): LoDashExplicitSyncWrapper; - find( - this: LoDashExplicitSyncWrapper, - predicate?: _.ObjectIterateeCustom, - fromIndex?: number - ): LoDashExplicitSyncWrapper; - findLast( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate: _.ListIteratorTypeGuard, - fromIndex?: number - ): LoDashExplicitSyncWrapper; - findLast( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom, - fromIndex?: number - ): LoDashExplicitSyncWrapper; - findLast( - this: LoDashExplicitSyncWrapper, - predicate: _.ObjectIteratorTypeGuard, - fromIndex?: number - ): LoDashExplicitSyncWrapper; - findLast( - this: LoDashExplicitSyncWrapper, - predicate?: _.ObjectIterateeCustom, - fromIndex?: number - ): LoDashExplicitSyncWrapper; - flatMap(this: LoDashExplicitSyncWrapper<_.List<_.Many> | _.Dictionary<_.Many> | _.NumericDictionary<_.Many> | null | undefined>): LoDashExplicitSyncWrapper; - flatMap(): LoDashExplicitSyncWrapper; - flatMap( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee: _.ListIterator> - ): LoDashExplicitSyncWrapper; - flatMap( - this: LoDashExplicitSyncWrapper, - iteratee: _.ObjectIterator> - ): LoDashExplicitSyncWrapper; - flatMap( - iteratee: string - ): LoDashExplicitSyncWrapper; - flatMap( - iteratee: object - ): LoDashExplicitSyncWrapper; - flatMapDeep( - this: LoDashExplicitSyncWrapper<_.List<_.ListOfRecursiveArraysOrValues | T> | _.Dictionary<_.ListOfRecursiveArraysOrValues | T> | _.NumericDictionary<_.ListOfRecursiveArraysOrValues | T> | null | undefined> - ): LoDashExplicitSyncWrapper; - flatMapDeep( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee: _.ListIterator | TResult> - ): LoDashExplicitSyncWrapper; - flatMapDeep( - this: LoDashExplicitSyncWrapper, - iteratee: _.ObjectIterator | TResult> - ): LoDashExplicitSyncWrapper; - flatMapDeep( - this: LoDashExplicitSyncWrapper, - iteratee: string - ): LoDashExplicitSyncWrapper; - flatMapDeep( - this: LoDashExplicitSyncWrapper, - iteratee: object - ): LoDashExplicitSyncWrapper; - flatMapDepth( - this: LoDashExplicitSyncWrapper<_.List<_.ListOfRecursiveArraysOrValues | T> | _.Dictionary<_.ListOfRecursiveArraysOrValues | T> | _.NumericDictionary<_.ListOfRecursiveArraysOrValues | T> | null | undefined> - ): LoDashExplicitSyncWrapper; - flatMapDepth( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee: _.ListIterator | TResult>, - depth?: number - ): LoDashExplicitSyncWrapper; - flatMapDepth( - this: LoDashExplicitSyncWrapper, - iteratee: _.ObjectIterator | TResult>, - depth?: number - ): LoDashExplicitSyncWrapper; - flatMapDepth( - this: LoDashExplicitSyncWrapper, - iteratee: string, - depth?: number - ): LoDashExplicitSyncWrapper; - flatMapDepth( - this: LoDashExplicitSyncWrapper, - iteratee: object, - depth?: number - ): LoDashExplicitSyncWrapper; - groupBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper<_.Dictionary>; - groupBy( - this: LoDashExplicitSyncWrapper, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper<_.Dictionary>>; - includes( - this: LoDashExplicitSyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - target: T, - fromIndex?: number - ): LoDashExplicitSyncWrapper; - invokeMap( - methodName: string, - ...args: any[]): LoDashExplicitSyncWrapper; - invokeMap( - method: (...args: any[]) => TResult, - ...args: any[]): LoDashExplicitSyncWrapper; - keyBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIterateeCustom - ): LoDashExplicitSyncWrapper<_.Dictionary>; - keyBy( - this: LoDashExplicitSyncWrapper, - iteratee?: _.ValueIterateeCustom - ): LoDashExplicitSyncWrapper<_.Dictionary>; - map( - this: LoDashExplicitSyncWrapper, - iteratee: _.ArrayIterator - ): LoDashExplicitSyncWrapper; - map( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee: _.ListIterator - ): LoDashExplicitSyncWrapper; - map(this: LoDashExplicitSyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>): LoDashExplicitSyncWrapper; - map( - this: LoDashExplicitSyncWrapper, - iteratee: _.ObjectIterator - ): LoDashExplicitSyncWrapper; - map( - this: LoDashExplicitSyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - iteratee: K - ): LoDashExplicitSyncWrapper>; - map( - this: LoDashExplicitSyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - iteratee?: string - ): LoDashExplicitSyncWrapper; - map( - this: LoDashExplicitSyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - iteratee?: object - ): LoDashExplicitSyncWrapper; - orderBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratees?: _.Many<_.ListIterator>, - orders?: _.Many - ): LoDashExplicitSyncWrapper; - orderBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratees?: _.Many<_.ListIteratee>, - orders?: _.Many - ): LoDashExplicitSyncWrapper; - orderBy( - this: LoDashExplicitSyncWrapper, - iteratees?: _.Many<_.ObjectIterator>, - orders?: _.Many - ): LoDashExplicitSyncWrapper>; - orderBy( - this: LoDashExplicitSyncWrapper, - iteratees?: _.Many<_.ObjectIteratee>, - orders?: _.Many - ): LoDashExplicitSyncWrapper>; - partition( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - callback: _.ValueIteratorTypeGuard - ): LoDashExplicitSyncWrapper<[U[], Array>]>; - partition( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - callback: _.ValueIteratee - ): LoDashExplicitSyncWrapper<[T[], T[]]>; - partition( - this: LoDashExplicitSyncWrapper, - callback: _.ValueIteratee - ): LoDashExplicitSyncWrapper<[Array, Array]>; - reduce( - this: LoDashExplicitSyncWrapper, - callback: _.MemoListIterator, - accumulator: TResult - ): LoDashExplicitSyncWrapper; - reduce( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - callback: _.MemoListIterator>, - accumulator: TResult - ): LoDashExplicitSyncWrapper; - reduce( - this: LoDashExplicitSyncWrapper, - callback: _.MemoObjectIterator, - accumulator: TResult - ): LoDashExplicitSyncWrapper; - reduce( - this: LoDashExplicitSyncWrapper, - callback: _.MemoListIterator - ): LoDashExplicitSyncWrapper; - reduce( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - callback: _.MemoListIterator> - ): LoDashExplicitSyncWrapper; - reduce( - this: LoDashExplicitSyncWrapper, - callback: _.MemoObjectIterator - ): LoDashExplicitSyncWrapper; - reduceRight( - this: LoDashExplicitSyncWrapper, - callback: _.MemoListIterator, - accumulator: TResult - ): LoDashExplicitSyncWrapper; - reduceRight( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - callback: _.MemoListIterator>, - accumulator: TResult - ): LoDashExplicitSyncWrapper; - reduceRight( - this: LoDashExplicitSyncWrapper, - callback: _.MemoObjectIterator, - accumulator: TResult - ): LoDashExplicitSyncWrapper; - reduceRight( - this: LoDashExplicitSyncWrapper, - callback: _.MemoListIterator - ): LoDashExplicitSyncWrapper; - reduceRight( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - callback: _.MemoListIterator> - ): LoDashExplicitSyncWrapper; - reduceRight( - this: LoDashExplicitSyncWrapper, - callback: _.MemoObjectIterator - ): LoDashExplicitSyncWrapper; - reject( - this: LoDashExplicitSyncWrapper, - predicate?: _.StringIterator - ): LoDashExplicitSyncWrapper; - reject( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom - ): LoDashExplicitSyncWrapper; - reject( - this: LoDashExplicitSyncWrapper, - predicate?: _.ObjectIterateeCustom - ): LoDashExplicitSyncWrapper>; - sample( - this: LoDashExplicitSyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined> - ): LoDashExplicitSyncWrapper; - sample( - this: LoDashExplicitSyncWrapper - ): LoDashExplicitSyncWrapper; - sampleSize( - this: LoDashExplicitSyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - n?: number - ): LoDashExplicitSyncWrapper; - sampleSize( - this: LoDashExplicitSyncWrapper, - n?: number - ): LoDashExplicitSyncWrapper>; - shuffle(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - shuffle(this: LoDashExplicitSyncWrapper): LoDashExplicitSyncWrapper>; - size(): LoDashExplicitSyncWrapper; - some( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom - ): LoDashExplicitSyncWrapper; - some( - this: LoDashExplicitSyncWrapper, - predicate?: _.ObjectIterateeCustom - ): LoDashExplicitSyncWrapper; - sortBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - ...iteratees: Array<_.Many<_.ListIteratee>> - ): LoDashExplicitSyncWrapper; - sortBy( - this: LoDashExplicitSyncWrapper, - ...iteratees: Array<_.Many<_.ObjectIteratee>> - ): LoDashExplicitSyncWrapper>; - pop(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - push(this: LoDashExplicitSyncWrapper<_.List | null | undefined>, ...items: T[]): this; - shift(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - sort(this: LoDashExplicitSyncWrapper<_.List | null | undefined>, compareFn?: (a: T, b: T) => number): this; - splice(this: LoDashExplicitSyncWrapper<_.List | null | undefined>, start: number, deleteCount?: number, ...items: T[]): this; - unshift(this: LoDashExplicitSyncWrapper<_.List | null | undefined>, ...items: T[]): this; - now(): LoDashExplicitSyncWrapper; - after any>(func: TFunc): LoDashExplicitSyncWrapper; - ary(n?: number): LoDashExplicitSyncWrapper<(...args: any[]) => any>; - before any>(func: TFunc): LoDashExplicitSyncWrapper; - bind( - thisArg: any, - ...partials: any[] - ): LoDashExplicitSyncWrapper<(...args: any[]) => any>; - bindKey( - key: string, - ...partials: any[] - ): LoDashExplicitSyncWrapper<(...args: any[]) => any>; - curry(this: LoDashExplicitSyncWrapper<(t1: T1) => R>): - LoDashExplicitSyncWrapper<_.CurriedFunction1>; - curry(this: LoDashExplicitSyncWrapper<(t1: T1, t2: T2) => R>): - LoDashExplicitSyncWrapper<_.CurriedFunction2>; - curry(this: LoDashExplicitSyncWrapper<(t1: T1, t2: T2, t3: T3) => R>): - LoDashExplicitSyncWrapper<_.CurriedFunction3>; - curry(this: LoDashExplicitSyncWrapper<(t1: T1, t2: T2, t3: T3, t4: T4) => R>): - LoDashExplicitSyncWrapper<_.CurriedFunction4>; - curry(this: LoDashExplicitSyncWrapper<(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R>): - LoDashExplicitSyncWrapper<_.CurriedFunction5>; - curry(arity?: number): LoDashExplicitSyncWrapper<(...args: any[]) => any>; - curryRight(this: LoDashExplicitSyncWrapper<(t1: T1) => R>, arity?: number): - LoDashExplicitSyncWrapper<_.RightCurriedFunction1>; - curryRight(this: LoDashExplicitSyncWrapper<(t1: T1, t2: T2) => R>, arity?: number): - LoDashExplicitSyncWrapper<_.RightCurriedFunction2>; - curryRight(this: LoDashExplicitSyncWrapper<(t1: T1, t2: T2, t3: T3) => R>, arity?: number): - LoDashExplicitSyncWrapper<_.RightCurriedFunction3>; - curryRight(this: LoDashExplicitSyncWrapper<(t1: T1, t2: T2, t3: T3, t4: T4) => R>, arity?: number): - LoDashExplicitSyncWrapper<_.RightCurriedFunction4>; - curryRight(this: LoDashExplicitSyncWrapper<(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R>, arity?: number): - LoDashExplicitSyncWrapper<_.RightCurriedFunction5>; - curryRight(arity?: number): LoDashExplicitSyncWrapper<(...args: any[]) => any>; - debounce( - wait?: number, - options?: _.DebounceSettings - ): LoDashExplicitSyncWrapper; - defer(...args: any[]): LoDashExplicitSyncWrapper; - delay( - wait: number, - ...args: any[] - ): LoDashExplicitSyncWrapper; - memoize(resolver?: (...args: any[]) => any): LoDashExplicitSyncWrapper; - negate(this: LoDashExplicitSyncWrapper<() => boolean>): LoDashExplicitSyncWrapper<() => boolean>; - negate(this: LoDashExplicitSyncWrapper<(a1: A1) => boolean>): LoDashExplicitSyncWrapper<(a1: A1) => boolean>; - negate(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => boolean>): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => boolean>; - negate(this: LoDashExplicitSyncWrapper<(...args: any[]) => any>): LoDashExplicitSyncWrapper<(...args: any[]) => boolean>; - overArgs(...transforms: Array<_.Many<(...args: any[]) => any>>): LoDashExplicitSyncWrapper<(...args: any[]) => any>; - partial: _.ExplicitPartial; - partialRight: _.ExplicitPartialRight; - rearg(...indexes: Array<_.Many>): LoDashExplicitSyncWrapper<(...args: any[]) => any>; - rest(start?: number): LoDashExplicitSyncWrapper<(...args: any[]) => any>; - spread(this: LoDashExplicitSyncWrapper<(...args: any[]) => TResult>): LoDashExplicitSyncWrapper<(...args: any[]) => TResult>; - spread(this: LoDashExplicitSyncWrapper<(...args: any[]) => TResult>, start: number): LoDashExplicitSyncWrapper<(...args: any[]) => TResult>; - throttle( - wait?: number, - options?: _.ThrottleSettings - ): LoDashExplicitSyncWrapper; - unary(this: LoDashExplicitSyncWrapper<(arg1: T, ...args: any[]) => TResult>): LoDashExplicitSyncWrapper<(arg1: T) => TResult>; - wrap( - wrapper: (value: TValue, ...args: TArgs[]) => TResult - ): LoDashExplicitSyncWrapper<(...args: TArgs[]) => TResult>; - wrap( - wrapper: (value: TValue, ...args: any[]) => TResult - ): LoDashExplicitSyncWrapper<(...args: any[]) => TResult>; - castArray(this: LoDashExplicitSyncWrapper<_.Many>): LoDashExplicitSyncWrapper; - clone(): this; - cloneDeep(): this; - cloneDeepWith( - customizer: _.CloneDeepWithCustomizer - ): LoDashExplicitSyncWrapper; - cloneDeepWith(): this; - cloneWith( - customizer: _.CloneWithCustomizer - ): LoDashExplicitSyncWrapper; - cloneWith( - customizer: _.CloneWithCustomizer - ): LoDashExplicitSyncWrapper; - cloneWith(): this; - conformsTo(this: LoDashExplicitSyncWrapper, source: _.ConformsPredicateObject): LoDashExplicitSyncWrapper; - // Note: we can't use TValue here, because it generates a typescript error when strictFunctionTypes is enabled. - eq( - other: any - ): LoDashExplicitSyncWrapper; - gt(other: any): LoDashExplicitSyncWrapper; - gte(other: any): LoDashExplicitSyncWrapper; - isArguments(): LoDashExplicitSyncWrapper; - isArray(): LoDashExplicitSyncWrapper; - isArrayBuffer(): LoDashExplicitSyncWrapper; - isArrayLike(): LoDashExplicitSyncWrapper; - isArrayLikeObject(): LoDashExplicitSyncWrapper; - isBoolean(): LoDashExplicitSyncWrapper; - isBuffer(): LoDashExplicitSyncWrapper; - isDate(): LoDashExplicitSyncWrapper; - isElement(): LoDashExplicitSyncWrapper; - isEmpty(): LoDashExplicitSyncWrapper; - isEqual( - other: any - ): LoDashExplicitSyncWrapper; - isEqualWith( - other: any, - customizer?: _.IsEqualCustomizer - ): LoDashExplicitSyncWrapper; - isError(): LoDashExplicitSyncWrapper; - isFinite(): LoDashExplicitSyncWrapper; - isFunction(): LoDashExplicitSyncWrapper; - isInteger(): LoDashExplicitSyncWrapper; - isLength(): LoDashExplicitSyncWrapper; - isMap(): LoDashExplicitSyncWrapper; - isMatch(source: object): LoDashExplicitSyncWrapper; - isMatchWith(source: object, customizer: _.isMatchWithCustomizer): LoDashExplicitSyncWrapper; - isNaN(): LoDashExplicitSyncWrapper; - isNative(): LoDashExplicitSyncWrapper; - isNil(): LoDashExplicitSyncWrapper; - isNull(): LoDashExplicitSyncWrapper; - isNumber(): LoDashExplicitSyncWrapper; - isObject(): LoDashExplicitSyncWrapper; - isObjectLike(): LoDashExplicitSyncWrapper; - isPlainObject(): LoDashExplicitSyncWrapper; - isRegExp(): LoDashExplicitSyncWrapper; - isSafeInteger(): LoDashExplicitSyncWrapper; - isSet(): LoDashExplicitSyncWrapper; - isString(): LoDashExplicitSyncWrapper; - isSymbol(): LoDashExplicitSyncWrapper; - isTypedArray(): LoDashExplicitSyncWrapper; - isUndefined(): LoDashExplicitSyncWrapper; - isWeakMap(): LoDashExplicitSyncWrapper; - isWeakSet(): LoDashExplicitSyncWrapper; - lt(other: any): LoDashExplicitSyncWrapper; - lte(other: any): LoDashExplicitSyncWrapper; - toArray(this: LoDashExplicitSyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>): LoDashExplicitSyncWrapper; - toArray(this: _.LoDashImplicitWrapper): LoDashExplicitSyncWrapper>; - toFinite(): LoDashExplicitSyncWrapper; - toInteger(): LoDashExplicitSyncWrapper; - toLength(): LoDashExplicitSyncWrapper; - toNumber(): LoDashExplicitSyncWrapper; - toPlainObject(): LoDashExplicitSyncWrapper; - toSafeInteger(): LoDashExplicitSyncWrapper; - add(addend: number): LoDashExplicitSyncWrapper; - ceil(precision?: number): LoDashExplicitSyncWrapper; - divide(divisor: number): LoDashExplicitSyncWrapper; - floor(precision?: number): LoDashExplicitSyncWrapper; - max(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - maxBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - mean(): LoDashExplicitSyncWrapper; - meanBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - min(this: LoDashExplicitSyncWrapper<_.List | null | undefined>): LoDashExplicitSyncWrapper; - minBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper; - multiply(multiplicand: number): LoDashExplicitSyncWrapper; - round(precision?: number): LoDashExplicitSyncWrapper; - subtract( - subtrahend: number - ): LoDashExplicitSyncWrapper; - sum(): LoDashExplicitSyncWrapper; - sumBy( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee?: ((value: T) => number) | string - ): LoDashExplicitSyncWrapper; - clamp( - lower: number, - upper: number - ): LoDashExplicitSyncWrapper; - clamp( - upper: number - ): LoDashExplicitSyncWrapper; - inRange( - start: number, - end?: number - ): LoDashExplicitSyncWrapper; - random(floating?: boolean): LoDashExplicitSyncWrapper; - random( - max: number, - floating?: boolean - ): LoDashExplicitSyncWrapper; - assign( - source: TSource - ): LoDashExplicitSyncWrapper; - assign( - source1: TSource1, - source2: TSource2 - ): LoDashExplicitSyncWrapper; - assign( - source1: TSource1, - source2: TSource2, - source3: TSource3 - ): LoDashExplicitSyncWrapper; - assign( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4 - ): LoDashExplicitSyncWrapper; - assign(): LoDashExplicitSyncWrapper; - assign(...otherArgs: any[]): LoDashExplicitSyncWrapper; - assignIn( - source: TSource - ): LoDashExplicitSyncWrapper; - assignIn( - source1: TSource1, - source2: TSource2 - ): LoDashExplicitSyncWrapper; - assignIn( - source1: TSource1, - source2: TSource2, - source3: TSource3 - ): LoDashExplicitSyncWrapper; - assignIn( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4 - ): LoDashExplicitSyncWrapper; - assignIn(): LoDashExplicitSyncWrapper; - assignIn(...otherArgs: any[]): LoDashExplicitSyncWrapper; - assignInWith( - source: TSource, - customizer: _.AssignCustomizer - ): LoDashExplicitSyncWrapper; - assignInWith( - source1: TSource1, - source2: TSource2, - customizer: _.AssignCustomizer - ): LoDashExplicitSyncWrapper; - assignInWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - customizer: _.AssignCustomizer - ): LoDashExplicitSyncWrapper; - assignInWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4, - customizer: _.AssignCustomizer - ): LoDashExplicitSyncWrapper; - assignInWith(): LoDashExplicitSyncWrapper; - assignInWith(...otherArgs: any[]): LoDashExplicitSyncWrapper; - assignWith( - source: TSource, - customizer: _.AssignCustomizer - ): LoDashExplicitSyncWrapper; - assignWith( - source1: TSource1, - source2: TSource2, - customizer: _.AssignCustomizer - ): LoDashExplicitSyncWrapper; - assignWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - customizer: _.AssignCustomizer - ): LoDashExplicitSyncWrapper; - assignWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4, - customizer: _.AssignCustomizer - ): LoDashExplicitSyncWrapper; - assignWith(): LoDashExplicitSyncWrapper; - assignWith(...otherArgs: any[]): LoDashExplicitSyncWrapper; - at( - this: LoDashExplicitSyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - ...props: _.PropertyPath[] - ): LoDashExplicitSyncWrapper; - at( - this: LoDashExplicitSyncWrapper, - ...props: Array<_.Many> - ): LoDashExplicitSyncWrapper>; - create(properties?: U): LoDashExplicitSyncWrapper; - defaults( - source: TSource - ): LoDashExplicitSyncWrapper; - defaults( - source1: TSource1, - source2: TSource2 - ): LoDashExplicitSyncWrapper; - defaults( - source1: TSource1, - source2: TSource2, - source3: TSource3 - ): LoDashExplicitSyncWrapper; - defaults( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4 - ): LoDashExplicitSyncWrapper; - defaults(): LoDashExplicitSyncWrapper; - defaults(...sources: any[]): LoDashExplicitSyncWrapper; - defaultsDeep(...sources: any[]): LoDashExplicitSyncWrapper; - entries(this: LoDashExplicitSyncWrapper<_.Dictionary | _.NumericDictionary>): LoDashExplicitSyncWrapper>; - entries(): LoDashExplicitSyncWrapper>; - entriesIn(this: LoDashExplicitSyncWrapper<_.Dictionary | _.NumericDictionary>): LoDashExplicitSyncWrapper>; - entriesIn(): LoDashExplicitSyncWrapper>; - extend( - source: TSource - ): LoDashExplicitSyncWrapper; - extend( - source1: TSource1, - source2: TSource2 - ): LoDashExplicitSyncWrapper; - extend( - source1: TSource1, - source2: TSource2, - source3: TSource3 - ): LoDashExplicitSyncWrapper; - extend( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4 - ): LoDashExplicitSyncWrapper; - extend(): LoDashExplicitSyncWrapper; - extend(...otherArgs: any[]): LoDashExplicitSyncWrapper; - extendWith( - source: TSource, - customizer: _.AssignCustomizer - ): LoDashExplicitSyncWrapper; - extendWith( - source1: TSource1, - source2: TSource2, - customizer: _.AssignCustomizer - ): LoDashExplicitSyncWrapper; - extendWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - customizer: _.AssignCustomizer - ): LoDashExplicitSyncWrapper; - extendWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4, - customizer: _.AssignCustomizer - ): LoDashExplicitSyncWrapper; - extendWith(): LoDashExplicitSyncWrapper; - extendWith(...otherArgs: any[]): LoDashExplicitSyncWrapper; - findKey( - this: LoDashExplicitSyncWrapper, - predicate?: _.ObjectIteratee - ): LoDashExplicitSyncWrapper; - findLastKey( - this: LoDashExplicitSyncWrapper, - predicate?: _.ObjectIteratee - ): LoDashExplicitSyncWrapper; - functions(): LoDashExplicitSyncWrapper; - functionsIn(): LoDashExplicitSyncWrapper; - get( - path: TKey | [TKey] - ): LoDashExplicitSyncWrapper; - get( - this: LoDashExplicitSyncWrapper, - path: TKey | [TKey], - ): LoDashExplicitSyncWrapper; - get( - this: LoDashExplicitSyncWrapper, - path: TKey | [TKey], - defaultValue: TDefault - ): LoDashExplicitSyncWrapper | TDefault>; - get( - this: LoDashExplicitSyncWrapper<_.NumericDictionary>, - path: number - ): LoDashExplicitSyncWrapper; - get( - this: LoDashExplicitSyncWrapper<_.NumericDictionary | null | undefined>, - path: number - ): LoDashExplicitSyncWrapper; - get( - this: LoDashExplicitSyncWrapper<_.NumericDictionary | null | undefined>, - path: number, - defaultValue: TDefault - ): LoDashExplicitSyncWrapper; - get( - this: LoDashExplicitSyncWrapper, - path: _.PropertyPath, - defaultValue: TDefault - ): LoDashExplicitSyncWrapper; - get( - this: LoDashExplicitSyncWrapper, - path: _.PropertyPath - ): LoDashExplicitSyncWrapper; - get( - path: _.PropertyPath, - defaultValue?: any - ): LoDashExplicitSyncWrapper; - has(path: _.PropertyPath): LoDashExplicitSyncWrapper; - hasIn(path: _.PropertyPath): LoDashExplicitSyncWrapper; - invert(): LoDashExplicitSyncWrapper<_.Dictionary>; - invertBy( - this: LoDashExplicitSyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - interatee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper<_.Dictionary>; - invertBy( - this: LoDashExplicitSyncWrapper, - interatee?: _.ValueIteratee - ): LoDashExplicitSyncWrapper<_.Dictionary>; - invoke( - path: _.PropertyPath, - ...args: any[]): LoDashExplicitSyncWrapper; - keys(): LoDashExplicitSyncWrapper; - keysIn(): LoDashExplicitSyncWrapper; - mapKeys( - this: LoDashExplicitSyncWrapper<_.List | null | undefined>, - iteratee?: _.ListIteratee - ): LoDashExplicitSyncWrapper<_.Dictionary>; - mapKeys( - this: LoDashExplicitSyncWrapper, - iteratee?: _.ObjectIteratee - ): LoDashExplicitSyncWrapper<_.Dictionary>; - mapValues( - this: LoDashExplicitSyncWrapper, - callback: _.StringIterator - ): LoDashExplicitSyncWrapper<_.NumericDictionary>; - mapValues( - this: LoDashExplicitSyncWrapper<_.Dictionary | _.NumericDictionary | null | undefined>, - callback: _.DictionaryIterator - ): LoDashExplicitSyncWrapper<_.Dictionary>; - mapValues( - this: LoDashExplicitSyncWrapper, - callback: _.ObjectIterator - ): LoDashExplicitSyncWrapper<{ [P in keyof T]: TResult }>; - mapValues( - this: LoDashExplicitSyncWrapper<_.Dictionary | _.NumericDictionary | null | undefined>, - iteratee: object - ): LoDashExplicitSyncWrapper<_.Dictionary>; - mapValues( - this: LoDashExplicitSyncWrapper, - iteratee: object - ): LoDashExplicitSyncWrapper<{ [P in keyof T]: boolean }>; - mapValues( - this: LoDashExplicitSyncWrapper<_.Dictionary | _.NumericDictionary | null | undefined>, - iteratee: TKey - ): LoDashExplicitSyncWrapper<_.Dictionary>; - mapValues( - this: LoDashExplicitSyncWrapper<_.Dictionary | _.NumericDictionary | null | undefined>, - iteratee: string - ): LoDashExplicitSyncWrapper<_.Dictionary>; - mapValues( - this: LoDashExplicitSyncWrapper, - iteratee: string - ): LoDashExplicitSyncWrapper<{ [P in keyof T]: any }>; - mapValues(this: LoDashExplicitSyncWrapper): LoDashExplicitSyncWrapper<_.NumericDictionary>; - mapValues(this: LoDashExplicitSyncWrapper<_.Dictionary | _.NumericDictionary | null | undefined>): LoDashExplicitSyncWrapper<_.Dictionary>; - mapValues(this: LoDashExplicitSyncWrapper): LoDashExplicitSyncWrapper; - mapValues(this: LoDashExplicitSyncWrapper): LoDashExplicitSyncWrapper<_.PartialObject>; - merge( - source: TSource - ): LoDashExplicitSyncWrapper; - merge( - source1: TSource1, - source2: TSource2 - ): LoDashExplicitSyncWrapper; - merge( - source1: TSource1, - source2: TSource2, - source3: TSource3 - ): LoDashExplicitSyncWrapper; - merge( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4 - ): LoDashExplicitSyncWrapper; - merge( - ...otherArgs: any[] - ): LoDashExplicitSyncWrapper; - mergeWith( - source: TSource, - customizer: _.MergeWithCustomizer - ): LoDashExplicitSyncWrapper; - mergeWith( - source1: TSource1, - source2: TSource2, - customizer: _.MergeWithCustomizer - ): LoDashExplicitSyncWrapper; - mergeWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - customizer: _.MergeWithCustomizer - ): LoDashExplicitSyncWrapper; - mergeWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4, - customizer: _.MergeWithCustomizer - ): LoDashExplicitSyncWrapper; - mergeWith( - ...otherArgs: any[] - ): LoDashExplicitSyncWrapper; - omit( - this: LoDashExplicitSyncWrapper, - ...paths: Array<_.Many<_.PropertyName>> - ): LoDashExplicitSyncWrapper; - omit( - this: LoDashExplicitSyncWrapper, - ...paths: Array<_.Many> - ): LoDashExplicitSyncWrapper<_.Omit>; - omit( - this: LoDashExplicitSyncWrapper, - ...paths: Array<_.Many<_.PropertyName>> - ): LoDashExplicitSyncWrapper<_.PartialObject>; - omitBy( - this: LoDashExplicitSyncWrapper<_.Dictionary | null | undefined>, - predicate?: _.ValueKeyIteratee - ): LoDashExplicitSyncWrapper<_.Dictionary>; - omitBy( - this: LoDashExplicitSyncWrapper<_.NumericDictionary | null | undefined>, - predicate?: _.ValueKeyIteratee - ): LoDashExplicitSyncWrapper<_.NumericDictionary>; - omitBy( - this: LoDashExplicitSyncWrapper, - predicate: _.ValueKeyIteratee - ): LoDashExplicitSyncWrapper<_.PartialObject>; - pick( - this: LoDashExplicitSyncWrapper, - ...props: Array<_.Many> - ): LoDashExplicitSyncWrapper>; - pick( - this: LoDashExplicitSyncWrapper, - ...props: _.PropertyPath[] - ): LoDashExplicitSyncWrapper<_.PartialObject>; - pickBy( - this: LoDashExplicitSyncWrapper<_.Dictionary | null | undefined>, - predicate: _.ValueKeyIterateeTypeGuard - ): LoDashExplicitSyncWrapper<_.Dictionary>; - pickBy( - this: LoDashExplicitSyncWrapper<_.NumericDictionary | null | undefined>, - predicate: _.ValueKeyIterateeTypeGuard - ): LoDashExplicitSyncWrapper<_.NumericDictionary>; - pickBy( - this: LoDashExplicitSyncWrapper<_.Dictionary | null | undefined>, - predicate?: _.ValueKeyIteratee - ): LoDashExplicitSyncWrapper<_.Dictionary>; - pickBy( - this: LoDashExplicitSyncWrapper<_.NumericDictionary | null | undefined>, - predicate?: _.ValueKeyIteratee - ): LoDashExplicitSyncWrapper<_.NumericDictionary>; - pickBy( - this: LoDashExplicitSyncWrapper, - predicate?: _.ValueKeyIteratee - ): LoDashExplicitSyncWrapper<_.PartialObject>; - result( - path: _.PropertyPath, - defaultValue?: TResult|((...args: any[]) => TResult) - ): LoDashExplicitSyncWrapper; - set( - path: _.PropertyPath, - value: any - ): this; - set( - path: _.PropertyPath, - value: any - ): LoDashExplicitSyncWrapper; - setWith( - path: _.PropertyPath, - value: any, - customizer?: _.SetWithCustomizer - ): this; - setWith( - path: _.PropertyPath, - value: any, - customizer?: _.SetWithCustomizer - ): LoDashExplicitSyncWrapper; - toPairs(this: LoDashExplicitSyncWrapper<_.Dictionary | _.NumericDictionary>): LoDashExplicitSyncWrapper>; - toPairs(): LoDashExplicitSyncWrapper>; - toPairsIn(this: LoDashExplicitSyncWrapper<_.Dictionary | _.NumericDictionary>): LoDashExplicitSyncWrapper>; - toPairsIn(): LoDashExplicitSyncWrapper>; - transform( - this: LoDashExplicitSyncWrapper, - iteratee: _.MemoVoidArrayIterator, - accumulator?: TResult[] - ): LoDashExplicitSyncWrapper; - transform( - this: LoDashExplicitSyncWrapper, - iteratee: _.MemoVoidArrayIterator>, - accumulator?: _.Dictionary - ): LoDashExplicitSyncWrapper<_.Dictionary>; - transform( - this: LoDashExplicitSyncWrapper<_.Dictionary>, - iteratee: _.MemoVoidDictionaryIterator>, - accumulator?: _.Dictionary - ): LoDashExplicitSyncWrapper<_.Dictionary>; - transform( - this: LoDashExplicitSyncWrapper<_.Dictionary>, - iteratee: _.MemoVoidDictionaryIterator, - accumulator?: TResult[] - ): LoDashExplicitSyncWrapper; - transform( - this: LoDashExplicitSyncWrapper, - ): LoDashExplicitSyncWrapper; - transform(): LoDashExplicitSyncWrapper<_.Dictionary>; - unset(path: _.PropertyPath): LoDashExplicitSyncWrapper; - update( - path: _.PropertyPath, - updater: (value: any) => any - ): LoDashExplicitSyncWrapper; - updateWith( - path: _.PropertyPath, - updater: (oldValue: any) => any, - customizer?: _.SetWithCustomizer - ): this; - updateWith( - path: _.PropertyPath, - updater: (oldValue: any) => any, - customizer?: _.SetWithCustomizer - ): LoDashExplicitSyncWrapper; - values(this: LoDashExplicitSyncWrapper<_.Dictionary | _.NumericDictionary | _.List | null | undefined>): LoDashExplicitSyncWrapper; - values(this: LoDashExplicitSyncWrapper): LoDashExplicitSyncWrapper>; - values(): LoDashExplicitSyncWrapper; - valuesIn(this: LoDashExplicitSyncWrapper<_.Dictionary | _.NumericDictionary | _.List | null | undefined>): LoDashExplicitSyncWrapper; - valuesIn(this: LoDashExplicitSyncWrapper): LoDashExplicitSyncWrapper>; - chain(): this; - chain(): this; - plant(value: T): LoDashExplicitSyncWrapper; - thru(interceptor: (value: TValue) => TResult): LoDashExplicitSyncWrapper; - camelCase(): LoDashExplicitSyncWrapper; - capitalize(): LoDashExplicitSyncWrapper; - deburr(): LoDashExplicitSyncWrapper; - endsWith( - target?: string, - position?: number - ): LoDashExplicitSyncWrapper; - escape(): LoDashExplicitSyncWrapper; - escapeRegExp(): LoDashExplicitSyncWrapper; - kebabCase(): LoDashExplicitSyncWrapper; - lowerCase(): LoDashExplicitSyncWrapper; - lowerFirst(): LoDashExplicitSyncWrapper; - pad( - length?: number, - chars?: string - ): LoDashExplicitSyncWrapper; - padEnd( - length?: number, - chars?: string - ): LoDashExplicitSyncWrapper; - padStart( - length?: number, - chars?: string - ): LoDashExplicitSyncWrapper; - parseInt(radix?: number): LoDashExplicitSyncWrapper; - repeat(n?: number): LoDashExplicitSyncWrapper; - replace( - pattern: RegExp | string, - replacement: _.ReplaceFunction | string - ): LoDashExplicitSyncWrapper; - replace( - replacement: _.ReplaceFunction | string - ): LoDashExplicitSyncWrapper; - snakeCase(): LoDashExplicitSyncWrapper; - split( - separator?: RegExp|string, - limit?: number - ): LoDashExplicitSyncWrapper; - startCase(): LoDashExplicitSyncWrapper; - startsWith( - target?: string, - position?: number - ): LoDashExplicitSyncWrapper; - template(options?: _.TemplateOptions): LoDashExplicitSyncWrapper<_.TemplateExecutor>; - toLower(): LoDashExplicitSyncWrapper; - toUpper(): LoDashExplicitSyncWrapper; - trim(chars?: string): LoDashExplicitSyncWrapper; - trimEnd(chars?: string): LoDashExplicitSyncWrapper; - trimStart(chars?: string): LoDashExplicitSyncWrapper; - truncate(options?: _.TruncateOptions): LoDashExplicitSyncWrapper; - unescape(): LoDashExplicitSyncWrapper; - upperCase(): LoDashExplicitSyncWrapper; - upperFirst(): LoDashExplicitSyncWrapper; - words(pattern?: string|RegExp): LoDashExplicitSyncWrapper; - attempt(...args: any[]): LoDashExplicitSyncWrapper; - conforms(this: LoDashExplicitSyncWrapper<_.ConformsPredicateObject>): LoDashExplicitSyncWrapper<(value: T) => boolean>; - constant(): LoDashExplicitSyncWrapper<() => TValue>; - defaultTo(this: LoDashExplicitSyncWrapper, defaultValue: T): LoDashExplicitSyncWrapper; - defaultTo( - this: LoDashExplicitSyncWrapper, - defaultValue: TDefault - ): LoDashExplicitSyncWrapper; - // 0-argument first function - flow(this: LoDashExplicitSyncWrapper<() => R1>, f2: (a: R1) => R2): LoDashExplicitSyncWrapper<() => R2>; - flow(this: LoDashExplicitSyncWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitSyncWrapper<() => R3>; - flow(this: LoDashExplicitSyncWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitSyncWrapper<() => R4>; - flow(this: LoDashExplicitSyncWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitSyncWrapper<() => R5>; - flow(this: LoDashExplicitSyncWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitSyncWrapper<() => R6>; - flow(this: LoDashExplicitSyncWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): LoDashExplicitSyncWrapper<() => R7>; - flow(this: LoDashExplicitSyncWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitSyncWrapper<() => any>; - // 1-argument first function - flow(this: LoDashExplicitSyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2): LoDashExplicitSyncWrapper<(a1: A1) => R2>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitSyncWrapper<(a1: A1) => R3>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitSyncWrapper<(a1: A1) => R4>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitSyncWrapper<(a1: A1) => R5>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitSyncWrapper<(a1: A1) => R6>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): LoDashExplicitSyncWrapper<(a1: A1) => R7>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitSyncWrapper<(a1: A1) => any>; - // 2-argument first function - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R2>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R3>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R4>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R5>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R6>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R7>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => any>; - // 3-argument first function - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R2>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R3>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R4>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R5>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R6>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R7>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => any>; - // 4-argument first function - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R2>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R3>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R4>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R5>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R6>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R7>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => any>; - // any-argument first function - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R2>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R3>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R4>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R5>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R6>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R7>; - flow(this: LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => any>; - flow(this: LoDashExplicitSyncWrapper<(...args: any[]) => any>, funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitSyncWrapper<(...args: any[]) => any>; - // 0-argument first function - flowRight(this: LoDashExplicitSyncWrapper<(a: R1) => R2>, f1: () => R1): LoDashExplicitSyncWrapper<() => R2>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitSyncWrapper<() => R3>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitSyncWrapper<() => R4>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitSyncWrapper<() => R5>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitSyncWrapper<() => R6>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitSyncWrapper<() => R7>; - // 1-argument first function - flowRight(this: LoDashExplicitSyncWrapper<(a: R1) => R2>, f1: (a1: A1) => R1): LoDashExplicitSyncWrapper<(a1: A1) => R2>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitSyncWrapper<(a1: A1) => R3>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitSyncWrapper<(a1: A1) => R4>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitSyncWrapper<(a1: A1) => R5>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitSyncWrapper<(a1: A1) => R6>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitSyncWrapper<(a1: A1) => R7>; - // 2-argument first function - flowRight(this: LoDashExplicitSyncWrapper<(a: R1) => R2>, f1: (a1: A1, a2: A2) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R2>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R3>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R4>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R5>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R6>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2) => R7>; - // 3-argument first function - flowRight(this: LoDashExplicitSyncWrapper<(a: R1) => R2>, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R2>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R3>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R4>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R5>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R6>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3) => R7>; - // 4-argument first function - flowRight(this: LoDashExplicitSyncWrapper<(a: R1) => R2>, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R2>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R3>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R4>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R5>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R6>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitSyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R7>; - // any-argument first function - flowRight(this: LoDashExplicitSyncWrapper<(a: R1) => R2>, f1: (...args: any[]) => R1): LoDashExplicitSyncWrapper<(...args: any[]) => R2>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R1) => R2>, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitSyncWrapper<(...args: any[]) => R3>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R1) => R2>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitSyncWrapper<(...args: any[]) => R4>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R1) => R2>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitSyncWrapper<(...args: any[]) => R5>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R1) => R2>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitSyncWrapper<(...args: any[]) => R6>; - flowRight(this: LoDashExplicitSyncWrapper<(a: R1) => R2>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitSyncWrapper<(...args: any[]) => R7>; - flowRight(this: LoDashExplicitSyncWrapper<(a: any) => any>, f6: (a: any) => any, f5: (a: any) => any, f4: (a: any) => any, f3: (a: any) => any, f2: (a: any) => any, f1: () => any, ...funcs: Array<_.Many<(...args: any[]) => any>>): LoDashExplicitSyncWrapper<(...args: any[]) => any>; - flowRight(this: LoDashExplicitSyncWrapper<(a: any) => any>, funcs: Array<_.Many<(...args: any[]) => any>>): LoDashExplicitSyncWrapper<(...args: any[]) => any>; - identity(): this; - iteratee any>( - this: LoDashExplicitSyncWrapper - ): LoDashExplicitSyncWrapper; - matches(): LoDashExplicitSyncWrapper<(value: V) => boolean>; - matchesProperty( - srcValue: SrcValue - ): LoDashExplicitSyncWrapper<(value: any) => boolean>; - matchesProperty( - srcValue: SrcValue - ): LoDashExplicitSyncWrapper<(value: Value) => boolean>; - method(...args: any[]): LoDashExplicitSyncWrapper<(object: any) => any>; - methodOf( - ...args: any[] - ): LoDashExplicitSyncWrapper<(path: _.PropertyPath) => any>; - mixin( - source: _.Dictionary<(...args: any[]) => any>, - options?: _.MixinOptions - ): this; - mixin( - options?: _.MixinOptions - ): LoDashExplicitSyncWrapper<_.LoDashStatic>; - noConflict(): LoDashExplicitSyncWrapper; - noop(...args: any[]): LoDashExplicitSyncWrapper; - nthArg(): LoDashExplicitSyncWrapper<(...args: any[]) => any>; - over( - this: LoDashExplicitSyncWrapper<_.Many<(...args: any[]) => TResult>>, - ...iteratees: Array<_.Many<(...args: any[]) => TResult>> - ): LoDashExplicitSyncWrapper<(...args: any[]) => TResult[]>; - overEvery(...predicates: Array<_.Many<(...args: T[]) => boolean>>): LoDashExplicitSyncWrapper<(...args: T[]) => boolean>; - overSome(...predicates: Array<_.Many<(...args: T[]) => boolean>>): LoDashExplicitSyncWrapper<(...args: T[]) => boolean>; - property(): LoDashExplicitSyncWrapper<(obj: TObj) => TResult>; - propertyOf(): LoDashExplicitSyncWrapper<(path: _.PropertyPath) => any>; - range( - end?: number, - step?: number - ): LoDashExplicitSyncWrapper; - rangeRight( - end?: number, - step?: number - ): LoDashExplicitSyncWrapper; - stubArray(): LoDashExplicitSyncWrapper; - stubFalse(): LoDashExplicitSyncWrapper; - stubObject(): LoDashExplicitSyncWrapper; - stubString(): LoDashExplicitSyncWrapper; - stubTrue(): LoDashExplicitSyncWrapper; - times( - iteratee: (num: number) => TResult - ): LoDashExplicitSyncWrapper; - times(): LoDashExplicitSyncWrapper; - toPath(): LoDashExplicitSyncWrapper; - uniqueId(): LoDashExplicitSyncWrapper; - } - - interface LoDashExplicitAsyncWrapper { - chunk( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - size?: number, - ): LoDashExplicitAsyncWrapper; - compact(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - concat(this: LoDashExplicitAsyncWrapper<_.Many>, ...values: Array<_.Many>): LoDashExplicitAsyncWrapper; - difference( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - ...values: Array<_.List> - ): LoDashExplicitAsyncWrapper; - differenceBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - differenceBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - differenceBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - values3: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - differenceBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - values3: _.List, - values4: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - differenceBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - values3: _.List, - values4: _.List, - values5: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - differenceBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - values3: _.List, - values4: _.List, - values5: _.List, - ...values: Array<_.List | _.ValueIteratee> - ): LoDashExplicitAsyncWrapper; - differenceBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - ...values: Array<_.List> - ): LoDashExplicitAsyncWrapper; - differenceWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values: _.List, - comparator: _.Comparator2 - ): LoDashExplicitAsyncWrapper; - differenceWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - comparator: _.Comparator2 - ): LoDashExplicitAsyncWrapper; - differenceWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - ...values: Array<_.List | _.Comparator2> - ): LoDashExplicitAsyncWrapper; - differenceWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - ...values: Array<_.List> - ): LoDashExplicitAsyncWrapper; - drop(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, n?: number): LoDashExplicitAsyncWrapper; - dropRight(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, n?: number): LoDashExplicitAsyncWrapper; - dropRightWhile( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate?: _.ListIteratee - ): LoDashExplicitAsyncWrapper; - dropWhile( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate?: _.ListIteratee - ): LoDashExplicitAsyncWrapper; - fill( - this: LoDashExplicitAsyncWrapper, - value: T - ): LoDashExplicitAsyncWrapper; - fill( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - value: T - ): LoDashExplicitAsyncWrapper<_.List>; - fill( - this: LoDashExplicitAsyncWrapper, - value: T, - start?: number, - end?: number - ): LoDashExplicitAsyncWrapper>; - fill( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - value: T, - start?: number, - end?: number - ): LoDashExplicitAsyncWrapper<_.List>; - findIndex( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom, - fromIndex?: number - ): LoDashExplicitAsyncWrapper; - findLastIndex( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom, - fromIndex?: number - ): LoDashExplicitAsyncWrapper; - first(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - flatten(this: LoDashExplicitAsyncWrapper<_.List<_.Many> | null | undefined>): LoDashExplicitAsyncWrapper; - flattenDeep(this: LoDashExplicitAsyncWrapper<_.ListOfRecursiveArraysOrValues | null | undefined>): LoDashExplicitAsyncWrapper; - flattenDepth(this: LoDashExplicitAsyncWrapper<_.ListOfRecursiveArraysOrValues | null | undefined>, depth?: number): LoDashExplicitAsyncWrapper; - fromPairs( - this: LoDashExplicitAsyncWrapper<_.List<[_.PropertyName, T]> | null | undefined> - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - fromPairs( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined> - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - head(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - indexOf( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - value: T, - fromIndex?: number - ): LoDashExplicitAsyncWrapper; - initial(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - intersection( - this: LoDashExplicitAsyncWrapper<_.List>, - ...arrays: Array<_.List> - ): LoDashExplicitAsyncWrapper; - intersectionBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - intersectionBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - iteratee: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - intersectionBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - ...values: Array<_.List | _.ValueIteratee> - ): LoDashExplicitAsyncWrapper; - intersectionBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - ...values: Array<_.List> - ): LoDashExplicitAsyncWrapper; - intersectionWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values: _.List, - comparator: _.Comparator2 - ): LoDashExplicitAsyncWrapper; - intersectionWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - comparator: _.Comparator2 - ): LoDashExplicitAsyncWrapper; - intersectionWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - values1: _.List, - values2: _.List, - ...values: Array<_.List | _.Comparator2> - ): LoDashExplicitAsyncWrapper; - intersectionWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - ...values: Array<_.List> - ): LoDashExplicitAsyncWrapper; - join(separator?: string): LoDashExplicitAsyncWrapper; - last(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - lastIndexOf( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - value: T, - fromIndex?: true|number - ): LoDashExplicitAsyncWrapper; - nth( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - n?: number - ): LoDashExplicitAsyncWrapper; - pull( - this: LoDashExplicitAsyncWrapper<_.List>, - ...values: T[] - ): this; - pullAll( - this: LoDashExplicitAsyncWrapper<_.List>, - values?: _.List - ): this; - remove( - this: LoDashExplicitAsyncWrapper<_.List>, - predicate?: _.ListIteratee - ): LoDashExplicitAsyncWrapper; - slice( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - start?: number, - end?: number - ): LoDashExplicitAsyncWrapper; - sortedIndex( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - value: T - ): LoDashExplicitAsyncWrapper; - sortedIndex( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - value: T - ): LoDashExplicitAsyncWrapper; - sortedIndexBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - value: T, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - sortedIndexOf( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - value: T - ): LoDashExplicitAsyncWrapper; - sortedLastIndex( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - value: T - ): LoDashExplicitAsyncWrapper; - sortedLastIndexBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - value: T, - iteratee: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - sortedLastIndexOf( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - value: T - ): LoDashExplicitAsyncWrapper; - sortedUniq(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - sortedUniqBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - tail(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - take( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - n?: number - ): LoDashExplicitAsyncWrapper; - takeRight( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - n?: number - ): LoDashExplicitAsyncWrapper; - takeRightWhile( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate?: _.ListIteratee - ): LoDashExplicitAsyncWrapper; - takeWhile( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate?: _.ListIteratee - ): LoDashExplicitAsyncWrapper; - union( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - ...arrays: Array<_.List | null | undefined> - ): LoDashExplicitAsyncWrapper; - unionBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - unionBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - unionBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - arrays3: _.List | null | undefined, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - unionBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - arrays3: _.List | null | undefined, - arrays4: _.List | null | undefined, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - unionBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - arrays3: _.List | null | undefined, - arrays4: _.List | null | undefined, - arrays5: _.List | null | undefined, - ...iteratee: Array<_.ValueIteratee | _.List | null | undefined> - ): LoDashExplicitAsyncWrapper; - unionWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - comparator?: _.Comparator - ): LoDashExplicitAsyncWrapper; - unionWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - comparator?: _.Comparator - ): LoDashExplicitAsyncWrapper; - unionWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - arrays3: _.List | null | undefined, - ...comparator: Array<_.Comparator | _.List | null | undefined> - ): LoDashExplicitAsyncWrapper; - uniq(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - uniqBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - uniqWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - comparator?: _.Comparator - ): LoDashExplicitAsyncWrapper; - unzip(this: LoDashExplicitAsyncWrapper> | null | undefined>): LoDashExplicitAsyncWrapper; - unzipWith( - this: LoDashExplicitAsyncWrapper<_.List<_.List> | null | undefined>, - iteratee: (...values: T[]) => TResult - ): LoDashExplicitAsyncWrapper; - unzipWith( - this: LoDashExplicitAsyncWrapper<_.List<_.List> | null | undefined> - ): LoDashExplicitAsyncWrapper; - without( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - ...values: T[] - ): LoDashExplicitAsyncWrapper; - xor( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - ...arrays: Array<_.List | null | undefined> - ): LoDashExplicitAsyncWrapper; - xorBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - xorBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - xorBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - arrays3: _.List | null | undefined, - ...iteratee: Array<_.ValueIteratee | _.List | null | undefined> - ): LoDashExplicitAsyncWrapper; - xorWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - comparator?: _.Comparator - ): LoDashExplicitAsyncWrapper; - xorWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - comparator?: _.Comparator - ): LoDashExplicitAsyncWrapper; - xorWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - arrays2: _.List | null | undefined, - arrays3: _.List | null | undefined, - ...comparator: Array<_.Comparator | _.List | null | undefined> - ): LoDashExplicitAsyncWrapper; - zip( - this: LoDashExplicitAsyncWrapper<_.List>, - arrays2: _.List, - ): LoDashExplicitAsyncWrapper>; - zip( - this: LoDashExplicitAsyncWrapper<_.List>, - arrays2: _.List, - arrays3: _.List, - ): LoDashExplicitAsyncWrapper>; - zip( - this: LoDashExplicitAsyncWrapper<_.List>, - arrays2: _.List, - arrays3: _.List, - arrays4: _.List, - ): LoDashExplicitAsyncWrapper>; - zip( - this: LoDashExplicitAsyncWrapper<_.List>, - arrays2: _.List, - arrays3: _.List, - arrays4: _.List, - arrays5: _.List, - ): LoDashExplicitAsyncWrapper>; - zip( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - ...arrays: Array<_.List | null | undefined> - ): LoDashExplicitAsyncWrapper>>; - zipObject( - this: LoDashExplicitAsyncWrapper<_.List<_.PropertyName>>, - values: _.List - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - zipObject( - this: LoDashExplicitAsyncWrapper<_.List<_.PropertyName>> - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - zipObjectDeep( - this: LoDashExplicitAsyncWrapper<_.List<_.PropertyPath>>, - values?: _.List - ): LoDashExplicitAsyncWrapper; - zipWith( - this: LoDashExplicitAsyncWrapper<_.List>, - iteratee: (value1: T) => TResult - ): LoDashExplicitAsyncWrapper; - zipWith( - this: LoDashExplicitAsyncWrapper<_.List>, - arrays2: _.List, - iteratee: (value1: T1, value2: T2) => TResult - ): LoDashExplicitAsyncWrapper; - zipWith( - this: LoDashExplicitAsyncWrapper<_.List>, - arrays2: _.List, - arrays3: _.List, - iteratee: (value1: T1, value2: T2, value3: T3) => TResult - ): LoDashExplicitAsyncWrapper; - zipWith( - this: LoDashExplicitAsyncWrapper<_.List>, - arrays2: _.List, - arrays3: _.List, - arrays4: _.List, - iteratee: (value1: T1, value2: T2, value3: T3, value4: T4) => TResult - ): LoDashExplicitAsyncWrapper; - zipWith( - this: LoDashExplicitAsyncWrapper<_.List>, - arrays2: _.List, - arrays3: _.List, - arrays4: _.List, - arrays5: _.List, - iteratee: (value1: T1, value2: T2, value3: T3, value4: T4, value5: T5) => TResult - ): LoDashExplicitAsyncWrapper; - zipWith( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - ...iteratee: Array<((...group: T[]) => TResult) | _.List | null | undefined> - ): LoDashExplicitAsyncWrapper; - countBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - countBy( - this: LoDashExplicitAsyncWrapper, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - every( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom - ): LoDashExplicitAsyncWrapper; - every( - this: LoDashExplicitAsyncWrapper, - predicate?: _.ObjectIterateeCustom - ): LoDashExplicitAsyncWrapper; - filter( - this: LoDashExplicitAsyncWrapper, - predicate?: _.StringIterator - ): LoDashExplicitAsyncWrapper; - filter( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate: _.ListIteratorTypeGuard - ): LoDashExplicitAsyncWrapper; - filter( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom - ): LoDashExplicitAsyncWrapper; - filter( - this: LoDashExplicitAsyncWrapper, - predicate: _.ObjectIteratorTypeGuard - ): LoDashExplicitAsyncWrapper; - filter( - this: LoDashExplicitAsyncWrapper, - predicate?: _.ObjectIterateeCustom - ): LoDashExplicitAsyncWrapper>; - find( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate: _.ListIteratorTypeGuard, - fromIndex?: number - ): LoDashExplicitAsyncWrapper; - find( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom, - fromIndex?: number - ): LoDashExplicitAsyncWrapper; - find( - this: LoDashExplicitAsyncWrapper, - predicate: _.ObjectIteratorTypeGuard, - fromIndex?: number - ): LoDashExplicitAsyncWrapper; - find( - this: LoDashExplicitAsyncWrapper, - predicate?: _.ObjectIterateeCustom, - fromIndex?: number - ): LoDashExplicitAsyncWrapper; - findLast( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate: _.ListIteratorTypeGuard, - fromIndex?: number - ): LoDashExplicitAsyncWrapper; - findLast( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom, - fromIndex?: number - ): LoDashExplicitAsyncWrapper; - findLast( - this: LoDashExplicitAsyncWrapper, - predicate: _.ObjectIteratorTypeGuard, - fromIndex?: number - ): LoDashExplicitAsyncWrapper; - findLast( - this: LoDashExplicitAsyncWrapper, - predicate?: _.ObjectIterateeCustom, - fromIndex?: number - ): LoDashExplicitAsyncWrapper; - flatMap(this: LoDashExplicitAsyncWrapper<_.List<_.Many> | _.Dictionary<_.Many> | _.NumericDictionary<_.Many> | null | undefined>): LoDashExplicitAsyncWrapper; - flatMap(): LoDashExplicitAsyncWrapper; - flatMap( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee: _.ListIterator> - ): LoDashExplicitAsyncWrapper; - flatMap( - this: LoDashExplicitAsyncWrapper, - iteratee: _.ObjectIterator> - ): LoDashExplicitAsyncWrapper; - flatMap( - iteratee: string - ): LoDashExplicitAsyncWrapper; - flatMap( - iteratee: object - ): LoDashExplicitAsyncWrapper; - flatMapDeep( - this: LoDashExplicitAsyncWrapper<_.List<_.ListOfRecursiveArraysOrValues | T> | _.Dictionary<_.ListOfRecursiveArraysOrValues | T> | _.NumericDictionary<_.ListOfRecursiveArraysOrValues | T> | null | undefined> - ): LoDashExplicitAsyncWrapper; - flatMapDeep( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee: _.ListIterator | TResult> - ): LoDashExplicitAsyncWrapper; - flatMapDeep( - this: LoDashExplicitAsyncWrapper, - iteratee: _.ObjectIterator | TResult> - ): LoDashExplicitAsyncWrapper; - flatMapDeep( - this: LoDashExplicitAsyncWrapper, - iteratee: string - ): LoDashExplicitAsyncWrapper; - flatMapDeep( - this: LoDashExplicitAsyncWrapper, - iteratee: object - ): LoDashExplicitAsyncWrapper; - flatMapDepth( - this: LoDashExplicitAsyncWrapper<_.List<_.ListOfRecursiveArraysOrValues | T> | _.Dictionary<_.ListOfRecursiveArraysOrValues | T> | _.NumericDictionary<_.ListOfRecursiveArraysOrValues | T> | null | undefined> - ): LoDashExplicitAsyncWrapper; - flatMapDepth( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee: _.ListIterator | TResult>, - depth?: number - ): LoDashExplicitAsyncWrapper; - flatMapDepth( - this: LoDashExplicitAsyncWrapper, - iteratee: _.ObjectIterator | TResult>, - depth?: number - ): LoDashExplicitAsyncWrapper; - flatMapDepth( - this: LoDashExplicitAsyncWrapper, - iteratee: string, - depth?: number - ): LoDashExplicitAsyncWrapper; - flatMapDepth( - this: LoDashExplicitAsyncWrapper, - iteratee: object, - depth?: number - ): LoDashExplicitAsyncWrapper; - groupBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - groupBy( - this: LoDashExplicitAsyncWrapper, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper<_.Dictionary>>; - includes( - this: LoDashExplicitAsyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - target: T, - fromIndex?: number - ): LoDashExplicitAsyncWrapper; - invokeMap( - methodName: string, - ...args: any[]): LoDashExplicitAsyncWrapper; - invokeMap( - method: (...args: any[]) => TResult, - ...args: any[]): LoDashExplicitAsyncWrapper; - keyBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIterateeCustom - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - keyBy( - this: LoDashExplicitAsyncWrapper, - iteratee?: _.ValueIterateeCustom - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - map( - this: LoDashExplicitAsyncWrapper, - iteratee: _.ArrayIterator - ): LoDashExplicitAsyncWrapper; - map( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee: _.ListIterator - ): LoDashExplicitAsyncWrapper; - map(this: LoDashExplicitAsyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>): LoDashExplicitAsyncWrapper; - map( - this: LoDashExplicitAsyncWrapper, - iteratee: _.ObjectIterator - ): LoDashExplicitAsyncWrapper; - map( - this: LoDashExplicitAsyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - iteratee: K - ): LoDashExplicitAsyncWrapper>; - map( - this: LoDashExplicitAsyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - iteratee?: string - ): LoDashExplicitAsyncWrapper; - map( - this: LoDashExplicitAsyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - iteratee?: object - ): LoDashExplicitAsyncWrapper; - orderBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratees?: _.Many<_.ListIterator>, - orders?: _.Many - ): LoDashExplicitAsyncWrapper; - orderBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratees?: _.Many<_.ListIteratee>, - orders?: _.Many - ): LoDashExplicitAsyncWrapper; - orderBy( - this: LoDashExplicitAsyncWrapper, - iteratees?: _.Many<_.ObjectIterator>, - orders?: _.Many - ): LoDashExplicitAsyncWrapper>; - orderBy( - this: LoDashExplicitAsyncWrapper, - iteratees?: _.Many<_.ObjectIteratee>, - orders?: _.Many - ): LoDashExplicitAsyncWrapper>; - partition( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - callback: _.ValueIteratorTypeGuard - ): LoDashExplicitAsyncWrapper<[U[], Array>]>; - partition( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - callback: _.ValueIteratee - ): LoDashExplicitAsyncWrapper<[T[], T[]]>; - partition( - this: LoDashExplicitAsyncWrapper, - callback: _.ValueIteratee - ): LoDashExplicitAsyncWrapper<[Array, Array]>; - reduce( - this: LoDashExplicitAsyncWrapper, - callback: _.MemoListIterator, - accumulator: TResult - ): LoDashExplicitAsyncWrapper; - reduce( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - callback: _.MemoListIterator>, - accumulator: TResult - ): LoDashExplicitAsyncWrapper; - reduce( - this: LoDashExplicitAsyncWrapper, - callback: _.MemoObjectIterator, - accumulator: TResult - ): LoDashExplicitAsyncWrapper; - reduce( - this: LoDashExplicitAsyncWrapper, - callback: _.MemoListIterator - ): LoDashExplicitAsyncWrapper; - reduce( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - callback: _.MemoListIterator> - ): LoDashExplicitAsyncWrapper; - reduce( - this: LoDashExplicitAsyncWrapper, - callback: _.MemoObjectIterator - ): LoDashExplicitAsyncWrapper; - reduceRight( - this: LoDashExplicitAsyncWrapper, - callback: _.MemoListIterator, - accumulator: TResult - ): LoDashExplicitAsyncWrapper; - reduceRight( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - callback: _.MemoListIterator>, - accumulator: TResult - ): LoDashExplicitAsyncWrapper; - reduceRight( - this: LoDashExplicitAsyncWrapper, - callback: _.MemoObjectIterator, - accumulator: TResult - ): LoDashExplicitAsyncWrapper; - reduceRight( - this: LoDashExplicitAsyncWrapper, - callback: _.MemoListIterator - ): LoDashExplicitAsyncWrapper; - reduceRight( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - callback: _.MemoListIterator> - ): LoDashExplicitAsyncWrapper; - reduceRight( - this: LoDashExplicitAsyncWrapper, - callback: _.MemoObjectIterator - ): LoDashExplicitAsyncWrapper; - reject( - this: LoDashExplicitAsyncWrapper, - predicate?: _.StringIterator - ): LoDashExplicitAsyncWrapper; - reject( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom - ): LoDashExplicitAsyncWrapper; - reject( - this: LoDashExplicitAsyncWrapper, - predicate?: _.ObjectIterateeCustom - ): LoDashExplicitAsyncWrapper>; - sample( - this: LoDashExplicitAsyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined> - ): LoDashExplicitAsyncWrapper; - sample( - this: LoDashExplicitAsyncWrapper - ): LoDashExplicitAsyncWrapper; - sampleSize( - this: LoDashExplicitAsyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - n?: number - ): LoDashExplicitAsyncWrapper; - sampleSize( - this: LoDashExplicitAsyncWrapper, - n?: number - ): LoDashExplicitAsyncWrapper>; - shuffle(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - shuffle(this: LoDashExplicitAsyncWrapper): LoDashExplicitAsyncWrapper>; - size(): LoDashExplicitAsyncWrapper; - some( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - predicate?: _.ListIterateeCustom - ): LoDashExplicitAsyncWrapper; - some( - this: LoDashExplicitAsyncWrapper, - predicate?: _.ObjectIterateeCustom - ): LoDashExplicitAsyncWrapper; - sortBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - ...iteratees: Array<_.Many<_.ListIteratee>> - ): LoDashExplicitAsyncWrapper; - sortBy( - this: LoDashExplicitAsyncWrapper, - ...iteratees: Array<_.Many<_.ObjectIteratee>> - ): LoDashExplicitAsyncWrapper>; - pop(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - push(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, ...items: T[]): this; - shift(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - sort(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, compareFn?: (a: T, b: T) => number): this; - splice(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, start: number, deleteCount?: number, ...items: T[]): this; - unshift(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, ...items: T[]): this; - now(): LoDashExplicitAsyncWrapper; - after any>(func: TFunc): LoDashExplicitAsyncWrapper; - ary(n?: number): LoDashExplicitAsyncWrapper<(...args: any[]) => any>; - before any>(func: TFunc): LoDashExplicitAsyncWrapper; - bind( - thisArg: any, - ...partials: any[] - ): LoDashExplicitAsyncWrapper<(...args: any[]) => any>; - bindKey( - key: string, - ...partials: any[] - ): LoDashExplicitAsyncWrapper<(...args: any[]) => any>; - curry(this: LoDashExplicitAsyncWrapper<(t1: T1) => R>): - LoDashExplicitAsyncWrapper<_.CurriedFunction1>; - curry(this: LoDashExplicitAsyncWrapper<(t1: T1, t2: T2) => R>): - LoDashExplicitAsyncWrapper<_.CurriedFunction2>; - curry(this: LoDashExplicitAsyncWrapper<(t1: T1, t2: T2, t3: T3) => R>): - LoDashExplicitAsyncWrapper<_.CurriedFunction3>; - curry(this: LoDashExplicitAsyncWrapper<(t1: T1, t2: T2, t3: T3, t4: T4) => R>): - LoDashExplicitAsyncWrapper<_.CurriedFunction4>; - curry(this: LoDashExplicitAsyncWrapper<(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R>): - LoDashExplicitAsyncWrapper<_.CurriedFunction5>; - curry(arity?: number): LoDashExplicitAsyncWrapper<(...args: any[]) => any>; - curryRight(this: LoDashExplicitAsyncWrapper<(t1: T1) => R>, arity?: number): - LoDashExplicitAsyncWrapper<_.RightCurriedFunction1>; - curryRight(this: LoDashExplicitAsyncWrapper<(t1: T1, t2: T2) => R>, arity?: number): - LoDashExplicitAsyncWrapper<_.RightCurriedFunction2>; - curryRight(this: LoDashExplicitAsyncWrapper<(t1: T1, t2: T2, t3: T3) => R>, arity?: number): - LoDashExplicitAsyncWrapper<_.RightCurriedFunction3>; - curryRight(this: LoDashExplicitAsyncWrapper<(t1: T1, t2: T2, t3: T3, t4: T4) => R>, arity?: number): - LoDashExplicitAsyncWrapper<_.RightCurriedFunction4>; - curryRight(this: LoDashExplicitAsyncWrapper<(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R>, arity?: number): - LoDashExplicitAsyncWrapper<_.RightCurriedFunction5>; - curryRight(arity?: number): LoDashExplicitAsyncWrapper<(...args: any[]) => any>; - debounce( - wait?: number, - options?: _.DebounceSettings - ): LoDashExplicitAsyncWrapper; - defer(...args: any[]): LoDashExplicitAsyncWrapper; - delay( - wait: number, - ...args: any[] - ): LoDashExplicitAsyncWrapper; - memoize(resolver?: (...args: any[]) => any): LoDashExplicitAsyncWrapper; - negate(this: LoDashExplicitAsyncWrapper<() => boolean>): LoDashExplicitAsyncWrapper<() => boolean>; - negate(this: LoDashExplicitAsyncWrapper<(a1: A1) => boolean>): LoDashExplicitAsyncWrapper<(a1: A1) => boolean>; - negate(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => boolean>): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => boolean>; - negate(this: LoDashExplicitAsyncWrapper<(...args: any[]) => any>): LoDashExplicitAsyncWrapper<(...args: any[]) => boolean>; - overArgs(...transforms: Array<_.Many<(...args: any[]) => any>>): LoDashExplicitAsyncWrapper<(...args: any[]) => any>; - partial: _.ExplicitPartial; - partialRight: _.ExplicitPartialRight; - rearg(...indexes: Array<_.Many>): LoDashExplicitAsyncWrapper<(...args: any[]) => any>; - rest(start?: number): LoDashExplicitAsyncWrapper<(...args: any[]) => any>; - spread(this: LoDashExplicitAsyncWrapper<(...args: any[]) => TResult>): LoDashExplicitAsyncWrapper<(...args: any[]) => TResult>; - spread(this: LoDashExplicitAsyncWrapper<(...args: any[]) => TResult>, start: number): LoDashExplicitAsyncWrapper<(...args: any[]) => TResult>; - throttle( - wait?: number, - options?: _.ThrottleSettings - ): LoDashExplicitAsyncWrapper; - unary(this: LoDashExplicitAsyncWrapper<(arg1: T, ...args: any[]) => TResult>): LoDashExplicitAsyncWrapper<(arg1: T) => TResult>; - wrap( - wrapper: (value: TValue, ...args: TArgs[]) => TResult - ): LoDashExplicitAsyncWrapper<(...args: TArgs[]) => TResult>; - wrap( - wrapper: (value: TValue, ...args: any[]) => TResult - ): LoDashExplicitAsyncWrapper<(...args: any[]) => TResult>; - castArray(this: LoDashExplicitAsyncWrapper<_.Many>): LoDashExplicitAsyncWrapper; - clone(): this; - cloneDeep(): this; - cloneDeepWith( - customizer: _.CloneDeepWithCustomizer - ): LoDashExplicitAsyncWrapper; - cloneDeepWith(): this; - cloneWith( - customizer: _.CloneWithCustomizer - ): LoDashExplicitAsyncWrapper; - cloneWith( - customizer: _.CloneWithCustomizer - ): LoDashExplicitAsyncWrapper; - cloneWith(): this; - conformsTo(this: LoDashExplicitAsyncWrapper, source: _.ConformsPredicateObject): LoDashExplicitAsyncWrapper; - // Note: we can't use TValue here, because it generates a typescript error when strictFunctionTypes is enabled. - eq( - other: any - ): LoDashExplicitAsyncWrapper; - gt(other: any): LoDashExplicitAsyncWrapper; - gte(other: any): LoDashExplicitAsyncWrapper; - isArguments(): LoDashExplicitAsyncWrapper; - isArray(): LoDashExplicitAsyncWrapper; - isArrayBuffer(): LoDashExplicitAsyncWrapper; - isArrayLike(): LoDashExplicitAsyncWrapper; - isArrayLikeObject(): LoDashExplicitAsyncWrapper; - isBoolean(): LoDashExplicitAsyncWrapper; - isBuffer(): LoDashExplicitAsyncWrapper; - isDate(): LoDashExplicitAsyncWrapper; - isElement(): LoDashExplicitAsyncWrapper; - isEmpty(): LoDashExplicitAsyncWrapper; - isEqual( - other: any - ): LoDashExplicitAsyncWrapper; - isEqualWith( - other: any, - customizer?: _.IsEqualCustomizer - ): LoDashExplicitAsyncWrapper; - isError(): LoDashExplicitAsyncWrapper; - isFinite(): LoDashExplicitAsyncWrapper; - isFunction(): LoDashExplicitAsyncWrapper; - isInteger(): LoDashExplicitAsyncWrapper; - isLength(): LoDashExplicitAsyncWrapper; - isMap(): LoDashExplicitAsyncWrapper; - isMatch(source: object): LoDashExplicitAsyncWrapper; - isMatchWith(source: object, customizer: _.isMatchWithCustomizer): LoDashExplicitAsyncWrapper; - isNaN(): LoDashExplicitAsyncWrapper; - isNative(): LoDashExplicitAsyncWrapper; - isNil(): LoDashExplicitAsyncWrapper; - isNull(): LoDashExplicitAsyncWrapper; - isNumber(): LoDashExplicitAsyncWrapper; - isObject(): LoDashExplicitAsyncWrapper; - isObjectLike(): LoDashExplicitAsyncWrapper; - isPlainObject(): LoDashExplicitAsyncWrapper; - isRegExp(): LoDashExplicitAsyncWrapper; - isSafeInteger(): LoDashExplicitAsyncWrapper; - isSet(): LoDashExplicitAsyncWrapper; - isString(): LoDashExplicitAsyncWrapper; - isSymbol(): LoDashExplicitAsyncWrapper; - isTypedArray(): LoDashExplicitAsyncWrapper; - isUndefined(): LoDashExplicitAsyncWrapper; - isWeakMap(): LoDashExplicitAsyncWrapper; - isWeakSet(): LoDashExplicitAsyncWrapper; - lt(other: any): LoDashExplicitAsyncWrapper; - lte(other: any): LoDashExplicitAsyncWrapper; - toArray(this: LoDashExplicitAsyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>): LoDashExplicitAsyncWrapper; - toArray(this: _.LoDashImplicitWrapper): LoDashExplicitAsyncWrapper>; - toFinite(): LoDashExplicitAsyncWrapper; - toInteger(): LoDashExplicitAsyncWrapper; - toLength(): LoDashExplicitAsyncWrapper; - toNumber(): LoDashExplicitAsyncWrapper; - toPlainObject(): LoDashExplicitAsyncWrapper; - toSafeInteger(): LoDashExplicitAsyncWrapper; - add(addend: number): LoDashExplicitAsyncWrapper; - ceil(precision?: number): LoDashExplicitAsyncWrapper; - divide(divisor: number): LoDashExplicitAsyncWrapper; - floor(precision?: number): LoDashExplicitAsyncWrapper; - max(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - maxBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - mean(): LoDashExplicitAsyncWrapper; - meanBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - min(this: LoDashExplicitAsyncWrapper<_.List | null | undefined>): LoDashExplicitAsyncWrapper; - minBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper; - multiply(multiplicand: number): LoDashExplicitAsyncWrapper; - round(precision?: number): LoDashExplicitAsyncWrapper; - subtract( - subtrahend: number - ): LoDashExplicitAsyncWrapper; - sum(): LoDashExplicitAsyncWrapper; - sumBy( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee?: ((value: T) => number) | string - ): LoDashExplicitAsyncWrapper; - clamp( - lower: number, - upper: number - ): LoDashExplicitAsyncWrapper; - clamp( - upper: number - ): LoDashExplicitAsyncWrapper; - inRange( - start: number, - end?: number - ): LoDashExplicitAsyncWrapper; - random(floating?: boolean): LoDashExplicitAsyncWrapper; - random( - max: number, - floating?: boolean - ): LoDashExplicitAsyncWrapper; - assign( - source: TSource - ): LoDashExplicitAsyncWrapper; - assign( - source1: TSource1, - source2: TSource2 - ): LoDashExplicitAsyncWrapper; - assign( - source1: TSource1, - source2: TSource2, - source3: TSource3 - ): LoDashExplicitAsyncWrapper; - assign( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4 - ): LoDashExplicitAsyncWrapper; - assign(): LoDashExplicitAsyncWrapper; - assign(...otherArgs: any[]): LoDashExplicitAsyncWrapper; - assignIn( - source: TSource - ): LoDashExplicitAsyncWrapper; - assignIn( - source1: TSource1, - source2: TSource2 - ): LoDashExplicitAsyncWrapper; - assignIn( - source1: TSource1, - source2: TSource2, - source3: TSource3 - ): LoDashExplicitAsyncWrapper; - assignIn( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4 - ): LoDashExplicitAsyncWrapper; - assignIn(): LoDashExplicitAsyncWrapper; - assignIn(...otherArgs: any[]): LoDashExplicitAsyncWrapper; - assignInWith( - source: TSource, - customizer: _.AssignCustomizer - ): LoDashExplicitAsyncWrapper; - assignInWith( - source1: TSource1, - source2: TSource2, - customizer: _.AssignCustomizer - ): LoDashExplicitAsyncWrapper; - assignInWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - customizer: _.AssignCustomizer - ): LoDashExplicitAsyncWrapper; - assignInWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4, - customizer: _.AssignCustomizer - ): LoDashExplicitAsyncWrapper; - assignInWith(): LoDashExplicitAsyncWrapper; - assignInWith(...otherArgs: any[]): LoDashExplicitAsyncWrapper; - assignWith( - source: TSource, - customizer: _.AssignCustomizer - ): LoDashExplicitAsyncWrapper; - assignWith( - source1: TSource1, - source2: TSource2, - customizer: _.AssignCustomizer - ): LoDashExplicitAsyncWrapper; - assignWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - customizer: _.AssignCustomizer - ): LoDashExplicitAsyncWrapper; - assignWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4, - customizer: _.AssignCustomizer - ): LoDashExplicitAsyncWrapper; - assignWith(): LoDashExplicitAsyncWrapper; - assignWith(...otherArgs: any[]): LoDashExplicitAsyncWrapper; - at( - this: LoDashExplicitAsyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - ...props: _.PropertyPath[] - ): LoDashExplicitAsyncWrapper; - at( - this: LoDashExplicitAsyncWrapper, - ...props: Array<_.Many> - ): LoDashExplicitAsyncWrapper>; - create(properties?: U): LoDashExplicitAsyncWrapper; - defaults( - source: TSource - ): LoDashExplicitAsyncWrapper; - defaults( - source1: TSource1, - source2: TSource2 - ): LoDashExplicitAsyncWrapper; - defaults( - source1: TSource1, - source2: TSource2, - source3: TSource3 - ): LoDashExplicitAsyncWrapper; - defaults( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4 - ): LoDashExplicitAsyncWrapper; - defaults(): LoDashExplicitAsyncWrapper; - defaults(...sources: any[]): LoDashExplicitAsyncWrapper; - defaultsDeep(...sources: any[]): LoDashExplicitAsyncWrapper; - entries(this: LoDashExplicitAsyncWrapper<_.Dictionary | _.NumericDictionary>): LoDashExplicitAsyncWrapper>; - entries(): LoDashExplicitAsyncWrapper>; - entriesIn(this: LoDashExplicitAsyncWrapper<_.Dictionary | _.NumericDictionary>): LoDashExplicitAsyncWrapper>; - entriesIn(): LoDashExplicitAsyncWrapper>; - extend( - source: TSource - ): LoDashExplicitAsyncWrapper; - extend( - source1: TSource1, - source2: TSource2 - ): LoDashExplicitAsyncWrapper; - extend( - source1: TSource1, - source2: TSource2, - source3: TSource3 - ): LoDashExplicitAsyncWrapper; - extend( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4 - ): LoDashExplicitAsyncWrapper; - extend(): LoDashExplicitAsyncWrapper; - extend(...otherArgs: any[]): LoDashExplicitAsyncWrapper; - extendWith( - source: TSource, - customizer: _.AssignCustomizer - ): LoDashExplicitAsyncWrapper; - extendWith( - source1: TSource1, - source2: TSource2, - customizer: _.AssignCustomizer - ): LoDashExplicitAsyncWrapper; - extendWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - customizer: _.AssignCustomizer - ): LoDashExplicitAsyncWrapper; - extendWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4, - customizer: _.AssignCustomizer - ): LoDashExplicitAsyncWrapper; - extendWith(): LoDashExplicitAsyncWrapper; - extendWith(...otherArgs: any[]): LoDashExplicitAsyncWrapper; - findKey( - this: LoDashExplicitAsyncWrapper, - predicate?: _.ObjectIteratee - ): LoDashExplicitAsyncWrapper; - findLastKey( - this: LoDashExplicitAsyncWrapper, - predicate?: _.ObjectIteratee - ): LoDashExplicitAsyncWrapper; - functions(): LoDashExplicitAsyncWrapper; - functionsIn(): LoDashExplicitAsyncWrapper; - get( - path: TKey | [TKey] - ): LoDashExplicitAsyncWrapper; - get( - this: LoDashExplicitAsyncWrapper, - path: TKey | [TKey], - ): LoDashExplicitAsyncWrapper; - get( - this: LoDashExplicitAsyncWrapper, - path: TKey | [TKey], - defaultValue: TDefault - ): LoDashExplicitAsyncWrapper | TDefault>; - get( - this: LoDashExplicitAsyncWrapper<_.NumericDictionary>, - path: number - ): LoDashExplicitAsyncWrapper; - get( - this: LoDashExplicitAsyncWrapper<_.NumericDictionary | null | undefined>, - path: number - ): LoDashExplicitAsyncWrapper; - get( - this: LoDashExplicitAsyncWrapper<_.NumericDictionary | null | undefined>, - path: number, - defaultValue: TDefault - ): LoDashExplicitAsyncWrapper; - get( - this: LoDashExplicitAsyncWrapper, - path: _.PropertyPath, - defaultValue: TDefault - ): LoDashExplicitAsyncWrapper; - get( - this: LoDashExplicitAsyncWrapper, - path: _.PropertyPath - ): LoDashExplicitAsyncWrapper; - get( - path: _.PropertyPath, - defaultValue?: any - ): LoDashExplicitAsyncWrapper; - has(path: _.PropertyPath): LoDashExplicitAsyncWrapper; - hasIn(path: _.PropertyPath): LoDashExplicitAsyncWrapper; - invert(): LoDashExplicitAsyncWrapper<_.Dictionary>; - invertBy( - this: LoDashExplicitAsyncWrapper<_.List | _.Dictionary | _.NumericDictionary | null | undefined>, - interatee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - invertBy( - this: LoDashExplicitAsyncWrapper, - interatee?: _.ValueIteratee - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - invoke( - path: _.PropertyPath, - ...args: any[]): LoDashExplicitAsyncWrapper; - keys(): LoDashExplicitAsyncWrapper; - keysIn(): LoDashExplicitAsyncWrapper; - mapKeys( - this: LoDashExplicitAsyncWrapper<_.List | null | undefined>, - iteratee?: _.ListIteratee - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - mapKeys( - this: LoDashExplicitAsyncWrapper, - iteratee?: _.ObjectIteratee - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - mapValues( - this: LoDashExplicitAsyncWrapper, - callback: _.StringIterator - ): LoDashExplicitAsyncWrapper<_.NumericDictionary>; - mapValues( - this: LoDashExplicitAsyncWrapper<_.Dictionary | _.NumericDictionary | null | undefined>, - callback: _.DictionaryIterator - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - mapValues( - this: LoDashExplicitAsyncWrapper, - callback: _.ObjectIterator - ): LoDashExplicitAsyncWrapper<{ [P in keyof T]: TResult }>; - mapValues( - this: LoDashExplicitAsyncWrapper<_.Dictionary | _.NumericDictionary | null | undefined>, - iteratee: object - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - mapValues( - this: LoDashExplicitAsyncWrapper, - iteratee: object - ): LoDashExplicitAsyncWrapper<{ [P in keyof T]: boolean }>; - mapValues( - this: LoDashExplicitAsyncWrapper<_.Dictionary | _.NumericDictionary | null | undefined>, - iteratee: TKey - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - mapValues( - this: LoDashExplicitAsyncWrapper<_.Dictionary | _.NumericDictionary | null | undefined>, - iteratee: string - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - mapValues( - this: LoDashExplicitAsyncWrapper, - iteratee: string - ): LoDashExplicitAsyncWrapper<{ [P in keyof T]: any }>; - mapValues(this: LoDashExplicitAsyncWrapper): LoDashExplicitAsyncWrapper<_.NumericDictionary>; - mapValues(this: LoDashExplicitAsyncWrapper<_.Dictionary | _.NumericDictionary | null | undefined>): LoDashExplicitAsyncWrapper<_.Dictionary>; - mapValues(this: LoDashExplicitAsyncWrapper): LoDashExplicitAsyncWrapper; - mapValues(this: LoDashExplicitAsyncWrapper): LoDashExplicitAsyncWrapper<_.PartialObject>; - merge( - source: TSource - ): LoDashExplicitAsyncWrapper; - merge( - source1: TSource1, - source2: TSource2 - ): LoDashExplicitAsyncWrapper; - merge( - source1: TSource1, - source2: TSource2, - source3: TSource3 - ): LoDashExplicitAsyncWrapper; - merge( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4 - ): LoDashExplicitAsyncWrapper; - merge( - ...otherArgs: any[] - ): LoDashExplicitAsyncWrapper; - mergeWith( - source: TSource, - customizer: _.MergeWithCustomizer - ): LoDashExplicitAsyncWrapper; - mergeWith( - source1: TSource1, - source2: TSource2, - customizer: _.MergeWithCustomizer - ): LoDashExplicitAsyncWrapper; - mergeWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - customizer: _.MergeWithCustomizer - ): LoDashExplicitAsyncWrapper; - mergeWith( - source1: TSource1, - source2: TSource2, - source3: TSource3, - source4: TSource4, - customizer: _.MergeWithCustomizer - ): LoDashExplicitAsyncWrapper; - mergeWith( - ...otherArgs: any[] - ): LoDashExplicitAsyncWrapper; - omit( - this: LoDashExplicitAsyncWrapper, - ...paths: Array<_.Many<_.PropertyName>> - ): LoDashExplicitAsyncWrapper; - omit( - this: LoDashExplicitAsyncWrapper, - ...paths: Array<_.Many> - ): LoDashExplicitAsyncWrapper<_.Omit>; - omit( - this: LoDashExplicitAsyncWrapper, - ...paths: Array<_.Many<_.PropertyName>> - ): LoDashExplicitAsyncWrapper<_.PartialObject>; - omitBy( - this: LoDashExplicitAsyncWrapper<_.Dictionary | null | undefined>, - predicate?: _.ValueKeyIteratee - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - omitBy( - this: LoDashExplicitAsyncWrapper<_.NumericDictionary | null | undefined>, - predicate?: _.ValueKeyIteratee - ): LoDashExplicitAsyncWrapper<_.NumericDictionary>; - omitBy( - this: LoDashExplicitAsyncWrapper, - predicate: _.ValueKeyIteratee - ): LoDashExplicitAsyncWrapper<_.PartialObject>; - pick( - this: LoDashExplicitAsyncWrapper, - ...props: Array<_.Many> - ): LoDashExplicitAsyncWrapper>; - pick( - this: LoDashExplicitAsyncWrapper, - ...props: _.PropertyPath[] - ): LoDashExplicitAsyncWrapper<_.PartialObject>; - pickBy( - this: LoDashExplicitAsyncWrapper<_.Dictionary | null | undefined>, - predicate: _.ValueKeyIterateeTypeGuard - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - pickBy( - this: LoDashExplicitAsyncWrapper<_.NumericDictionary | null | undefined>, - predicate: _.ValueKeyIterateeTypeGuard - ): LoDashExplicitAsyncWrapper<_.NumericDictionary>; - pickBy( - this: LoDashExplicitAsyncWrapper<_.Dictionary | null | undefined>, - predicate?: _.ValueKeyIteratee - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - pickBy( - this: LoDashExplicitAsyncWrapper<_.NumericDictionary | null | undefined>, - predicate?: _.ValueKeyIteratee - ): LoDashExplicitAsyncWrapper<_.NumericDictionary>; - pickBy( - this: LoDashExplicitAsyncWrapper, - predicate?: _.ValueKeyIteratee - ): LoDashExplicitAsyncWrapper<_.PartialObject>; - result( - path: _.PropertyPath, - defaultValue?: TResult|((...args: any[]) => TResult) - ): LoDashExplicitAsyncWrapper; - set( - path: _.PropertyPath, - value: any - ): this; - set( - path: _.PropertyPath, - value: any - ): LoDashExplicitAsyncWrapper; - setWith( - path: _.PropertyPath, - value: any, - customizer?: _.SetWithCustomizer - ): this; - setWith( - path: _.PropertyPath, - value: any, - customizer?: _.SetWithCustomizer - ): LoDashExplicitAsyncWrapper; - toPairs(this: LoDashExplicitAsyncWrapper<_.Dictionary | _.NumericDictionary>): LoDashExplicitAsyncWrapper>; - toPairs(): LoDashExplicitAsyncWrapper>; - toPairsIn(this: LoDashExplicitAsyncWrapper<_.Dictionary | _.NumericDictionary>): LoDashExplicitAsyncWrapper>; - toPairsIn(): LoDashExplicitAsyncWrapper>; - transform( - this: LoDashExplicitAsyncWrapper, - iteratee: _.MemoVoidArrayIterator, - accumulator?: TResult[] - ): LoDashExplicitAsyncWrapper; - transform( - this: LoDashExplicitAsyncWrapper, - iteratee: _.MemoVoidArrayIterator>, - accumulator?: _.Dictionary - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - transform( - this: LoDashExplicitAsyncWrapper<_.Dictionary>, - iteratee: _.MemoVoidDictionaryIterator>, - accumulator?: _.Dictionary - ): LoDashExplicitAsyncWrapper<_.Dictionary>; - transform( - this: LoDashExplicitAsyncWrapper<_.Dictionary>, - iteratee: _.MemoVoidDictionaryIterator, - accumulator?: TResult[] - ): LoDashExplicitAsyncWrapper; - transform( - this: LoDashExplicitAsyncWrapper, - ): LoDashExplicitAsyncWrapper; - transform(): LoDashExplicitAsyncWrapper<_.Dictionary>; - unset(path: _.PropertyPath): LoDashExplicitAsyncWrapper; - update( - path: _.PropertyPath, - updater: (value: any) => any - ): LoDashExplicitAsyncWrapper; - updateWith( - path: _.PropertyPath, - updater: (oldValue: any) => any, - customizer?: _.SetWithCustomizer - ): this; - updateWith( - path: _.PropertyPath, - updater: (oldValue: any) => any, - customizer?: _.SetWithCustomizer - ): LoDashExplicitAsyncWrapper; - values(this: LoDashExplicitAsyncWrapper<_.Dictionary | _.NumericDictionary | _.List | null | undefined>): LoDashExplicitAsyncWrapper; - values(this: LoDashExplicitAsyncWrapper): LoDashExplicitAsyncWrapper>; - values(): LoDashExplicitAsyncWrapper; - valuesIn(this: LoDashExplicitAsyncWrapper<_.Dictionary | _.NumericDictionary | _.List | null | undefined>): LoDashExplicitAsyncWrapper; - valuesIn(this: LoDashExplicitAsyncWrapper): LoDashExplicitAsyncWrapper>; - chain(): this; - chain(): this; - plant(value: T): LoDashExplicitAsyncWrapper; - thru(interceptor: (value: TValue) => TResult): LoDashExplicitAsyncWrapper; - camelCase(): LoDashExplicitAsyncWrapper; - capitalize(): LoDashExplicitAsyncWrapper; - deburr(): LoDashExplicitAsyncWrapper; - endsWith( - target?: string, - position?: number - ): LoDashExplicitAsyncWrapper; - escape(): LoDashExplicitAsyncWrapper; - escapeRegExp(): LoDashExplicitAsyncWrapper; - kebabCase(): LoDashExplicitAsyncWrapper; - lowerCase(): LoDashExplicitAsyncWrapper; - lowerFirst(): LoDashExplicitAsyncWrapper; - pad( - length?: number, - chars?: string - ): LoDashExplicitAsyncWrapper; - padEnd( - length?: number, - chars?: string - ): LoDashExplicitAsyncWrapper; - padStart( - length?: number, - chars?: string - ): LoDashExplicitAsyncWrapper; - parseInt(radix?: number): LoDashExplicitAsyncWrapper; - repeat(n?: number): LoDashExplicitAsyncWrapper; - replace( - pattern: RegExp | string, - replacement: _.ReplaceFunction | string - ): LoDashExplicitAsyncWrapper; - replace( - replacement: _.ReplaceFunction | string - ): LoDashExplicitAsyncWrapper; - snakeCase(): LoDashExplicitAsyncWrapper; - split( - separator?: RegExp|string, - limit?: number - ): LoDashExplicitAsyncWrapper; - startCase(): LoDashExplicitAsyncWrapper; - startsWith( - target?: string, - position?: number - ): LoDashExplicitAsyncWrapper; - template(options?: _.TemplateOptions): LoDashExplicitAsyncWrapper<_.TemplateExecutor>; - toLower(): LoDashExplicitAsyncWrapper; - toUpper(): LoDashExplicitAsyncWrapper; - trim(chars?: string): LoDashExplicitAsyncWrapper; - trimEnd(chars?: string): LoDashExplicitAsyncWrapper; - trimStart(chars?: string): LoDashExplicitAsyncWrapper; - truncate(options?: _.TruncateOptions): LoDashExplicitAsyncWrapper; - unescape(): LoDashExplicitAsyncWrapper; - upperCase(): LoDashExplicitAsyncWrapper; - upperFirst(): LoDashExplicitAsyncWrapper; - words(pattern?: string|RegExp): LoDashExplicitAsyncWrapper; - attempt(...args: any[]): LoDashExplicitAsyncWrapper; - conforms(this: LoDashExplicitAsyncWrapper<_.ConformsPredicateObject>): LoDashExplicitAsyncWrapper<(value: T) => boolean>; - constant(): LoDashExplicitAsyncWrapper<() => TValue>; - defaultTo(this: LoDashExplicitAsyncWrapper, defaultValue: T): LoDashExplicitAsyncWrapper; - defaultTo( - this: LoDashExplicitAsyncWrapper, - defaultValue: TDefault - ): LoDashExplicitAsyncWrapper; - // 0-argument first function - flow(this: LoDashExplicitAsyncWrapper<() => R1>, f2: (a: R1) => R2): LoDashExplicitAsyncWrapper<() => R2>; - flow(this: LoDashExplicitAsyncWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitAsyncWrapper<() => R3>; - flow(this: LoDashExplicitAsyncWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitAsyncWrapper<() => R4>; - flow(this: LoDashExplicitAsyncWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitAsyncWrapper<() => R5>; - flow(this: LoDashExplicitAsyncWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitAsyncWrapper<() => R6>; - flow(this: LoDashExplicitAsyncWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): LoDashExplicitAsyncWrapper<() => R7>; - flow(this: LoDashExplicitAsyncWrapper<() => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitAsyncWrapper<() => any>; - // 1-argument first function - flow(this: LoDashExplicitAsyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2): LoDashExplicitAsyncWrapper<(a1: A1) => R2>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitAsyncWrapper<(a1: A1) => R3>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitAsyncWrapper<(a1: A1) => R4>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitAsyncWrapper<(a1: A1) => R5>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitAsyncWrapper<(a1: A1) => R6>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): LoDashExplicitAsyncWrapper<(a1: A1) => R7>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitAsyncWrapper<(a1: A1) => any>; - // 2-argument first function - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R2>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R3>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R4>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R5>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R6>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R7>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => any>; - // 3-argument first function - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R2>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R3>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R4>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R5>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R6>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R7>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => any>; - // 4-argument first function - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R2>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R3>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R4>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R5>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R6>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R7>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => any>; - // any-argument first function - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R2>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R3>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R4>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R5>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R6>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R7>; - flow(this: LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1>, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => any>; - flow(this: LoDashExplicitAsyncWrapper<(...args: any[]) => any>, funcs: Array<_.Many<(a: any) => any>>): LoDashExplicitAsyncWrapper<(...args: any[]) => any>; - // 0-argument first function - flowRight(this: LoDashExplicitAsyncWrapper<(a: R1) => R2>, f1: () => R1): LoDashExplicitAsyncWrapper<() => R2>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitAsyncWrapper<() => R3>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitAsyncWrapper<() => R4>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitAsyncWrapper<() => R5>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitAsyncWrapper<() => R6>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): LoDashExplicitAsyncWrapper<() => R7>; - // 1-argument first function - flowRight(this: LoDashExplicitAsyncWrapper<(a: R1) => R2>, f1: (a1: A1) => R1): LoDashExplicitAsyncWrapper<(a1: A1) => R2>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitAsyncWrapper<(a1: A1) => R3>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitAsyncWrapper<(a1: A1) => R4>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitAsyncWrapper<(a1: A1) => R5>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitAsyncWrapper<(a1: A1) => R6>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): LoDashExplicitAsyncWrapper<(a1: A1) => R7>; - // 2-argument first function - flowRight(this: LoDashExplicitAsyncWrapper<(a: R1) => R2>, f1: (a1: A1, a2: A2) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R2>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R3>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R4>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R5>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R6>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2) => R7>; - // 3-argument first function - flowRight(this: LoDashExplicitAsyncWrapper<(a: R1) => R2>, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R2>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R3>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R4>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R5>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R6>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3) => R7>; - // 4-argument first function - flowRight(this: LoDashExplicitAsyncWrapper<(a: R1) => R2>, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R2>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R2) => R3>, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R3>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R3) => R4>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R4>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R4) => R5>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R5>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R5) => R6>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R6>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R6) => R7>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1): LoDashExplicitAsyncWrapper<(a1: A1, a2: A2, a3: A3, a4: A4) => R7>; - // any-argument first function - flowRight(this: LoDashExplicitAsyncWrapper<(a: R1) => R2>, f1: (...args: any[]) => R1): LoDashExplicitAsyncWrapper<(...args: any[]) => R2>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R1) => R2>, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitAsyncWrapper<(...args: any[]) => R3>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R1) => R2>, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitAsyncWrapper<(...args: any[]) => R4>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R1) => R2>, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitAsyncWrapper<(...args: any[]) => R5>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R1) => R2>, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitAsyncWrapper<(...args: any[]) => R6>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: R1) => R2>, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: any[]) => R1): LoDashExplicitAsyncWrapper<(...args: any[]) => R7>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: any) => any>, f6: (a: any) => any, f5: (a: any) => any, f4: (a: any) => any, f3: (a: any) => any, f2: (a: any) => any, f1: () => any, ...funcs: Array<_.Many<(...args: any[]) => any>>): LoDashExplicitAsyncWrapper<(...args: any[]) => any>; - flowRight(this: LoDashExplicitAsyncWrapper<(a: any) => any>, funcs: Array<_.Many<(...args: any[]) => any>>): LoDashExplicitAsyncWrapper<(...args: any[]) => any>; - identity(): this; - iteratee any>( - this: LoDashExplicitAsyncWrapper - ): LoDashExplicitAsyncWrapper; - matches(): LoDashExplicitAsyncWrapper<(value: V) => boolean>; - matchesProperty( - srcValue: SrcValue - ): LoDashExplicitAsyncWrapper<(value: any) => boolean>; - matchesProperty( - srcValue: SrcValue - ): LoDashExplicitAsyncWrapper<(value: Value) => boolean>; - method(...args: any[]): LoDashExplicitAsyncWrapper<(object: any) => any>; - methodOf( - ...args: any[] - ): LoDashExplicitAsyncWrapper<(path: _.PropertyPath) => any>; - mixin( - source: _.Dictionary<(...args: any[]) => any>, - options?: _.MixinOptions - ): this; - mixin( - options?: _.MixinOptions - ): LoDashExplicitAsyncWrapper<_.LoDashStatic>; - noConflict(): LoDashExplicitAsyncWrapper; - noop(...args: any[]): LoDashExplicitAsyncWrapper; - nthArg(): LoDashExplicitAsyncWrapper<(...args: any[]) => any>; - over( - this: LoDashExplicitAsyncWrapper<_.Many<(...args: any[]) => TResult>>, - ...iteratees: Array<_.Many<(...args: any[]) => TResult>> - ): LoDashExplicitAsyncWrapper<(...args: any[]) => TResult[]>; - overEvery(...predicates: Array<_.Many<(...args: T[]) => boolean>>): LoDashExplicitAsyncWrapper<(...args: T[]) => boolean>; - overSome(...predicates: Array<_.Many<(...args: T[]) => boolean>>): LoDashExplicitAsyncWrapper<(...args: T[]) => boolean>; - property(): LoDashExplicitAsyncWrapper<(obj: TObj) => TResult>; - propertyOf(): LoDashExplicitAsyncWrapper<(path: _.PropertyPath) => any>; - range( - end?: number, - step?: number - ): LoDashExplicitAsyncWrapper; - rangeRight( - end?: number, - step?: number - ): LoDashExplicitAsyncWrapper; - stubArray(): LoDashExplicitAsyncWrapper; - stubFalse(): LoDashExplicitAsyncWrapper; - stubObject(): LoDashExplicitAsyncWrapper; - stubString(): LoDashExplicitAsyncWrapper; - stubTrue(): LoDashExplicitAsyncWrapper; - times( - iteratee: (num: number) => TResult - ): LoDashExplicitAsyncWrapper; - times(): LoDashExplicitAsyncWrapper; - toPath(): LoDashExplicitAsyncWrapper; - uniqueId(): LoDashExplicitAsyncWrapper; - } -} diff --git a/types/lowdb/index.d.ts b/types/lowdb/index.d.ts index 3663b35823..40e68037db 100644 --- a/types/lowdb/index.d.ts +++ b/types/lowdb/index.d.ts @@ -3,11 +3,29 @@ // Definitions by: typicode // Bazyli Brzóska // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped -// TypeScript Version: 2.8 +// TypeScript Version: 3.1 -/// - -import { LoDashStatic } from "lodash"; +import { LoDashStatic, ObjectChain } from "lodash"; +declare module "lodash" { + interface ObjectChain { + /** + * @description Be careful: This function overwrites the whole database. + */ + write(): T & Promise; + } + interface PrimitiveChain { + write(): T & Promise; + } + interface CollectionChain { + write(): ArrayLike & Promise>; + } + interface FunctionChain { + write(): T & Promise; + } + interface StringChain { + write(): string & Promise; + } +} declare let Lowdb: Lowdb.lowdb; export = Lowdb; @@ -49,22 +67,22 @@ declare namespace Lowdb { setState: (state: SchemaT) => this; } - interface LowdbSync extends LowdbBase, LoDashExplicitSyncWrapper { + interface LowdbSync extends LowdbBase, ObjectChain { _: LoDashStatic; read: () => this; /** * @description Be careful: This function overwrites the whole database. */ - write(returnValue?: T): T; + write(returnValue?: T): T & Promise; } - interface LowdbAsync extends LowdbBase, LoDashExplicitAsyncWrapper { + interface LowdbAsync extends LowdbBase, ObjectChain { _: LoDashStatic; read: () => Promise; /** * @description Be careful: This function overwrites the whole database. */ - write(returnValue?: T): Promise; + write(returnValue?: T): T & Promise; } interface LowdbFpSync extends LowdbBase { @@ -246,15 +264,6 @@ declare namespace Lowdb { (adapter: AdapterT): Promise>; (adapter: AdapterT): LowdbFpSync; } - - // Note: this interface is augmented in _lodash.d.ts - interface LoDashExplicitSyncWrapper extends _.LoDashWrapper { - write(): TValue; - } - // Note: this interface is augmented in _lodash.d.ts - interface LoDashExplicitAsyncWrapper extends _.LoDashWrapper { - write(): Promise; - } } type ReferenceProperty = "@@reference"; diff --git a/types/lowdb/lowdb-tests.ts b/types/lowdb/lowdb-tests.ts index 45662ce342..f47f1b627a 100644 --- a/types/lowdb/lowdb-tests.ts +++ b/types/lowdb/lowdb-tests.ts @@ -12,7 +12,7 @@ const db = low(adapterSync); const write: DbSchema = db.defaults({ posts: [] }).write(); -const result: Post[] = db +const result: ArrayLike = db .get("posts") .push({ title: "hello", views: 123 }) .value(); @@ -21,16 +21,16 @@ const result: Post[] = db db.get("posts") .find({ id: 123 }) .value(); -// $ExpectType Post | undefined +// $ExpectType Post & Promise db.get("posts") .find({ id: 123 }) .write(); low(adapterAsync).then(dbAsync => { - const writeAction: Promise = dbAsync + const writeAction: Promise = (dbAsync .get("posts") .push({ title: "async hello" }) - .last() + .last() as _.ObjectChain) .assign({ id: Date.now().toString() }) .write(); @@ -44,9 +44,9 @@ low(adapterAsync).then(dbAsync => { .find({}) .value(); - const tuple: Promise<[boolean, number] | undefined> = dbAsync + const tuple: ArrayLike & Promise> = (dbAsync .get("posts") - .first() + .first() as _.ObjectChain) .get("tuple") .write(); }); @@ -82,12 +82,12 @@ async () => { .defaults({ posts: [{ name: "baz" }] }) .write(); - const result: Promise = dbAsync + const result: ArrayLike<{ name: string }> & Promise> = dbAsync .get("posts") .push({ name: "hello" }) .write(); - const resultSync: ExampleSchema["posts"] = dbSync + const resultSync: ArrayLike<{ name: string }> & Promise> = dbSync .get("posts") .push({ name: "hello" }) .write(); @@ -105,10 +105,10 @@ async () => { .write(); }; -declare const lodashChain: _.LoDashExplicitWrapper; +declare const lodashChain: _.ObjectChain; // let's also ensure we didn't break lodash.chain through extension -const weDidNotBreakLodash: ExampleSchema["posts"] = lodashChain +const weDidNotBreakLodash: ArrayLike<{ name: string }> = lodashChain .get("posts") .sortBy("") .value();