// 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> { }
}
