code:
import { F } from "../fp";
export = F;

license: mit


code:
import { T } from "../fp";
export = T;


code:
import _ = require("../index");
declare const __: _.__;
export = __;


code:
import { add } from "../fp";
export = add;


code:
import { after } from "../fp";
export = after;


code:
import { all } from "../fp";
export = all;


code:
import { allPass } from "../fp";
export = allPass;


code:
import { always } from "../fp";
export = always;


code:
import { any } from "../fp";
export = any;


code:
import { anyPass } from "../fp";
export = anyPass;


code:
import { apply } from "../fp";
export = apply;


code:
import { ary } from "../fp";
export = ary;


code:
import { assign } from "../fp";
export = assign;


code:
import { assignAll } from "../fp";
export = assignAll;


code:
import { assignAllWith } from "../fp";
export = assignAllWith;


code:
import { assignIn } from "../fp";
export = assignIn;


code:
import { assignInAll } from "../fp";
export = assignInAll;


code:
import { assignInAllWith } from "../fp";
export = assignInAllWith;


code:
import { assignInWith } from "../fp";
export = assignInWith;


code:
import { assignWith } from "../fp";
export = assignWith;


code:
import { assoc } from "../fp";
export = assoc;


code:
import { assocPath } from "../fp";
export = assocPath;


code:
import { at } from "../fp";
export = at;


code:
import { attempt } from "../fp";
export = attempt;


code:
import { before } from "../fp";
export = before;


code:
import { bind } from "../fp";
export = bind;


code:
import { bindAll } from "../fp";
export = bindAll;


code:
import { bindKey } from "../fp";
export = bindKey;


code:
import { camelCase } from "../fp";
export = camelCase;


code:
import { capitalize } from "../fp";
export = capitalize;


code:
import { castArray } from "../fp";
export = castArray;


code:
import { ceil } from "../fp";
export = ceil;


code:
import { chunk } from "../fp";
export = chunk;


code:
import { clamp } from "../fp";
export = clamp;


code:
import { clone } from "../fp";
export = clone;


code:
import { cloneDeep } from "../fp";
export = cloneDeep;


code:
import { cloneDeepWith } from "../fp";
export = cloneDeepWith;


code:
import { cloneWith } from "../fp";
export = cloneWith;


code:
import { compact } from "../fp";
export = compact;


code:
import { complement } from "../fp";
export = complement;


code:
import { compose } from "../fp";
export = compose;


code:
import { concat } from "../fp";
export = concat;


code:
import { cond } from "../fp";
export = cond;


code:
import { conforms } from "../fp";
export = conforms;


code:
import { conformsTo } from "../fp";
export = conformsTo;


code:
import { constant } from "../fp";
export = constant;


code:
import { contains } from "../fp";
export = contains;


code:
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;


code:
import { countBy } from "../fp";
export = countBy;


code:
import { create } from "../fp";
export = create;


code:
import { curry } from "../fp";
export = curry;


code:
import { curryN } from "../fp";
export = curryN;


code:
import { curryRight } from "../fp";
export = curryRight;


code:
import { curryRightN } from "../fp";
export = curryRightN;


code:
import { debounce } from "../fp";
export = debounce;


code:
import { deburr } from "../fp";
export = deburr;


code:
import { defaultTo } from "../fp";
export = defaultTo;


code:
import { defaults } from "../fp";
export = defaults;


code:
import { defaultsAll } from "../fp";
export = defaultsAll;


code:
import { defaultsDeep } from "../fp";
export = defaultsDeep;


code:
import { defaultsDeepAll } from "../fp";
export = defaultsDeepAll;


code:
import { defer } from "../fp";
export = defer;


code:
import { delay } from "../fp";
export = delay;


code:
import { difference } from "../fp";
export = difference;


code:
import { differenceBy } from "../fp";
export = differenceBy;


code:
import { differenceWith } from "../fp";
export = differenceWith;


code:
import { dissoc } from "../fp";
export = dissoc;


code:
import { dissocPath } from "../fp";
export = dissocPath;


code:
import { divide } from "../fp";
export = divide;


code:
import { drop } from "../fp";
export = drop;


code:
import { dropLast } from "../fp";
export = dropLast;


code:
import { dropLastWhile } from "../fp";
export = dropLastWhile;


code:
import { dropRight } from "../fp";
export = dropRight;


code:
import { dropRightWhile } from "../fp";
export = dropRightWhile;


code:
import { dropWhile } from "../fp";
export = dropWhile;


code:
import { each } from "../fp";
export = each;


code:
import { eachRight } from "../fp";
export = eachRight;


code:
import { endsWith } from "../fp";
export = endsWith;


code:
import { entries } from "../fp";
export = entries;


code:
import { entriesIn } from "../fp";
export = entriesIn;


code:
import { eq } from "../fp";
export = eq;


code:
import { equals } from "../fp";
export = equals;


code:
import { escape } from "../fp";
export = escape;


code:
import { escapeRegExp } from "../fp";
export = escapeRegExp;


code:
import { every } from "../fp";
export = every;


code:
import { extend } from "../fp";
export = extend;


code:
import { extendAll } from "../fp";
export = extendAll;


code:
import { extendAllWith } from "../fp";
export = extendAllWith;


code:
import { extendWith } from "../fp";
export = extendWith;


code:
import { fill } from "../fp";
export = fill;


code:
import { filter } from "../fp";
export = filter;


code:
import { find } from "../fp";
export = find;


code:
import { findFrom } from "../fp";
export = findFrom;


