mirror of
https://github.com/zhigang1992/DefinitelyTyped.git
synced 2026-05-21 08:33:26 +08:00
67ff021363
* lodash: _.get should with numeric keys, too. Also added some better tests. * lodash: add one more NumericDictionary overload for _.get * lodash: more reasonable index for _.get tests * Working on script to generate FP types (for #7896) * Generate generic args and multiple overloads correctly (ish) * Cap callback arguments * Fix ObjectIteratee issue, merge interfaces * Merge similar overloads * Read and write definiton files * Generate definitions for all functions (still needs some tweaking) * Add JSDoc comments to the output, fix some bugs * Fix more fp generation bugs * Add alias functions and special fp functions * Fix more fp generation bugs * Fix more fp generation bugs * Fix more fp generation bugs * lodash fp: cap more callbacks, use ReadonlyArray, handle special cases * Add some tests, fix some bugs * Remove invalid argument from flatten. Don't curry single argument functions. But do "convert" them so aliases work. Also fixed some tests. * lodash fp: implement more tests, fix more bugs, improve performance * lodash fp: implement more tests, fix more bugs * lodash fp: add more tests, fix more bugs * lodash fp: tests finally pass! * Remove namespace hack * lodash: fix tests * lodash fp: fix lint issues * lodash: Fix lint issues * lodash: fix more lint issues * lodash: make travis happy * lodash: make travis happy (again) * Update generate-fp script to work with new folder structure * Lodash: update fp types after merge * Lodash: test optimizations * lodash: simplify some tests to avoid GC error * lodash: simplify tests even more (and fix bugs)
791 lines
30 KiB
TypeScript
791 lines
30 KiB
TypeScript
// 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 run fp
|
|
|
|
import add = require("./fp/add");
|
|
import after = require("./fp/after");
|
|
import all = require("./fp/all");
|
|
import allPass = require("./fp/allPass");
|
|
import always = require("./fp/always");
|
|
import any = require("./fp/any");
|
|
import anyPass = require("./fp/anyPass");
|
|
import apply = require("./fp/apply");
|
|
import ary = require("./fp/ary");
|
|
import assign = require("./fp/assign");
|
|
import assignAll = require("./fp/assignAll");
|
|
import assignAllWith = require("./fp/assignAllWith");
|
|
import assignIn = require("./fp/assignIn");
|
|
import assignInAll = require("./fp/assignInAll");
|
|
import assignInAllWith = require("./fp/assignInAllWith");
|
|
import assignInWith = require("./fp/assignInWith");
|
|
import assignWith = require("./fp/assignWith");
|
|
import assoc = require("./fp/assoc");
|
|
import assocPath = require("./fp/assocPath");
|
|
import at = require("./fp/at");
|
|
import attempt = require("./fp/attempt");
|
|
import before = require("./fp/before");
|
|
import bind = require("./fp/bind");
|
|
import bindAll = require("./fp/bindAll");
|
|
import bindKey = require("./fp/bindKey");
|
|
import camelCase = require("./fp/camelCase");
|
|
import capitalize = require("./fp/capitalize");
|
|
import castArray = require("./fp/castArray");
|
|
import ceil = require("./fp/ceil");
|
|
import chunk = require("./fp/chunk");
|
|
import clamp = require("./fp/clamp");
|
|
import clone = require("./fp/clone");
|
|
import cloneDeep = require("./fp/cloneDeep");
|
|
import cloneDeepWith = require("./fp/cloneDeepWith");
|
|
import cloneWith = require("./fp/cloneWith");
|
|
import compact = require("./fp/compact");
|
|
import complement = require("./fp/complement");
|
|
import compose = require("./fp/compose");
|
|
import concat = require("./fp/concat");
|
|
import cond = require("./fp/cond");
|
|
import conforms = require("./fp/conforms");
|
|
import conformsTo = require("./fp/conformsTo");
|
|
import constant = require("./fp/constant");
|
|
import contains = require("./fp/contains");
|
|
import countBy = require("./fp/countBy");
|
|
import create = require("./fp/create");
|
|
import curry = require("./fp/curry");
|
|
import curryN = require("./fp/curryN");
|
|
import curryRight = require("./fp/curryRight");
|
|
import curryRightN = require("./fp/curryRightN");
|
|
import debounce = require("./fp/debounce");
|
|
import deburr = require("./fp/deburr");
|
|
import defaults = require("./fp/defaults");
|
|
import defaultsAll = require("./fp/defaultsAll");
|
|
import defaultsDeep = require("./fp/defaultsDeep");
|
|
import defaultsDeepAll = require("./fp/defaultsDeepAll");
|
|
import defaultTo = require("./fp/defaultTo");
|
|
import defer = require("./fp/defer");
|
|
import delay = require("./fp/delay");
|
|
import difference = require("./fp/difference");
|
|
import differenceBy = require("./fp/differenceBy");
|
|
import differenceWith = require("./fp/differenceWith");
|
|
import dissoc = require("./fp/dissoc");
|
|
import dissocPath = require("./fp/dissocPath");
|
|
import divide = require("./fp/divide");
|
|
import drop = require("./fp/drop");
|
|
import dropLast = require("./fp/dropLast");
|
|
import dropLastWhile = require("./fp/dropLastWhile");
|
|
import dropRight = require("./fp/dropRight");
|
|
import dropRightWhile = require("./fp/dropRightWhile");
|
|
import dropWhile = require("./fp/dropWhile");
|
|
import each = require("./fp/each");
|
|
import eachRight = require("./fp/eachRight");
|
|
import endsWith = require("./fp/endsWith");
|
|
import entries = require("./fp/entries");
|
|
import entriesIn = require("./fp/entriesIn");
|
|
import eq = require("./fp/eq");
|
|
import equals = require("./fp/equals");
|
|
import escape = require("./fp/escape");
|
|
import escapeRegExp = require("./fp/escapeRegExp");
|
|
import every = require("./fp/every");
|
|
import extend = require("./fp/extend");
|
|
import extendAll = require("./fp/extendAll");
|
|
import extendAllWith = require("./fp/extendAllWith");
|
|
import extendWith = require("./fp/extendWith");
|
|
import F = require("./fp/F");
|
|
import fill = require("./fp/fill");
|
|
import filter = require("./fp/filter");
|
|
import find = require("./fp/find");
|
|
import findFrom = require("./fp/findFrom");
|
|
import findIndex = require("./fp/findIndex");
|
|
import findIndexFrom = require("./fp/findIndexFrom");
|
|
import findKey = require("./fp/findKey");
|
|
import findLast = require("./fp/findLast");
|
|
import findLastFrom = require("./fp/findLastFrom");
|
|
import findLastIndex = require("./fp/findLastIndex");
|
|
import findLastIndexFrom = require("./fp/findLastIndexFrom");
|
|
import findLastKey = require("./fp/findLastKey");
|
|
import first = require("./fp/first");
|
|
import flatMap = require("./fp/flatMap");
|
|
import flatMapDeep = require("./fp/flatMapDeep");
|
|
import flatMapDepth = require("./fp/flatMapDepth");
|
|
import flatten = require("./fp/flatten");
|
|
import flattenDeep = require("./fp/flattenDeep");
|
|
import flattenDepth = require("./fp/flattenDepth");
|
|
import flip = require("./fp/flip");
|
|
import floor = require("./fp/floor");
|
|
import flow = require("./fp/flow");
|
|
import flowRight = require("./fp/flowRight");
|
|
import forEach = require("./fp/forEach");
|
|
import forEachRight = require("./fp/forEachRight");
|
|
import forIn = require("./fp/forIn");
|
|
import forInRight = require("./fp/forInRight");
|
|
import forOwn = require("./fp/forOwn");
|
|
import forOwnRight = require("./fp/forOwnRight");
|
|
import fromPairs = require("./fp/fromPairs");
|
|
import functions = require("./fp/functions");
|
|
import functionsIn = require("./fp/functionsIn");
|
|
import get = require("./fp/get");
|
|
import getOr = require("./fp/getOr");
|
|
import groupBy = require("./fp/groupBy");
|
|
import gt = require("./fp/gt");
|
|
import gte = require("./fp/gte");
|
|
import has = require("./fp/has");
|
|
import hasIn = require("./fp/hasIn");
|
|
import head = require("./fp/head");
|
|
import identical = require("./fp/identical");
|
|
import identity = require("./fp/identity");
|
|
import includes = require("./fp/includes");
|
|
import includesFrom = require("./fp/includesFrom");
|
|
import indexBy = require("./fp/indexBy");
|
|
import indexOf = require("./fp/indexOf");
|
|
import indexOfFrom = require("./fp/indexOfFrom");
|
|
import init = require("./fp/init");
|
|
import initial = require("./fp/initial");
|
|
import inRange = require("./fp/inRange");
|
|
import intersection = require("./fp/intersection");
|
|
import intersectionBy = require("./fp/intersectionBy");
|
|
import intersectionWith = require("./fp/intersectionWith");
|
|
import invert = require("./fp/invert");
|
|
import invertBy = require("./fp/invertBy");
|
|
import invertObj = require("./fp/invertObj");
|
|
import invoke = require("./fp/invoke");
|
|
import invokeArgs = require("./fp/invokeArgs");
|
|
import invokeArgsMap = require("./fp/invokeArgsMap");
|
|
import invokeMap = require("./fp/invokeMap");
|
|
import isArguments = require("./fp/isArguments");
|
|
import isArray = require("./fp/isArray");
|
|
import isArrayBuffer = require("./fp/isArrayBuffer");
|
|
import isArrayLike = require("./fp/isArrayLike");
|
|
import isArrayLikeObject = require("./fp/isArrayLikeObject");
|
|
import isBoolean = require("./fp/isBoolean");
|
|
import isBuffer = require("./fp/isBuffer");
|
|
import isDate = require("./fp/isDate");
|
|
import isElement = require("./fp/isElement");
|
|
import isEmpty = require("./fp/isEmpty");
|
|
import isEqual = require("./fp/isEqual");
|
|
import isEqualWith = require("./fp/isEqualWith");
|
|
import isError = require("./fp/isError");
|
|
import isFinite = require("./fp/isFinite");
|
|
import isFunction = require("./fp/isFunction");
|
|
import isInteger = require("./fp/isInteger");
|
|
import isLength = require("./fp/isLength");
|
|
import isMap = require("./fp/isMap");
|
|
import isMatch = require("./fp/isMatch");
|
|
import isMatchWith = require("./fp/isMatchWith");
|
|
import isNaN = require("./fp/isNaN");
|
|
import isNative = require("./fp/isNative");
|
|
import isNil = require("./fp/isNil");
|
|
import isNull = require("./fp/isNull");
|
|
import isNumber = require("./fp/isNumber");
|
|
import isObject = require("./fp/isObject");
|
|
import isObjectLike = require("./fp/isObjectLike");
|
|
import isPlainObject = require("./fp/isPlainObject");
|
|
import isRegExp = require("./fp/isRegExp");
|
|
import isSafeInteger = require("./fp/isSafeInteger");
|
|
import isSet = require("./fp/isSet");
|
|
import isString = require("./fp/isString");
|
|
import isSymbol = require("./fp/isSymbol");
|
|
import isTypedArray = require("./fp/isTypedArray");
|
|
import isUndefined = require("./fp/isUndefined");
|
|
import isWeakMap = require("./fp/isWeakMap");
|
|
import isWeakSet = require("./fp/isWeakSet");
|
|
import iteratee = require("./fp/iteratee");
|
|
import join = require("./fp/join");
|
|
import juxt = require("./fp/juxt");
|
|
import kebabCase = require("./fp/kebabCase");
|
|
import keyBy = require("./fp/keyBy");
|
|
import keys = require("./fp/keys");
|
|
import keysIn = require("./fp/keysIn");
|
|
import last = require("./fp/last");
|
|
import lastIndexOf = require("./fp/lastIndexOf");
|
|
import lastIndexOfFrom = require("./fp/lastIndexOfFrom");
|
|
import lowerCase = require("./fp/lowerCase");
|
|
import lowerFirst = require("./fp/lowerFirst");
|
|
import lt = require("./fp/lt");
|
|
import lte = require("./fp/lte");
|
|
import map = require("./fp/map");
|
|
import mapKeys = require("./fp/mapKeys");
|
|
import mapValues = require("./fp/mapValues");
|
|
import matches = require("./fp/matches");
|
|
import matchesProperty = require("./fp/matchesProperty");
|
|
import max = require("./fp/max");
|
|
import maxBy = require("./fp/maxBy");
|
|
import mean = require("./fp/mean");
|
|
import meanBy = require("./fp/meanBy");
|
|
import memoize = require("./fp/memoize");
|
|
import merge = require("./fp/merge");
|
|
import mergeAll = require("./fp/mergeAll");
|
|
import mergeAllWith = require("./fp/mergeAllWith");
|
|
import mergeWith = require("./fp/mergeWith");
|
|
import method = require("./fp/method");
|
|
import methodOf = require("./fp/methodOf");
|
|
import min = require("./fp/min");
|
|
import minBy = require("./fp/minBy");
|
|
import multiply = require("./fp/multiply");
|
|
import nAry = require("./fp/nAry");
|
|
import negate = require("./fp/negate");
|
|
import noConflict = require("./fp/noConflict");
|
|
import noop = require("./fp/noop");
|
|
import now = require("./fp/now");
|
|
import nth = require("./fp/nth");
|
|
import nthArg = require("./fp/nthArg");
|
|
import omit = require("./fp/omit");
|
|
import omitAll = require("./fp/omitAll");
|
|
import omitBy = require("./fp/omitBy");
|
|
import once = require("./fp/once");
|
|
import orderBy = require("./fp/orderBy");
|
|
import over = require("./fp/over");
|
|
import overArgs = require("./fp/overArgs");
|
|
import overEvery = require("./fp/overEvery");
|
|
import overSome = require("./fp/overSome");
|
|
import pad = require("./fp/pad");
|
|
import padChars = require("./fp/padChars");
|
|
import padCharsEnd = require("./fp/padCharsEnd");
|
|
import padCharsStart = require("./fp/padCharsStart");
|
|
import padEnd = require("./fp/padEnd");
|
|
import padStart = require("./fp/padStart");
|
|
import parseInt = require("./fp/parseInt");
|
|
import partial = require("./fp/partial");
|
|
import partialRight = require("./fp/partialRight");
|
|
import partition = require("./fp/partition");
|
|
import path = require("./fp/path");
|
|
import pathEq = require("./fp/pathEq");
|
|
import pathOr = require("./fp/pathOr");
|
|
import paths = require("./fp/paths");
|
|
import pick = require("./fp/pick");
|
|
import pickAll = require("./fp/pickAll");
|
|
import pickBy = require("./fp/pickBy");
|
|
import pipe = require("./fp/pipe");
|
|
import pluck = require("./fp/pluck");
|
|
import prop = require("./fp/prop");
|
|
import propEq = require("./fp/propEq");
|
|
import property = require("./fp/property");
|
|
import propertyOf = require("./fp/propertyOf");
|
|
import propOr = require("./fp/propOr");
|
|
import props = require("./fp/props");
|
|
import pull = require("./fp/pull");
|
|
import pullAll = require("./fp/pullAll");
|
|
import pullAllBy = require("./fp/pullAllBy");
|
|
import pullAllWith = require("./fp/pullAllWith");
|
|
import pullAt = require("./fp/pullAt");
|
|
import random = require("./fp/random");
|
|
import range = require("./fp/range");
|
|
import rangeRight = require("./fp/rangeRight");
|
|
import rangeStep = require("./fp/rangeStep");
|
|
import rangeStepRight = require("./fp/rangeStepRight");
|
|
import rearg = require("./fp/rearg");
|
|
import reduce = require("./fp/reduce");
|
|
import reduceRight = require("./fp/reduceRight");
|
|
import reject = require("./fp/reject");
|
|
import remove = require("./fp/remove");
|
|
import repeat = require("./fp/repeat");
|
|
import replace = require("./fp/replace");
|
|
import rest = require("./fp/rest");
|
|
import restFrom = require("./fp/restFrom");
|
|
import result = require("./fp/result");
|
|
import reverse = require("./fp/reverse");
|
|
import round = require("./fp/round");
|
|
import runInContext = require("./fp/runInContext");
|
|
import sample = require("./fp/sample");
|
|
import sampleSize = require("./fp/sampleSize");
|
|
import set = require("./fp/set");
|
|
import setWith = require("./fp/setWith");
|
|
import shuffle = require("./fp/shuffle");
|
|
import size = require("./fp/size");
|
|
import slice = require("./fp/slice");
|
|
import snakeCase = require("./fp/snakeCase");
|
|
import some = require("./fp/some");
|
|
import sortBy = require("./fp/sortBy");
|
|
import sortedIndex = require("./fp/sortedIndex");
|
|
import sortedIndexBy = require("./fp/sortedIndexBy");
|
|
import sortedIndexOf = require("./fp/sortedIndexOf");
|
|
import sortedLastIndex = require("./fp/sortedLastIndex");
|
|
import sortedLastIndexBy = require("./fp/sortedLastIndexBy");
|
|
import sortedLastIndexOf = require("./fp/sortedLastIndexOf");
|
|
import sortedUniq = require("./fp/sortedUniq");
|
|
import sortedUniqBy = require("./fp/sortedUniqBy");
|
|
import split = require("./fp/split");
|
|
import spread = require("./fp/spread");
|
|
import spreadFrom = require("./fp/spreadFrom");
|
|
import startCase = require("./fp/startCase");
|
|
import startsWith = require("./fp/startsWith");
|
|
import stubArray = require("./fp/stubArray");
|
|
import stubFalse = require("./fp/stubFalse");
|
|
import stubObject = require("./fp/stubObject");
|
|
import stubString = require("./fp/stubString");
|
|
import stubTrue = require("./fp/stubTrue");
|
|
import subtract = require("./fp/subtract");
|
|
import sum = require("./fp/sum");
|
|
import sumBy = require("./fp/sumBy");
|
|
import symmetricDifference = require("./fp/symmetricDifference");
|
|
import symmetricDifferenceBy = require("./fp/symmetricDifferenceBy");
|
|
import symmetricDifferenceWith = require("./fp/symmetricDifferenceWith");
|
|
import T = require("./fp/T");
|
|
import tail = require("./fp/tail");
|
|
import take = require("./fp/take");
|
|
import takeLast = require("./fp/takeLast");
|
|
import takeLastWhile = require("./fp/takeLastWhile");
|
|
import takeRight = require("./fp/takeRight");
|
|
import takeRightWhile = require("./fp/takeRightWhile");
|
|
import takeWhile = require("./fp/takeWhile");
|
|
import tap = require("./fp/tap");
|
|
import template = require("./fp/template");
|
|
import throttle = require("./fp/throttle");
|
|
import thru = require("./fp/thru");
|
|
import times = require("./fp/times");
|
|
import toArray = require("./fp/toArray");
|
|
import toFinite = require("./fp/toFinite");
|
|
import toInteger = require("./fp/toInteger");
|
|
import toLength = require("./fp/toLength");
|
|
import toLower = require("./fp/toLower");
|
|
import toNumber = require("./fp/toNumber");
|
|
import toPairs = require("./fp/toPairs");
|
|
import toPairsIn = require("./fp/toPairsIn");
|
|
import toPath = require("./fp/toPath");
|
|
import toPlainObject = require("./fp/toPlainObject");
|
|
import toSafeInteger = require("./fp/toSafeInteger");
|
|
import toString = require("./fp/toString");
|
|
import toUpper = require("./fp/toUpper");
|
|
import transform = require("./fp/transform");
|
|
import trim = require("./fp/trim");
|
|
import trimChars = require("./fp/trimChars");
|
|
import trimCharsEnd = require("./fp/trimCharsEnd");
|
|
import trimCharsStart = require("./fp/trimCharsStart");
|
|
import trimEnd = require("./fp/trimEnd");
|
|
import trimStart = require("./fp/trimStart");
|
|
import truncate = require("./fp/truncate");
|
|
import unapply = require("./fp/unapply");
|
|
import unary = require("./fp/unary");
|
|
import unescape = require("./fp/unescape");
|
|
import union = require("./fp/union");
|
|
import unionBy = require("./fp/unionBy");
|
|
import unionWith = require("./fp/unionWith");
|
|
import uniq = require("./fp/uniq");
|
|
import uniqBy = require("./fp/uniqBy");
|
|
import uniqueId = require("./fp/uniqueId");
|
|
import uniqWith = require("./fp/uniqWith");
|
|
import unnest = require("./fp/unnest");
|
|
import unset = require("./fp/unset");
|
|
import unzip = require("./fp/unzip");
|
|
import unzipWith = require("./fp/unzipWith");
|
|
import update = require("./fp/update");
|
|
import updateWith = require("./fp/updateWith");
|
|
import upperCase = require("./fp/upperCase");
|
|
import upperFirst = require("./fp/upperFirst");
|
|
import useWith = require("./fp/useWith");
|
|
import values = require("./fp/values");
|
|
import valuesIn = require("./fp/valuesIn");
|
|
import where = require("./fp/where");
|
|
import whereEq = require("./fp/whereEq");
|
|
import without = require("./fp/without");
|
|
import words = require("./fp/words");
|
|
import wrap = require("./fp/wrap");
|
|
import xor = require("./fp/xor");
|
|
import xorBy = require("./fp/xorBy");
|
|
import xorWith = require("./fp/xorWith");
|
|
import zip = require("./fp/zip");
|
|
import zipAll = require("./fp/zipAll");
|
|
import zipObj = require("./fp/zipObj");
|
|
import zipObject = require("./fp/zipObject");
|
|
import zipObjectDeep = require("./fp/zipObjectDeep");
|
|
import zipWith = require("./fp/zipWith");
|
|
|
|
export = _;
|
|
|
|
declare const _: _.LoDashFp;
|
|
declare namespace _ {
|
|
interface LoDashFp {
|
|
add: typeof add;
|
|
after: typeof after;
|
|
all: typeof all;
|
|
allPass: typeof allPass;
|
|
always: typeof always;
|
|
any: typeof any;
|
|
anyPass: typeof anyPass;
|
|
apply: typeof apply;
|
|
ary: typeof ary;
|
|
assign: typeof assign;
|
|
assignAll: typeof assignAll;
|
|
assignAllWith: typeof assignAllWith;
|
|
assignIn: typeof assignIn;
|
|
assignInAll: typeof assignInAll;
|
|
assignInAllWith: typeof assignInAllWith;
|
|
assignInWith: typeof assignInWith;
|
|
assignWith: typeof assignWith;
|
|
assoc: typeof assoc;
|
|
assocPath: typeof assocPath;
|
|
at: typeof at;
|
|
attempt: typeof attempt;
|
|
before: typeof before;
|
|
bind: typeof bind;
|
|
bindAll: typeof bindAll;
|
|
bindKey: typeof bindKey;
|
|
camelCase: typeof camelCase;
|
|
capitalize: typeof capitalize;
|
|
castArray: typeof castArray;
|
|
ceil: typeof ceil;
|
|
chunk: typeof chunk;
|
|
clamp: typeof clamp;
|
|
clone: typeof clone;
|
|
cloneDeep: typeof cloneDeep;
|
|
cloneDeepWith: typeof cloneDeepWith;
|
|
cloneWith: typeof cloneWith;
|
|
compact: typeof compact;
|
|
complement: typeof complement;
|
|
compose: typeof compose;
|
|
concat: typeof concat;
|
|
cond: typeof cond;
|
|
conforms: typeof conforms;
|
|
conformsTo: typeof conformsTo;
|
|
constant: typeof constant;
|
|
contains: typeof contains;
|
|
countBy: typeof countBy;
|
|
create: typeof create;
|
|
curry: typeof curry;
|
|
curryN: typeof curryN;
|
|
curryRight: typeof curryRight;
|
|
curryRightN: typeof curryRightN;
|
|
debounce: typeof debounce;
|
|
deburr: typeof deburr;
|
|
defaults: typeof defaults;
|
|
defaultsAll: typeof defaultsAll;
|
|
defaultsDeep: typeof defaultsDeep;
|
|
defaultsDeepAll: typeof defaultsDeepAll;
|
|
defaultTo: typeof defaultTo;
|
|
defer: typeof defer;
|
|
delay: typeof delay;
|
|
difference: typeof difference;
|
|
differenceBy: typeof differenceBy;
|
|
differenceWith: typeof differenceWith;
|
|
dissoc: typeof dissoc;
|
|
dissocPath: typeof dissocPath;
|
|
divide: typeof divide;
|
|
drop: typeof drop;
|
|
dropLast: typeof dropLast;
|
|
dropLastWhile: typeof dropLastWhile;
|
|
dropRight: typeof dropRight;
|
|
dropRightWhile: typeof dropRightWhile;
|
|
dropWhile: typeof dropWhile;
|
|
each: typeof each;
|
|
eachRight: typeof eachRight;
|
|
endsWith: typeof endsWith;
|
|
entries: typeof entries;
|
|
entriesIn: typeof entriesIn;
|
|
eq: typeof eq;
|
|
equals: typeof equals;
|
|
escape: typeof escape;
|
|
escapeRegExp: typeof escapeRegExp;
|
|
every: typeof every;
|
|
extend: typeof extend;
|
|
extendAll: typeof extendAll;
|
|
extendAllWith: typeof extendAllWith;
|
|
extendWith: typeof extendWith;
|
|
F: typeof F;
|
|
fill: typeof fill;
|
|
filter: typeof filter;
|
|
find: typeof find;
|
|
findFrom: typeof findFrom;
|
|
findIndex: typeof findIndex;
|
|
findIndexFrom: typeof findIndexFrom;
|
|
findKey: typeof findKey;
|
|
findLast: typeof findLast;
|
|
findLastFrom: typeof findLastFrom;
|
|
findLastIndex: typeof findLastIndex;
|
|
findLastIndexFrom: typeof findLastIndexFrom;
|
|
findLastKey: typeof findLastKey;
|
|
first: typeof first;
|
|
flatMap: typeof flatMap;
|
|
flatMapDeep: typeof flatMapDeep;
|
|
flatMapDepth: typeof flatMapDepth;
|
|
flatten: typeof flatten;
|
|
flattenDeep: typeof flattenDeep;
|
|
flattenDepth: typeof flattenDepth;
|
|
flip: typeof flip;
|
|
floor: typeof floor;
|
|
flow: typeof flow;
|
|
flowRight: typeof flowRight;
|
|
forEach: typeof forEach;
|
|
forEachRight: typeof forEachRight;
|
|
forIn: typeof forIn;
|
|
forInRight: typeof forInRight;
|
|
forOwn: typeof forOwn;
|
|
forOwnRight: typeof forOwnRight;
|
|
fromPairs: typeof fromPairs;
|
|
functions: typeof functions;
|
|
functionsIn: typeof functionsIn;
|
|
get: typeof get;
|
|
getOr: typeof getOr;
|
|
groupBy: typeof groupBy;
|
|
gt: typeof gt;
|
|
gte: typeof gte;
|
|
has: typeof has;
|
|
hasIn: typeof hasIn;
|
|
head: typeof head;
|
|
identical: typeof identical;
|
|
identity: typeof identity;
|
|
includes: typeof includes;
|
|
includesFrom: typeof includesFrom;
|
|
indexBy: typeof indexBy;
|
|
indexOf: typeof indexOf;
|
|
indexOfFrom: typeof indexOfFrom;
|
|
init: typeof init;
|
|
initial: typeof initial;
|
|
inRange: typeof inRange;
|
|
intersection: typeof intersection;
|
|
intersectionBy: typeof intersectionBy;
|
|
intersectionWith: typeof intersectionWith;
|
|
invert: typeof invert;
|
|
invertBy: typeof invertBy;
|
|
invertObj: typeof invertObj;
|
|
invoke: typeof invoke;
|
|
invokeArgs: typeof invokeArgs;
|
|
invokeArgsMap: typeof invokeArgsMap;
|
|
invokeMap: typeof invokeMap;
|
|
isArguments: typeof isArguments;
|
|
isArray: typeof isArray;
|
|
isArrayBuffer: typeof isArrayBuffer;
|
|
isArrayLike: typeof isArrayLike;
|
|
isArrayLikeObject: typeof isArrayLikeObject;
|
|
isBoolean: typeof isBoolean;
|
|
isBuffer: typeof isBuffer;
|
|
isDate: typeof isDate;
|
|
isElement: typeof isElement;
|
|
isEmpty: typeof isEmpty;
|
|
isEqual: typeof isEqual;
|
|
isEqualWith: typeof isEqualWith;
|
|
isError: typeof isError;
|
|
isFinite: typeof isFinite;
|
|
isFunction: typeof isFunction;
|
|
isInteger: typeof isInteger;
|
|
isLength: typeof isLength;
|
|
isMap: typeof isMap;
|
|
isMatch: typeof isMatch;
|
|
isMatchWith: typeof isMatchWith;
|
|
isNaN: typeof isNaN;
|
|
isNative: typeof isNative;
|
|
isNil: typeof isNil;
|
|
isNull: typeof isNull;
|
|
isNumber: typeof isNumber;
|
|
isObject: typeof isObject;
|
|
isObjectLike: typeof isObjectLike;
|
|
isPlainObject: typeof isPlainObject;
|
|
isRegExp: typeof isRegExp;
|
|
isSafeInteger: typeof isSafeInteger;
|
|
isSet: typeof isSet;
|
|
isString: typeof isString;
|
|
isSymbol: typeof isSymbol;
|
|
isTypedArray: typeof isTypedArray;
|
|
isUndefined: typeof isUndefined;
|
|
isWeakMap: typeof isWeakMap;
|
|
isWeakSet: typeof isWeakSet;
|
|
iteratee: typeof iteratee;
|
|
join: typeof join;
|
|
juxt: typeof juxt;
|
|
kebabCase: typeof kebabCase;
|
|
keyBy: typeof keyBy;
|
|
keys: typeof keys;
|
|
keysIn: typeof keysIn;
|
|
last: typeof last;
|
|
lastIndexOf: typeof lastIndexOf;
|
|
lastIndexOfFrom: typeof lastIndexOfFrom;
|
|
lowerCase: typeof lowerCase;
|
|
lowerFirst: typeof lowerFirst;
|
|
lt: typeof lt;
|
|
lte: typeof lte;
|
|
map: typeof map;
|
|
mapKeys: typeof mapKeys;
|
|
mapValues: typeof mapValues;
|
|
matches: typeof matches;
|
|
matchesProperty: typeof matchesProperty;
|
|
max: typeof max;
|
|
maxBy: typeof maxBy;
|
|
mean: typeof mean;
|
|
meanBy: typeof meanBy;
|
|
memoize: typeof memoize;
|
|
merge: typeof merge;
|
|
mergeAll: typeof mergeAll;
|
|
mergeAllWith: typeof mergeAllWith;
|
|
mergeWith: typeof mergeWith;
|
|
method: typeof method;
|
|
methodOf: typeof methodOf;
|
|
min: typeof min;
|
|
minBy: typeof minBy;
|
|
multiply: typeof multiply;
|
|
nAry: typeof nAry;
|
|
negate: typeof negate;
|
|
noConflict: typeof noConflict;
|
|
noop: typeof noop;
|
|
now: typeof now;
|
|
nth: typeof nth;
|
|
nthArg: typeof nthArg;
|
|
omit: typeof omit;
|
|
omitAll: typeof omitAll;
|
|
omitBy: typeof omitBy;
|
|
once: typeof once;
|
|
orderBy: typeof orderBy;
|
|
over: typeof over;
|
|
overArgs: typeof overArgs;
|
|
overEvery: typeof overEvery;
|
|
overSome: typeof overSome;
|
|
pad: typeof pad;
|
|
padChars: typeof padChars;
|
|
padCharsEnd: typeof padCharsEnd;
|
|
padCharsStart: typeof padCharsStart;
|
|
padEnd: typeof padEnd;
|
|
padStart: typeof padStart;
|
|
parseInt: typeof parseInt;
|
|
partial: typeof partial;
|
|
partialRight: typeof partialRight;
|
|
partition: typeof partition;
|
|
path: typeof path;
|
|
pathEq: typeof pathEq;
|
|
pathOr: typeof pathOr;
|
|
paths: typeof paths;
|
|
pick: typeof pick;
|
|
pickAll: typeof pickAll;
|
|
pickBy: typeof pickBy;
|
|
pipe: typeof pipe;
|
|
pluck: typeof pluck;
|
|
prop: typeof prop;
|
|
propEq: typeof propEq;
|
|
property: typeof property;
|
|
propertyOf: typeof propertyOf;
|
|
propOr: typeof propOr;
|
|
props: typeof props;
|
|
pull: typeof pull;
|
|
pullAll: typeof pullAll;
|
|
pullAllBy: typeof pullAllBy;
|
|
pullAllWith: typeof pullAllWith;
|
|
pullAt: typeof pullAt;
|
|
random: typeof random;
|
|
range: typeof range;
|
|
rangeRight: typeof rangeRight;
|
|
rangeStep: typeof rangeStep;
|
|
rangeStepRight: typeof rangeStepRight;
|
|
rearg: typeof rearg;
|
|
reduce: typeof reduce;
|
|
reduceRight: typeof reduceRight;
|
|
reject: typeof reject;
|
|
remove: typeof remove;
|
|
repeat: typeof repeat;
|
|
replace: typeof replace;
|
|
rest: typeof rest;
|
|
restFrom: typeof restFrom;
|
|
result: typeof result;
|
|
reverse: typeof reverse;
|
|
round: typeof round;
|
|
runInContext: typeof runInContext;
|
|
sample: typeof sample;
|
|
sampleSize: typeof sampleSize;
|
|
set: typeof set;
|
|
setWith: typeof setWith;
|
|
shuffle: typeof shuffle;
|
|
size: typeof size;
|
|
slice: typeof slice;
|
|
snakeCase: typeof snakeCase;
|
|
some: typeof some;
|
|
sortBy: typeof sortBy;
|
|
sortedIndex: typeof sortedIndex;
|
|
sortedIndexBy: typeof sortedIndexBy;
|
|
sortedIndexOf: typeof sortedIndexOf;
|
|
sortedLastIndex: typeof sortedLastIndex;
|
|
sortedLastIndexBy: typeof sortedLastIndexBy;
|
|
sortedLastIndexOf: typeof sortedLastIndexOf;
|
|
sortedUniq: typeof sortedUniq;
|
|
sortedUniqBy: typeof sortedUniqBy;
|
|
split: typeof split;
|
|
spread: typeof spread;
|
|
spreadFrom: typeof spreadFrom;
|
|
startCase: typeof startCase;
|
|
startsWith: typeof startsWith;
|
|
stubArray: typeof stubArray;
|
|
stubFalse: typeof stubFalse;
|
|
stubObject: typeof stubObject;
|
|
stubString: typeof stubString;
|
|
stubTrue: typeof stubTrue;
|
|
subtract: typeof subtract;
|
|
sum: typeof sum;
|
|
sumBy: typeof sumBy;
|
|
symmetricDifference: typeof symmetricDifference;
|
|
symmetricDifferenceBy: typeof symmetricDifferenceBy;
|
|
symmetricDifferenceWith: typeof symmetricDifferenceWith;
|
|
T: typeof T;
|
|
tail: typeof tail;
|
|
take: typeof take;
|
|
takeLast: typeof takeLast;
|
|
takeLastWhile: typeof takeLastWhile;
|
|
takeRight: typeof takeRight;
|
|
takeRightWhile: typeof takeRightWhile;
|
|
takeWhile: typeof takeWhile;
|
|
tap: typeof tap;
|
|
template: typeof template;
|
|
throttle: typeof throttle;
|
|
thru: typeof thru;
|
|
times: typeof times;
|
|
toArray: typeof toArray;
|
|
toFinite: typeof toFinite;
|
|
toInteger: typeof toInteger;
|
|
toLength: typeof toLength;
|
|
toLower: typeof toLower;
|
|
toNumber: typeof toNumber;
|
|
toPairs: typeof toPairs;
|
|
toPairsIn: typeof toPairsIn;
|
|
toPath: typeof toPath;
|
|
toPlainObject: typeof toPlainObject;
|
|
toSafeInteger: typeof toSafeInteger;
|
|
toString: typeof toString;
|
|
toUpper: typeof toUpper;
|
|
transform: typeof transform;
|
|
trim: typeof trim;
|
|
trimChars: typeof trimChars;
|
|
trimCharsEnd: typeof trimCharsEnd;
|
|
trimCharsStart: typeof trimCharsStart;
|
|
trimEnd: typeof trimEnd;
|
|
trimStart: typeof trimStart;
|
|
truncate: typeof truncate;
|
|
unapply: typeof unapply;
|
|
unary: typeof unary;
|
|
unescape: typeof unescape;
|
|
union: typeof union;
|
|
unionBy: typeof unionBy;
|
|
unionWith: typeof unionWith;
|
|
uniq: typeof uniq;
|
|
uniqBy: typeof uniqBy;
|
|
uniqueId: typeof uniqueId;
|
|
uniqWith: typeof uniqWith;
|
|
unnest: typeof unnest;
|
|
unset: typeof unset;
|
|
unzip: typeof unzip;
|
|
unzipWith: typeof unzipWith;
|
|
update: typeof update;
|
|
updateWith: typeof updateWith;
|
|
upperCase: typeof upperCase;
|
|
upperFirst: typeof upperFirst;
|
|
useWith: typeof useWith;
|
|
values: typeof values;
|
|
valuesIn: typeof valuesIn;
|
|
where: typeof where;
|
|
whereEq: typeof whereEq;
|
|
without: typeof without;
|
|
words: typeof words;
|
|
wrap: typeof wrap;
|
|
xor: typeof xor;
|
|
xorBy: typeof xorBy;
|
|
xorWith: typeof xorWith;
|
|
zip: typeof zip;
|
|
zipAll: typeof zipAll;
|
|
zipObj: typeof zipObj;
|
|
zipObject: typeof zipObject;
|
|
zipObjectDeep: typeof zipObjectDeep;
|
|
zipWith: typeof zipWith;
|
|
}
|
|
}
|
|
|
|
// Backward compatibility with --target es5
|
|
declare global {
|
|
// tslint:disable-next-line:no-empty-interface
|
|
interface Set<T> { }
|
|
// tslint:disable-next-line:no-empty-interface
|
|
interface Map<K, V> { }
|
|
// tslint:disable-next-line:no-empty-interface
|
|
interface WeakSet<T> { }
|
|
// tslint:disable-next-line:no-empty-interface
|
|
interface WeakMap<K extends object, V> { }
|
|
}
|