code:
import { findIndex } from "../fp";
export = findIndex;


code:
import { findIndexFrom } from "../fp";
export = findIndexFrom;


code:
import { findKey } from "../fp";
export = findKey;


code:
import { findLast } from "../fp";
export = findLast;


code:
import { findLastFrom } from "../fp";
export = findLastFrom;


code:
import { findLastIndex } from "../fp";
export = findLastIndex;


code:
import { findLastIndexFrom } from "../fp";
export = findLastIndexFrom;


code:
import { findLastKey } from "../fp";
export = findLastKey;


code:
import { first } from "../fp";
export = first;


code:
import { flatMap } from "../fp";
export = flatMap;


code:
import { flatMapDeep } from "../fp";
export = flatMapDeep;


code:
import { flatMapDepth } from "../fp";
export = flatMapDepth;


code:
import { flatten } from "../fp";
export = flatten;


code:
import { flattenDeep } from "../fp";
export = flattenDeep;


code:
import { flattenDepth } from "../fp";
export = flattenDepth;


code:
import { flip } from "../fp";
export = flip;


code:
import { floor } from "../fp";
export = floor;


code:
import { flow } from "../fp";
export = flow;


code:
import { flowRight } from "../fp";
export = flowRight;


code:
import { forEach } from "../fp";
export = forEach;


code:
import { forEachRight } from "../fp";
export = forEachRight;


code:
import { forIn } from "../fp";
export = forIn;


code:
import { forInRight } from "../fp";
export = forInRight;


code:
import { forOwn } from "../fp";
export = forOwn;


code:
import { forOwnRight } from "../fp";
export = forOwnRight;


code:
import { fromPairs } from "../fp";
export = fromPairs;


code:
import { functions } from "../fp";
export = functions;


code:
import { functionsIn } from "../fp";
export = functionsIn;


code:
import { get } from "../fp";
export = get;


code:
import { getOr } from "../fp";
export = getOr;


code:
import { groupBy } from "../fp";
export = groupBy;


code:
import { gt } from "../fp";
export = gt;


code:
import { gte } from "../fp";
export = gte;


code:
import { has } from "../fp";
export = has;


code:
import { hasIn } from "../fp";
export = hasIn;


code:
import { head } from "../fp";
export = head;


code:
import { identical } from "../fp";
export = identical;


code:
import { identity } from "../fp";
export = identity;


code:
import { inRange } from "../fp";
export = inRange;


code:
import { includes } from "../fp";
export = includes;


code:
import { includesFrom } from "../fp";
export = includesFrom;


code:
import { indexBy } from "../fp";
export = indexBy;


code:
import { indexOf } from "../fp";
export = indexOf;


code:
import { indexOfFrom } from "../fp";
export = indexOfFrom;


code:
import { init } from "../fp";
export = init;


code:
import { initial } from "../fp";
export = initial;


code:
import { intersection } from "../fp";
export = intersection;


code:
import { intersectionBy } from "../fp";
export = intersectionBy;


code:
import { intersectionWith } from "../fp";
export = intersectionWith;


code:
import { invert } from "../fp";
export = invert;


code:
import { invertBy } from "../fp";
export = invertBy;


code:
import { invertObj } from "../fp";
export = invertObj;


code:
import { invoke } from "../fp";
export = invoke;


code:
import { invokeArgs } from "../fp";
export = invokeArgs;


code:
import { invokeArgsMap } from "../fp";
export = invokeArgsMap;


code:
import { invokeMap } from "../fp";
export = invokeMap;


code:
import { isArguments } from "../fp";
export = isArguments;


code:
import { isArray } from "../fp";
export = isArray;


code:
import { isArrayBuffer } from "../fp";
export = isArrayBuffer;


code:
import { isArrayLike } from "../fp";
export = isArrayLike;


code:
import { isArrayLikeObject } from "../fp";
export = isArrayLikeObject;


code:
import { isBoolean } from "../fp";
export = isBoolean;


code:
import { isBuffer } from "../fp";
export = isBuffer;


code:
import { isDate } from "../fp";
export = isDate;


code:
import { isElement } from "../fp";
export = isElement;


code:
import { isEmpty } from "../fp";
export = isEmpty;


code:
import { isEqual } from "../fp";
export = isEqual;


code:
import { isEqualWith } from "../fp";
export = isEqualWith;


code:
import { isError } from "../fp";
export = isError;


code:
import { isFinite } from "../fp";
export = isFinite;


code:
import { isFunction } from "../fp";
export = isFunction;


code:
import { isInteger } from "../fp";
export = isInteger;


code:
import { isLength } from "../fp";
export = isLength;


code:
import { isMap } from "../fp";
export = isMap;


code:
import { isMatch } from "../fp";
export = isMatch;


code:
import { isMatchWith } from "../fp";
export = isMatchWith;


code:
import { isNaN } from "../fp";
export = isNaN;


code:
import { isNative } from "../fp";
export = isNative;


code:
import { isNil } from "../fp";
export = isNil;


code:
import { isNull } from "../fp";
export = isNull;


code:
import { isNumber } from "../fp";
export = isNumber;


code:
import { isObject } from "../fp";
export = isObject;


code:
import { isObjectLike } from "../fp";
export = isObjectLike;


code:
import { isPlainObject } from "../fp";
export = isPlainObject;


code:
import { isRegExp } from "../fp";
export = isRegExp;


code:
import { isSafeInteger } from "../fp";
export = isSafeInteger;


code:
import { isSet } from "../fp";
export = isSet;


code:
import { isString } from "../fp";
export = isString;


code:
import { isSymbol } from "../fp";
export = isSymbol;


code:
import { isTypedArray } from "../fp";
export = isTypedArray;


code:
import { isUndefined } from "../fp";
export = isUndefined;


code:
import { isWeakMap } from "../fp";
export = isWeakMap;


code:
import { isWeakSet } from "../fp";
export = isWeakSet;


code:
import { iteratee } from "../fp";
export = iteratee;


code:
import { join } from "../fp";
export = join;


code:
import { juxt } from "../fp";
export = juxt;


code:
import { kebabCase } from "../fp";
export = kebabCase;


code:
import { keyBy } from "../fp";
export = keyBy;


code:
import { keys } from "../fp";
export = keys;


code:
import { keysIn } from "../fp";
export = keysIn;


code:
import { last } from "../fp";
export = last;


code:
import { lastIndexOf } from "../fp";
export = lastIndexOf;


code:
import { lastIndexOfFrom } from "../fp";
export = lastIndexOfFrom;


code:
import { lowerCase } from "../fp";
export = lowerCase;


code:
import { lowerFirst } from "../fp";
export = lowerFirst;


code:
import { lt } from "../fp";
export = lt;


code:
import { lte } from "../fp";
export = lte;


code:
import { map } from "../fp";
export = map;


code:
import { mapKeys } from "../fp";
export = mapKeys;


code:
import { mapValues } from "../fp";
export = mapValues;


code:
import { matches } from "../fp";
export = matches;


code:
import { matchesProperty } from "../fp";
export = matchesProperty;


code:
import { max } from "../fp";
export = max;


code:
import { maxBy } from "../fp";
export = maxBy;


code:
import { mean } from "../fp";
export = mean;


code:
import { meanBy } from "../fp";
export = meanBy;


code:
import { memoize } from "../fp";
export = memoize;


code:
import { merge } from "../fp";
export = merge;


code:
import { mergeAll } from "../fp";
export = mergeAll;


code:
import { mergeAllWith } from "../fp";
export = mergeAllWith;


code:
import { mergeWith } from "../fp";
export = mergeWith;


code:
import { method } from "../fp";
export = method;


code:
import { methodOf } from "../fp";
export = methodOf;


code:
import { min } from "../fp";
export = min;


code:
import { minBy } from "../fp";
export = minBy;


code:
import { multiply } from "../fp";
export = multiply;


code:
import { nAry } from "../fp";
export = nAry;


code:
import { negate } from "../fp";
export = negate;


code:
import { noConflict } from "../fp";
export = noConflict;


code:
import { noop } from "../fp";
export = noop;


code:
import { now } from "../fp";
export = now;


code:
import { nth } from "../fp";
export = nth;


code:
import { nthArg } from "../fp";
export = nthArg;


code:
import { omit } from "../fp";
export = omit;


code:
import { omitAll } from "../fp";
export = omitAll;


code:
import { omitBy } from "../fp";
export = omitBy;


code:
import { once } from "../fp";
export = once;


code:
import { orderBy } from "../fp";
export = orderBy;


code:
import { over } from "../fp";
export = over;


code:
import { overArgs } from "../fp";
export = overArgs;


code:
import { overEvery } from "../fp";
export = overEvery;


code:
import { overSome } from "../fp";
export = overSome;


code:
import { pad } from "../fp";
export = pad;


code:
import { padChars } from "../fp";
export = padChars;


code:
import { padCharsEnd } from "../fp";
export = padCharsEnd;


code:
import { padCharsStart } from "../fp";
export = padCharsStart;


code:
import { padEnd } from "../fp";
export = padEnd;


code:
import { padStart } from "../fp";
export = padStart;


code:
import { parseInt } from "../fp";
export = parseInt;


code:
import { partial } from "../fp";
export = partial;


code:
import { partialRight } from "../fp";
export = partialRight;


code:
import { partition } from "../fp";
export = partition;


code:
import { path } from "../fp";
export = path;


code:
import { pathEq } from "../fp";
export = pathEq;


code:
import { pathOr } from "../fp";
export = pathOr;


code:
import { paths } from "../fp";
export = paths;


code:
import { pick } from "../fp";
export = pick;


code:
import { pickAll } from "../fp";
export = pickAll;


code:
import { pickBy } from "../fp";
export = pickBy;


code:
import { pipe } from "../fp";
export = pipe;


code:
import _ = require("../index");
declare const placeholder: _.__;
export = placeholder;


code:
import { pluck } from "../fp";
export = pluck;


code:
import { prop } from "../fp";
export = prop;


code:
import { propEq } from "../fp";
export = propEq;


code:
import { propOr } from "../fp";
export = propOr;


code:
import { property } from "../fp";
export = property;


code:
import { propertyOf } from "../fp";
export = propertyOf;


code:
import { props } from "../fp";
export = props;


code:
import { pull } from "../fp";
export = pull;


code:
import { pullAll } from "../fp";
export = pullAll;


code:
import { pullAllBy } from "../fp";
export = pullAllBy;


code:
import { pullAllWith } from "../fp";
export = pullAllWith;


code:
import { pullAt } from "../fp";
export = pullAt;


code:
import { random } from "../fp";
export = random;


code:
import { range } from "../fp";
export = range;


code:
import { rangeRight } from "../fp";
export = rangeRight;


code:
import { rangeStep } from "../fp";
export = rangeStep;


code:
import { rangeStepRight } from "../fp";
export = rangeStepRight;


code:
import { rearg } from "../fp";
export = rearg;


code:
import { reduce } from "../fp";
export = reduce;


code:
import { reduceRight } from "../fp";
export = reduceRight;


code:
import { reject } from "../fp";
export = reject;


code:
import { remove } from "../fp";
export = remove;


code:
import { repeat } from "../fp";
export = repeat;


code:
import { replace } from "../fp";
export = replace;


code:
import { rest } from "../fp";
export = rest;


code:
import { restFrom } from "../fp";
export = restFrom;


code:
import { result } from "../fp";
export = result;


code:
import { reverse } from "../fp";
export = reverse;


code:
import { round } from "../fp";
export = round;


code:
import { runInContext } from "../fp";
export = runInContext;


code:
import { sample } from "../fp";
export = sample;


code:
import { sampleSize } from "../fp";
export = sampleSize;


code:
import { set } from "../fp";
export = set;


code:
import { setWith } from "../fp";
export = setWith;


code:
import { shuffle } from "../fp";
export = shuffle;


code:
import { size } from "../fp";
export = size;


code:
import { slice } from "../fp";
export = slice;


code:
import { snakeCase } from "../fp";
export = snakeCase;


code:
import { some } from "../fp";
export = some;


code:
import { sortBy } from "../fp";
export = sortBy;


code:
import { sortedIndex } from "../fp";
export = sortedIndex;


code:
import { sortedIndexBy } from "../fp";
export = sortedIndexBy;


code:
import { sortedIndexOf } from "../fp";
export = sortedIndexOf;


code:
import { sortedLastIndex } from "../fp";
export = sortedLastIndex;


code:
import { sortedLastIndexBy } from "../fp";
export = sortedLastIndexBy;


code:
import { sortedLastIndexOf } from "../fp";
export = sortedLastIndexOf;


code:
import { sortedUniq } from "../fp";
export = sortedUniq;


code:
import { sortedUniqBy } from "../fp";
export = sortedUniqBy;


code:
import { split } from "../fp";
export = split;


code:
import { spread } from "../fp";
export = spread;


code:
import { spreadFrom } from "../fp";
export = spreadFrom;


code:
import { startCase } from "../fp";
export = startCase;


code:
import { startsWith } from "../fp";
export = startsWith;


code:
import { stubArray } from "../fp";
export = stubArray;


code:
import { stubFalse } from "../fp";
export = stubFalse;


code:
import { stubObject } from "../fp";
export = stubObject;


code:
import { stubString } from "../fp";
export = stubString;


code:
import { stubTrue } from "../fp";
export = stubTrue;


code:
import { subtract } from "../fp";
export = subtract;


code:
import { sum } from "../fp";
export = sum;


code:
import { sumBy } from "../fp";
export = sumBy;


code:
import { symmetricDifference } from "../fp";
export = symmetricDifference;


code:
import { symmetricDifferenceBy } from "../fp";
export = symmetricDifferenceBy;


code:
import { symmetricDifferenceWith } from "../fp";
export = symmetricDifferenceWith;


code:
import { tail } from "../fp";
export = tail;


code:
import { take } from "../fp";
export = take;


code:
import { takeLast } from "../fp";
export = takeLast;


code:
import { takeLastWhile } from "../fp";
export = takeLastWhile;


code:
import { takeRight } from "../fp";
export = takeRight;


code:
import { takeRightWhile } from "../fp";
export = takeRightWhile;


code:
import { takeWhile } from "../fp";
export = takeWhile;


code:
import { tap } from "../fp";
export = tap;


code:
import { template } from "../fp";
export = template;


code:
import { throttle } from "../fp";
export = throttle;


code:
import { thru } from "../fp";
export = thru;


code:
import { times } from "../fp";
export = times;


code:
import { toArray } from "../fp";
export = toArray;


code:
import { toFinite } from "../fp";
export = toFinite;


code:
import { toInteger } from "../fp";
export = toInteger;


code:
import { toLength } from "../fp";
export = toLength;


code:
import { toLower } from "../fp";
export = toLower;


code:
import { toNumber } from "../fp";
export = toNumber;


code:
import { toPairs } from "../fp";
export = toPairs;


code:
import { toPairsIn } from "../fp";
export = toPairsIn;


code:
import { toPath } from "../fp";
export = toPath;


code:
import { toPlainObject } from "../fp";
export = toPlainObject;


code:
import { toSafeInteger } from "../fp";
export = toSafeInteger;


code:
import { toString } from "../fp";
export = toString;


code:
import { toUpper } from "../fp";
export = toUpper;


code:
import { transform } from "../fp";
export = transform;


code:
import { trim } from "../fp";
export = trim;


code:
import { trimChars } from "../fp";
export = trimChars;


code:
import { trimCharsEnd } from "../fp";
export = trimCharsEnd;


code:
import { trimCharsStart } from "../fp";
export = trimCharsStart;


code:
import { trimEnd } from "../fp";
export = trimEnd;


code:
import { trimStart } from "../fp";
export = trimStart;


code:
import { truncate } from "../fp";
export = truncate;


code:
import { unapply } from "../fp";
export = unapply;


code:
import { unary } from "../fp";
export = unary;


code:
import { unescape } from "../fp";
export = unescape;


code:
import { union } from "../fp";
export = union;


code:
import { unionBy } from "../fp";
export = unionBy;


code:
import { unionWith } from "../fp";
export = unionWith;


code:
import { uniq } from "../fp";
export = uniq;


code:
import { uniqBy } from "../fp";
export = uniqBy;


code:
import { uniqWith } from "../fp";
export = uniqWith;


code:
import { uniqueId } from "../fp";
export = uniqueId;


code:
import { unnest } from "../fp";
export = unnest;


code:
import { unset } from "../fp";
export = unset;


code:
import { unzip } from "../fp";
export = unzip;


code:
import { unzipWith } from "../fp";
export = unzipWith;


code:
import { update } from "../fp";
export = update;


code:
import { updateWith } from "../fp";
export = updateWith;


code:
import { upperCase } from "../fp";
export = upperCase;


code:
import { upperFirst } from "../fp";
export = upperFirst;


code:
import { useWith } from "../fp";
export = useWith;


code:
import { values } from "../fp";
export = values;


code:
import { valuesIn } from "../fp";
export = valuesIn;


code:
import { where } from "../fp";
export = where;


code:
import { whereEq } from "../fp";
export = whereEq;


code:
import { without } from "../fp";
export = without;


code:
import { words } from "../fp";
export = words;


code:
import { wrap } from "../fp";
export = wrap;


code:
import { xor } from "../fp";
export = xor;


code:
import { xorBy } from "../fp";
export = xorBy;


code:
import { xorWith } from "../fp";
export = xorWith;


code:
import { zip } from "../fp";
export = zip;


code:
import { zipAll } from "../fp";
export = zipAll;


code:
import { zipObj } from "../fp";
export = zipObj;


code:
import { zipObject } from "../fp";
export = zipObject;


code:
import { zipObjectDeep } from "../fp";
export = zipObjectDeep;


code:
import { zipWith } from "../fp";
export = zipWith;


code:
import { fromPairs } from "./index";
export = fromPairs;


code:
import { functions } from "./index";
export = functions;


code:
import { functionsIn } from "./index";
export = functionsIn;


code:
import { get } from "./index";
export = get;


code:
import { groupBy } from "./index";
export = groupBy;


code:
import { gt } from "./index";
export = gt;


code:
import { gte } from "./index";
export = gte;


code:
import { has } from "./index";
export = has;


code:
import { hasIn } from "./index";
export = hasIn;


code:
import { head } from "./index";
export = head;


code:
import { identity } from "./index";
export = identity;


code:
import { inRange } from "./index";
export = inRange;


code:
import { includes } from "./index";
export = includes;


code:
/// <reference path="./common/common.d.ts" />
/// <reference path="./common/array.d.ts" />
/// <reference path="./common/collection.d.ts" />
/// <reference path="./common/date.d.ts" />
/// <reference path="./common/function.d.ts" />
/// <reference path="./common/lang.d.ts" />
/// <reference path="./common/math.d.ts" />
/// <reference path="./common/number.d.ts" />
/// <reference path="./common/object.d.ts" />
/// <reference path="./common/seq.d.ts" />
/// <reference path="./common/string.d.ts" />
/// <reference path="./common/util.d.ts" />

export = _;
export as namespace _;

declare const _: _.LoDashStatic;
declare namespace _ {
    // eslint-disable-next-line @typescript-eslint/no-empty-interface -- (This will be augmented)
    interface LoDashStatic {}
}


code:
import { indexOf } from "./index";
export = indexOf;


code:
import { initial } from "./index";
export = initial;


code:
import { intersection } from "./index";
export = intersection;


code:
import { intersectionBy } from "./index";
export = intersectionBy;


code:
import { intersectionWith } from "./index";
export = intersectionWith;


code:
import { invert } from "./index";
export = invert;


code:
import { invertBy } from "./index";
export = invertBy;


code:
import { invoke } from "./index";
export = invoke;


code:
import { invokeMap } from "./index";
export = invokeMap;


code:
import { isArguments } from "./index";
export = isArguments;


code:
import { isArray } from "./index";
export = isArray;


code:
import { isArrayBuffer } from "./index";
export = isArrayBuffer;


code:
import { isArrayLike } from "./index";
export = isArrayLike;


code:
import { isArrayLikeObject } from "./index";
export = isArrayLikeObject;


code:
import { isBoolean } from "./index";
export = isBoolean;


code:
import { isBuffer } from "./index";
export = isBuffer;


code:
import { isDate } from "./index";
export = isDate;


code:
import { isElement } from "./index";
export = isElement;


code:
import { isEmpty } from "./index";
export = isEmpty;


code:
import { isEqual } from "./index";
export = isEqual;


code:
import { isEqualWith } from "./index";
export = isEqualWith;


code:
import { isError } from "./index";
export = isError;


code:
import { isFinite } from "./index";
export = isFinite;


code:
import { isFunction } from "./index";
export = isFunction;


code:
import { isInteger } from "./index";
export = isInteger;


code:
import { isLength } from "./index";
export = isLength;


code:
import { isMap } from "./index";
export = isMap;


code:
import { isMatch } from "./index";
export = isMatch;


code:
import { isMatchWith } from "./index";
export = isMatchWith;


code:
import { isNaN } from "./index";
export = isNaN;


code:
import { isNative } from "./index";
export = isNative;


code:
import { isNil } from "./index";
export = isNil;


code:
import { isNull } from "./index";
export = isNull;


code:
import { isNumber } from "./index";
export = isNumber;


code:
import { isObject } from "./index";
export = isObject;


code:
import { isObjectLike } from "./index";
export = isObjectLike;


code:
import { isPlainObject } from "./index";
export = isPlainObject;


code:
import { isRegExp } from "./index";
export = isRegExp;


code:
import { isSafeInteger } from "./index";
export = isSafeInteger;


code:
import { isSet } from "./index";
export = isSet;


code:
import { isString } from "./index";
export = isString;


code:
import { isSymbol } from "./index";
export = isSymbol;


code:
import { isTypedArray } from "./index";
export = isTypedArray;


code:
import { isUndefined } from "./index";
export = isUndefined;


code:
import { isWeakMap } from "./index";
export = isWeakMap;


code:
import { isWeakSet } from "./index";
export = isWeakSet;


code:
import { iteratee } from "./index";
export = iteratee;


code:
import { join } from "./index";
export = join;


code:
import { kebabCase } from "./index";
export = kebabCase;


code:
import { keyBy } from "./index";
export = keyBy;


code:
import { keys } from "./index";
export = keys;


code:
import { keysIn } from "./index";
export = keysIn;


code:
import { last } from "./index";
export = last;


code:
import { lastIndexOf } from "./index";
export = lastIndexOf;


code:
import { lowerCase } from "./index";
export = lowerCase;


code:
import { lowerFirst } from "./index";
export = lowerFirst;


code:
import { lt } from "./index";
export = lt;


code:
import { lte } from "./index";
export = lte;


code:
import { map } from "./index";
export = map;


code:
import { mapKeys } from "./index";
export = mapKeys;


code:
import { mapValues } from "./index";
export = mapValues;


code:
import { matches } from "./index";
export = matches;


code:
import { matchesProperty } from "./index";
export = matchesProperty;


code:
import { max } from "./index";
export = max;


code:
import { maxBy } from "./index";
export = maxBy;


code:
import { mean } from "./index";
export = mean;


code:
import { meanBy } from "./index";
export = meanBy;


code:
import { memoize } from "./index";
export = memoize;


code:
import { merge } from "./index";
export = merge;


code:
import { mergeWith } from "./index";
export = mergeWith;


code:
import { method } from "./index";
export = method;


code:
import { methodOf } from "./index";
export = methodOf;


code:
import { min } from "./index";
export = min;


code:
import { minBy } from "./index";
export = minBy;


code:
import { mixin } from "./index";
export = mixin;


code:
import { multiply } from './index';
export = multiply;


code:
import { negate } from "./index";
export = negate;


code:
import { noConflict } from "./index";
export = noConflict;


code:
import { noop } from "./index";
export = noop;


code:
import { now } from "./index";
export = now;


code:
import { nth } from "./index";
export = nth;


code:
import { nthArg } from "./index";
export = nthArg;


code:
import { omit } from "./index";
export = omit;


code:
import { omitBy } from "./index";
export = omitBy;


code:
import { once } from "./index";
export = once;


code:
import { orderBy } from "./index";
export = orderBy;


code:
import { over } from "./index";
export = over;


code:
import { overArgs } from "./index";
export = overArgs;


code:
import { overEvery } from "./index";
export = overEvery;


code:
import { overSome } from "./index";
export = overSome;


@types/lodash

description: TypeScript definitions for lodash

license: MIT

Brian Zengel

githubUsername: bczengel

Ilya Mochalov

githubUsername: chrootsu

AJ Richardson

githubUsername: aj-r

e-cloud

githubUsername: e-cloud

Jack Moore

githubUsername: jtmthf

Dominique Rau

githubUsername: DomiR

William Chelman

githubUsername: WilliamChelman

type: git

directory: types/lodash


code:
import { pad } from "./index";
export = pad;


code:
import { padEnd } from "./index";
export = padEnd;


code:
import { padStart } from "./index";
export = padStart;


code:
import { parseInt } from "./index";
export = parseInt;


code:
import { partial } from "./index";
export = partial;


code:
import { partialRight } from "./index";
export = partialRight;


code:
import { partition } from "./index";
export = partition;


code:
import { pick } from "./index";
export = pick;


code:
import { pickBy } from "./index";
export = pickBy;


code:
import { property } from "./index";
export = property;


code:
import { propertyOf } from "./index";
export = propertyOf;


code:
import { pull } from "./index";
export = pull;


code:
import { pullAll } from "./index";
export = pullAll;


code:
import { pullAllBy } from "./index";
export = pullAllBy;


code:
import { pullAllWith } from "./index";
export = pullAllWith;


code:
import { pullAt } from "./index";
export = pullAt;


code:
import { random } from "./index";
export = random;


code:
import { range } from "./index";
export = range;


code:
import { rangeRight } from "./index";
export = rangeRight;


code:
import { rearg } from "./index";
export = rearg;


code:
import { reduce } from "./index";
export = reduce;


code:
import { reduceRight } from "./index";
export = reduceRight;


code:
import { reject } from "./index";
export = reject;


code:
import { remove } from "./index";
export = remove;


code:
import { repeat } from "./index";
export = repeat;


code:
import { replace } from "./index";
export = replace;


code:
import { rest } from "./index";
export = rest;


code:
import { result } from "./index";
export = result;


code:
import { reverse } from "./index";
export = reverse;


code:
import { round } from "./index";
export = round;


code:
import { runInContext } from "./index";
export = runInContext;


code:
import { sample } from "./index";
export = sample;


code:
import { sampleSize } from "./index";
export = sampleSize;


code:
import { set } from "./index";
export = set;


code:
import { setWith } from "./index";
export = setWith;


code:
import { shuffle } from "./index";
export = shuffle;


code:
import { size } from "./index";
export = size;


code:
import { slice } from "./index";
export = slice;


code:
import { snakeCase } from "./index";
export = snakeCase;


code:
import { some } from "./index";
export = some;


code:
import { sortBy } from "./index";
export = sortBy;


code:
import { sortedIndex } from "./index";
export = sortedIndex;


code:
import { sortedIndexBy } from "./index";
export = sortedIndexBy;


code:
import { sortedIndexOf } from "./index";
export = sortedIndexOf;


code:
import { sortedLastIndex } from "./index";
export = sortedLastIndex;


code:
import { sortedLastIndexBy } from "./index";
export = sortedLastIndexBy;


code:
import { sortedLastIndexOf } from "./index";
export = sortedLastIndexOf;


code:
import { sortedUniq } from "./index";
export = sortedUniq;


code:
import { sortedUniqBy } from "./index";
export = sortedUniqBy;


code:
import { split } from "./index";
export = split;


code:
import { spread } from "./index";
export = spread;


code:
import { startCase } from "./index";
export = startCase;


code:
import { startsWith } from "./index";
export = startsWith;


code:
import { stubFalse } from "./index";
export = stubFalse;


code:
import { stubTrue } from "./index";
export = stubTrue;


code:
import { subtract } from "./index";
export = subtract;


code:
import { sum } from "./index";
export = sum;


code:
import { sumBy } from "./index";
export = sumBy;


code:
import { tail } from "./index";
export = tail;


code:
import { take } from "./index";
export = take;


code:
import { takeRight } from "./index";
export = takeRight;


code:
import { takeRightWhile } from "./index";
export = takeRightWhile;


code:
import { takeWhile } from "./index";
export = takeWhile;


code:
import { tap } from "./index";
export = tap;


code:
import { template } from "./index";
export = template;


code:
import { throttle } from "./index";
export = throttle;


code:
import { thru } from "./index";
export = thru;


code:
import { times } from "./index";
export = times;


code:
import { toArray } from "./index";
export = toArray;


code:
import { toFinite } from "./index";
export = toFinite;


code:
import { toInteger } from "./index";
export = toInteger;


code:
import { toLength } from "./index";
export = toLength;


code:
import { toLower } from "./index";
export = toLower;


code:
import { toNumber } from "./index";
export = toNumber;


code:
import { toPairs } from "./index";
export = toPairs;


code:
import { toPairsIn } from "./index";
export = toPairsIn;


code:
import { toPath } from "./index";
export = toPath;


code:
import { toPlainObject } from "./index";
export = toPlainObject;


code:
import { toSafeInteger } from "./index";
export = toSafeInteger;


code:
import { toString } from "./index";
export = toString;


code:
import { toUpper } from "./index";
export = toUpper;


code:
import { transform } from "./index";
export = transform;


code:
import { trim } from "./index";
export = trim;


code:
import { trimEnd } from "./index";
export = trimEnd;


code:
import { trimStart } from "./index";
export = trimStart;


code:
import { truncate } from "./index";
export = truncate;


code:
import { unary } from "./index";
export = unary;


code:
import { unescape } from "./index";
export = unescape;


code:
import { union } from "./index";
export = union;


code:
import { unionBy } from "./index";
export = unionBy;


code:
import { unionWith } from "./index";
export = unionWith;


code:
import { uniq } from "./index";
export = uniq;


code:
import { uniqBy } from "./index";
export = uniqBy;


code:
import { uniqWith } from "./index";
export = uniqWith;


code:
import { uniqueId } from "./index";
export = uniqueId;


code:
import { unset } from "./index";
export = unset;


code:
import { unzip } from "./index";
export = unzip;


code:
import { unzipWith } from "./index";
export = unzipWith;


code:
import { update } from "./index";
export = update;


code:
import { updateWith } from "./index";
export = updateWith;


code:
import { upperCase } from "./index";
export = upperCase;


code:
import { upperFirst } from "./index";
export = upperFirst;


code:
import { values } from "./index";
export = values;


code:
import { valuesIn } from "./index";
export = valuesIn;


code:
import { without } from "./index";
export = without;


code:
import { words } from "./index";
export = words;


code:
import { wrap } from "./index";
export = wrap;


code:
import { xor } from "./index";
export = xor;


code:
import { xorBy } from "./index";
export = xorBy;


code:
import { xorWith } from "./index";
export = xorWith;


code:
import { zip } from "./index";
export = zip;


code:
import { zipObject } from "./index";
export = zipObject;


code:
import { zipObjectDeep } from "./index";
export = zipObjectDeep;


code:
import { zipWith } from "./index";
export = zipWith;


code:
import { TypeMap } from "./index";

export default class Mime {
    constructor(mimes: TypeMap);

    lookup(path: string, fallback?: string): string;
    extension(mime: string): string | undefined;
    load(filepath: string): void;
    define(mimes: TypeMap): void;
}


code:
# Installation
> `npm install --save @types/mime`

# Summary
This package contains type definitions for mime (https://github.com/broofa/node-mime).

# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/mime/v1.

### Additional Details
 * Last updated: Tue, 07 Nov 2023 20:08:00 GMT
 * Dependencies: none

# Credits
These definitions were written by [Jeff Goddard](https://github.com/jedigo), and [Daniel Hritzkiv](https://github.com/dhritzkiv).


code:
// Originally imported from: https://github.com/soywiz/typescript-node-definitions/mime.d.ts

export as namespace mime;

export interface TypeMap {
    [key: string]: string[];
}

/**
 * Look up a mime type based on extension.
 *
 * If not found, uses the fallback argument if provided, and otherwise
 * uses `default_type`.
 */
export function lookup(path: string, fallback?: string): string;
/**
 * Return a file extensions associated with a mime type.
 */
export function extension(mime: string): string | undefined;
/**
 * Load an Apache2-style ".types" file.
 */
export function load(filepath: string): void;
export function define(mimes: TypeMap): void;

export interface Charsets {
    lookup(mime: string, fallback: string): string;
}

export const charsets: Charsets;
export const default_type: string;


code:
import { default as Mime } from "./Mime";

declare const mimelite: Mime;

export as namespace mimelite;

export = mimelite;


@types/mime

description: TypeScript definitions for mime

Jeff Goddard

githubUsername: jedigo

Daniel Hritzkiv

githubUsername: dhritzkiv

directory: types/mime


code:
# Installation
> `npm install --save @types/minimist`

# Summary
This package contains type definitions for minimist (https://github.com/substack/minimist).

# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/minimist.

### Additional Details
 * Last updated: Tue, 07 Nov 2023 09:09:39 GMT
 * Dependencies: none

# Credits
These definitions were written by [Bart van der Schoor](https://github.com/Bartvds), [Necroskillz](https://github.com/Necroskillz), [kamranayub](https://github.com/kamranayub), and [Piotr Błażejewicz](https://github.com/peterblazejewicz).


code:
/**
 * Return an argument object populated with the array arguments from args
 *
 * @param [args] An optional argument array (typically `process.argv.slice(2)`)
 * @param [opts] An optional options object to customize the parsing
 */
declare function minimist(args?: string[], opts?: minimist.Opts): minimist.ParsedArgs;

/**
 * Return an argument object populated with the array arguments from args. Strongly-typed
 * to be the intersect of type T with minimist.ParsedArgs.
 *
 * `T` The type that will be intersected with minimist.ParsedArgs to represent the argument object
 *
 * @param [args] An optional argument array (typically `process.argv.slice(2)`)
 * @param [opts] An optional options object to customize the parsing
 */
declare function minimist<T>(args?: string[], opts?: minimist.Opts): T & minimist.ParsedArgs;

/**
 * Return an argument object populated with the array arguments from args. Strongly-typed
 * to be the the type T which should extend minimist.ParsedArgs
 *
 * `T` The type that extends minimist.ParsedArgs and represents the argument object
 *
 * @param [args] An optional argument array (typically `process.argv.slice(2)`)
 * @param [opts] An optional options object to customize the parsing
 */
declare function minimist<T extends minimist.ParsedArgs>(args?: string[], opts?: minimist.Opts): T;

declare namespace minimist {
    interface Opts {
        /**
         * A string or array of strings argument names to always treat as strings
         */
        string?: string | string[] | undefined;

        /**
         * A boolean, string or array of strings to always treat as booleans. If true will treat
         * all double hyphenated arguments without equals signs as boolean (e.g. affects `--foo`, not `-f` or `--foo=bar`)
         */
        boolean?: boolean | string | string[] | undefined;

        /**
         * An object mapping string names to strings or arrays of string argument names to use as aliases
         */
        alias?: { [key: string]: string | string[] } | undefined;

        /**
         * An object mapping string argument names to default values
         */
        default?: { [key: string]: any } | undefined;

        /**
         * When true, populate argv._ with everything after the first non-option
         */
        stopEarly?: boolean | undefined;

        /**
         * A function which is invoked with a command line parameter not defined in the opts
         * configuration object. If the function returns false, the unknown option is not added to argv
         */
        unknown?: ((arg: string) => boolean) | undefined;

        /**
         * When true, populate argv._ with everything before the -- and argv['--'] with everything after the --.
         * Note that with -- set, parsing for arguments still stops after the `--`.
         */
        "--"?: boolean | undefined;
    }

    interface ParsedArgs {
        [arg: string]: any;

        /**
         * If opts['--'] is true, populated with everything after the --
         */
        "--"?: string[] | undefined;

        /**
         * Contains all the arguments that didn't have an option associated with them
         */
        _: string[];
    }
}

export = minimist;


@types/minimist

description: TypeScript definitions for minimist

Bart van der Schoor

githubUsername: Bartvds

Necroskillz

githubUsername: Necroskillz

kamranayub

githubUsername: kamranayub

Piotr Błażejewicz

githubUsername: peterblazejewicz

directory: types/minimist


code:
# Installation
> `npm install --save @types/node-forge`

# Summary
This package contains type definitions for node-forge (https://github.com/digitalbazaar/forge).

# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node-forge.

### Additional Details
 * Last updated: Tue, 02 Jan 2024 22:35:21 GMT
 * Dependencies: [@types/node](https://npmjs.com/package/@types/node)

# Credits
These definitions were written by [Seth Westphal      ](https://github.com/westy92), [Kay Schecker       ](https://github.com/flynetworks), [Aakash Goenka      ](https://github.com/a-k-g), [Rafal2228          ](https://github.com/rafal2228), [Beeno Tung         ](https://github.com/beenotung), [Joe Flateau        ](https://github.com/joeflateau), [timhwang21         ](https://github.com/timhwang21), [Anders Kaseorg     ](https://github.com/andersk), [Sascha Zarhuber    ](https://github.com/saschazar21), [Rogier Schouten    ](https://github.com/rogierschouten), [Ivan Aseev         ](https://github.com/aseevia), [Wiktor Kwapisiewicz](https://github.com/wiktor-k), [Ligia Frangello    ](https://github.com/frangello), [Dmitry Avezov      ](https://github.com/avezov), [Jose Fuentes       ](https://github.com/j-fuentes), [Anya Reyes         ](https://github.com/darkade), and [BendingBender      ](https://github.com/BendingBender).