@types/underscore

  • Version 1.11.2
  • Published
  • 247 kB
  • No dependencies
  • MIT license

Install

npm i @types/underscore
yarn add @types/underscore
pnpm add @types/underscore

Overview

TypeScript definitions for Underscore

Index

Interfaces

Type Aliases

Namespaces

Interfaces

interface Cancelable

interface Cancelable {}

    method cancel

    cancel: () => void;

      interface CollectionIterator

      interface CollectionIterator<
      T extends TypeOfList<V> | TypeOfDictionary<V, any>,
      TResult,
      V = Collection<T>
      > {}

        call signature

        (element: T, key: CollectionKey<V>, collection: V): TResult;

          interface CompiledTemplate

          interface CompiledTemplate {}

            property source

            source: string;

              call signature

              (data?: any): string;

                interface Dictionary

                interface Dictionary<T> {}

                  index signature

                  [index: string]: T;

                    interface List

                    interface List<T> {}

                      property length

                      length: number;

                        index signature

                        [index: number]: T;

                          interface ListIterator

                          interface ListIterator<T extends TypeOfList<V>, TResult, V = List<T>>
                          extends CollectionIterator<T, TResult, V> {}

                            interface MemoCollectionIterator

                            interface MemoCollectionIterator<
                            T extends TypeOfList<V> | TypeOfDictionary<V, any>,
                            TResult,
                            V = Collection<T>
                            > {}

                              call signature

                              (prev: TResult, curr: T, key: CollectionKey<V>, collection: V): TResult;

                                interface MemoIterator

                                interface MemoIterator<T extends TypeOfList<V>, TResult, V = List<T>>
                                extends MemoCollectionIterator<T, TResult, V> {}

                                  interface MemoObjectIterator

                                  interface MemoObjectIterator<
                                  T extends TypeOfDictionary<V>,
                                  TResult,
                                  V = Dictionary<T>
                                  > extends MemoCollectionIterator<T, TResult, V> {}

                                    interface ObjectIterator

                                    interface ObjectIterator<
                                    T extends TypeOfDictionary<V, any>,
                                    TResult,
                                    V = Dictionary<T>
                                    > extends CollectionIterator<T, TResult, V> {}

                                      interface Predicate

                                      interface Predicate<T> {}

                                        call signature

                                        (value: T): boolean;

                                          interface TemplateSettings

                                          interface TemplateSettings {}
                                          • underscore.js template settings, set templateSettings or pass as an argument to 'template()' to override defaults.

                                          property escape

                                          escape?: RegExp;
                                          • Default value is '/<%-([\s\S]+?)%>/g'.

                                          property evaluate

                                          evaluate?: RegExp;
                                          • Default value is '/<%([\s\S]+?)%>/g'.

                                          property interpolate

                                          interpolate?: RegExp;
                                          • Default value is '/<%=([\s\S]+?)%>/g'.

                                          property variable

                                          variable?: string;
                                          • By default, 'template()' places the values from your data in the local scope via the 'with' statement. However, you can specify a single variable name with this setting.

                                          interface ThrottleSettings

                                          interface ThrottleSettings {}
                                          • underscore.js _.throttle options.

                                          property leading

                                          leading?: boolean;
                                          • If you'd like to disable the leading-edge call, pass this as false.

                                          property trailing

                                          trailing?: boolean;
                                          • If you'd like to disable the execution on the trailing-edge, pass false.

                                          interface Underscore

                                          interface Underscore<T, V = T[]> {}

                                            property all

                                            all: Underscore<T, V>['every'];
                                            • See Also

                                              • every

                                            property any

                                            any: Underscore<T, V>['some'];
                                            • See Also

                                              • some

                                            property collect

                                            collect: Underscore<T, V>['map'];
                                            • See Also

                                              • map

                                            property detect

                                            detect: Underscore<T, V>['find'];
                                            • See Also

                                              • find

                                            property drop

                                            drop: Underscore<T, V>['rest'];
                                            • See Also

                                              • rest

                                            property foldl

                                            foldl: Underscore<T, V>['reduce'];
                                            • See Also

                                              • reduce

                                            property foldr

                                            foldr: Underscore<T, V>['reduceRight'];
                                            • See Also

                                              • reduceRight

                                            property forEach

                                            forEach: Underscore<T, V>['each'];
                                            • See Also

                                              • each

                                            property head

                                            head: Underscore<T, V>['first'];
                                            • See Also

                                              • first

                                            property include

                                            include: Underscore<T, V>['contains'];
                                            • See Also

                                              • contains

                                            property includes

                                            includes: Underscore<T, V>['contains'];
                                            • See Also

                                              • contains

                                            property inject

                                            inject: Underscore<T, V>['reduce'];
                                            • See Also

                                              • reduce

                                            property select

                                            select: Underscore<T, V>['filter'];
                                            • See Also

                                              • filter

                                            property tail

                                            tail: Underscore<T, V>['rest'];
                                            • See Also

                                              • rest

                                            property take

                                            take: Underscore<T, V>['first'];
                                            • See Also

                                              • first

                                            property unique

                                            unique: Underscore<T, V>['uniq'];
                                            • See Also

                                              • uniq

                                            method after

                                            after: (fn: Function) => Function;
                                            • Wrapped type number.

                                              See Also

                                              • _.after

                                            method allKeys

                                            allKeys: () => string[];
                                            • Wrapped type object.

                                              See Also

                                              • _.allKeys

                                            method before

                                            before: (fn: Function) => Function;
                                            • Wrapped type number.

                                              See Also

                                              • _.before

                                            method bind

                                            bind: (object: any, ...args: any[]) => Function;
                                            • Wrapped type Function.

                                              See Also

                                              • _.bind

                                            method bindAll

                                            bindAll: (...methodNames: string[]) => any;
                                            • Wrapped type object.

                                              See Also

                                              • _.bindAll

                                            method chain

                                            chain: () => _Chain<T, V>;
                                            • Returns a wrapped object. Calling methods on this object will continue to return wrapped objects until value() is used.

                                              Returns

                                              An underscore chain wrapper around the wrapped value.

                                            method chunk

                                            chunk: (length: number) => T[][];
                                            • Chunks the wrapped list into multiple arrays, each containing length or fewer items.

                                              Parameter length

                                              The maximum size of the chunks.

                                              Returns

                                              The contents of the wrapped list in chunks no greater than length in size.

                                            method clone

                                            clone: () => T;
                                            • Wrapped type any[].

                                              See Also

                                              • _.clone

                                            method compact

                                            compact: () => Truthy<T>[];
                                            • Returns a copy of the wrapped list with all falsy values removed. In JavaScript, false, null, 0, "", undefined and NaN are all falsy.

                                              Returns

                                              An array containing the elements of the wrapped list without falsy values.

                                            method compose

                                            compose: (...functions: Function[]) => Function;
                                            • Wrapped type Function[].

                                              See Also

                                              • _.compose

                                            method constant

                                            constant: () => () => T;
                                            • Wrapped type any.

                                              See Also

                                              • _.constant

                                            method contains

                                            contains: (value: any, fromIndex?: number) => boolean;
                                            • Returns true if the value is present in the wrapped collection. Uses indexOf internally, if the wrapped collection is a List. Use fromIndex to start your search at a given index.

                                              Parameter value

                                              The value to check the wrapped collection for.

                                              Parameter fromIndex

                                              The index to start searching from, optional, default = 0, only used when the wrapped collection is a List.

                                              Returns

                                              True if value is present in the wrapped collection after fromIndex, otherwise false.

                                            method countBy

                                            countBy: (
                                            iteratee?: Iteratee<V, string | number>,
                                            context?: any
                                            ) => Dictionary<number>;
                                            • Sorts the wrapped collection into groups and returns a count for the number of objects in each group. Similar to groupBy, but instead of returning a list of values, returns a count for the number of values in that group.

                                              Parameter iteratee

                                              An iteratee that provides the value to count by for each item in the wrapped collection.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              A dictionary with the group names provided by iteratee as properties where each property contains the count of the grouped elements from the wrapped collection.

                                            method create

                                            create: (props?: object) => any;
                                            • Wrapped type any.

                                              See Also

                                              • _.create

                                            method debounce

                                            debounce: (wait: number, immediate?: boolean) => Function & _.Cancelable;
                                            • Wrapped type Function.

                                              See Also

                                              • _.debounce

                                            method defaults

                                            defaults: (...defaults: any[]) => any;
                                            • Wrapped type object.

                                              See Also

                                              • _.defaults

                                            method defer

                                            defer: (...args: any[]) => void;
                                            • Wrapped type Function.

                                              See Also

                                              • _.defer

                                            method delay

                                            delay: { (wait: number, ...args: any[]): any; (...args: any[]): any };
                                            • Wrapped type Function.

                                              See Also

                                              • _.delay

                                            • See Also

                                              • _.delay

                                            method difference

                                            difference: (...others: List<T>[]) => T[];
                                            • Similar to without, but returns the values from the wrapped list that are not present in others.

                                              Parameter list

                                              The starting list.

                                              Parameter others

                                              The lists of values to exclude from the wrapped list.

                                              Returns

                                              The contents of the wrapped list without the values in others.

                                            method each

                                            each: (
                                            iteratee: CollectionIterator<TypeOfCollection<V>, void, V>,
                                            context?: any
                                            ) => V;
                                            • Iterates over the wrapped collection of elements, yielding each in turn to an iteratee. The iteratee is bound to the context object, if one is passed.

                                              Parameter iteratee

                                              The iteratee to call for each element in the wrapped collection.

                                              Parameter context

                                              'this' object in iteratee, optional.

                                              Returns

                                              The originally wrapped collection.

                                            method escape

                                            escape: () => string;
                                            • Wrapped type string.

                                              See Also

                                              • _.escape

                                            method every

                                            every: (iteratee?: Iteratee<V, boolean>, context?: any) => boolean;
                                            • Returns true if all of the values in the wrapped collection pass the iteratee truth test. Short-circuits and stops traversing the wrapped collection if a false element is found.

                                              Parameter iteratee

                                              The truth test to apply.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              True if all elements pass the truth test, otherwise false.

                                            method extend

                                            extend: (...sources: any[]) => any;
                                            • Wrapped type object.

                                              See Also

                                              • _.extend

                                            method filter

                                            filter: (iteratee?: Iteratee<V, boolean>, context?: any) => T[];
                                            • Looks through each value in the wrapped collection, returning an array of all the values that pass a truth test (iteratee).

                                              Parameter iteratee

                                              The truth test to apply.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              The set of values that pass the truth test.

                                            method find

                                            find: (iteratee?: Iteratee<V, boolean>, context?: any) => T | undefined;
                                            • Looks through each value in the wrapped collection, returning the first one that passes a truth test (iteratee), or undefined if no value passes the test. The function returns as soon as it finds an acceptable element, and doesn't traverse the entire collection.

                                              Parameter iteratee

                                              The truth test to apply.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              The first element in the wrapped collection that passes the truth test or undefined if no elements pass.

                                            method findIndex

                                            findIndex: (iteratee?: Iteratee<V, boolean>, context?: any) => number;
                                            • Returns the first index of an element in the wrapped list where the iteratee truth test passes, otherwise returns -1.

                                              Parameter iteratee

                                              The truth test to apply.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              The index of the first element in the wrapped list where the truth test passes or -1 if no elements pass.

                                            method findKey

                                            findKey: (
                                            iteratee?: Iteratee<V, boolean, TypeOfCollection<V, any>>,
                                            context?: any
                                            ) => Extract<keyof V, string> | undefined;
                                            • Similar to findIndex but for keys in objects. Returns the key where the iteratee truth test passes or undefined.

                                              Parameter iteratee

                                              The truth test to apply.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              The first element in the wrapped object that passes the truth test or undefined if no elements pass.

                                            method findLastIndex

                                            findLastIndex: (iteratee?: Iteratee<V, boolean>, context?: any) => number;
                                            • Returns the last index of an element in the wrapped list where the iteratee truth test passes, otherwise returns -1.

                                              Parameter iteratee

                                              The truth test to apply.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              The index of the last element in the wrapped list where the truth test passes or -1 if no elements pass.

                                            method findWhere

                                            findWhere: (properties: Partial<T>) => T | undefined;
                                            • Looks through the wrapped collection and returns the first value that matches all of the key-value pairs listed in properties. If no match is found, or if list is empty, undefined will be returned.

                                              Parameter properties

                                              The properties to check for on the elements within the wrapped collection.

                                              Returns

                                              The first element in the wrapped collection that matches properties or undefined if no match is found.

                                            method first

                                            first: { (): T | undefined; (n: number): T[] };
                                            • Returns the first element of the wrapped list. Passing n will return the first n elements of the wrapped list.

                                              Parameter n

                                              The number of elements to retrieve, optional.

                                              Returns

                                              The first n elements of the wrapped list or the first element if n is omitted.

                                            method flatten

                                            flatten: {
                                            (depth: 1 | true): ListItemOrSelf<T>[];
                                            (depth?: number | false): DeepestListItemOrSelf<T>[];
                                            };
                                            • Flattens a nested list (the nesting can be to any depth). If you pass depth, the wrapped list will only be flattened a single level.

                                              Parameter depth

                                              True to only flatten one level, optional, default = false.

                                              Returns

                                              The flattened list.

                                            method functions

                                            functions: () => string[];
                                            • Wrapped type object.

                                              See Also

                                              • _.functions

                                            method get

                                            get: {
                                            (path: string | string[]): TypeOfCollection<V> | undefined;
                                            <U>(path: string | string[], defaultValue?: U):
                                            | TypeOfCollection<V, never>
                                            | U;
                                            };
                                            • Wrapped type any.

                                              See Also

                                              • _.get

                                            method groupBy

                                            groupBy: (
                                            iteratee?: Iteratee<V, string | number>,
                                            context?: any
                                            ) => Dictionary<T[]>;
                                            • Splits the warpped collection into sets that are grouped by the result of running each value through iteratee.

                                              Parameter iteratee

                                              An iteratee that provides the value to group by for each item in the wrapped collection.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              A dictionary with the group names provided by iteratee as properties where each property contains the grouped elements from the wrapped collection.

                                            method has

                                            has: (key: string) => boolean;
                                            • Wrapped type object.

                                              See Also

                                              • _.has

                                            method identity

                                            identity: () => any;
                                            • Wrapped type any.

                                              See Also

                                              • _.identity

                                            method indexBy

                                            indexBy: (
                                            iteratee?: Iteratee<V, string | number>,
                                            context?: any
                                            ) => Dictionary<T>;
                                            • Given the warpped collection and an iteratee function that returns a key for each element in the wrapped collection, returns an object that acts as an index of each item. Just like groupBy, but for when you know your keys are unique.

                                              Parameter iteratee

                                              An iteratee that provides the value to index by for each item in the wrapped collection.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              A dictionary where each item in the wrapped collection is assigned to the property designated by iteratee.

                                            method indexOf

                                            indexOf: (value: T, isSortedOrFromIndex?: boolean | number) => number;
                                            • Returns the index at which value can be found in the wrapped list, or -1 if value is not present. If you're working with a large list and you know that the list is already sorted, pass true for isSortedOrFromIndex to use a faster binary search...or, pass a number in order to look for the first matching value in the list after the given index.

                                              Parameter value

                                              The value to search for within the wrapped list.

                                              Parameter isSortedOrFromIndex

                                              True if the wrapped list is already sorted OR the starting index for the search, optional.

                                              Returns

                                              The index of the first occurrence of value within the wrapped list or -1 if value is not found.

                                            method initial

                                            initial: (n?: number) => T[];
                                            • Returns everything but the last entry of the wrapped list. Especially useful on the arguments object. Pass n to exclude the last n elements from the result.

                                              Parameter n

                                              The number of elements from the end of the wrapped list to omit, optional, default = 1.

                                              Returns

                                              The elements of the wrapped list with the last n items omitted.

                                            method intersection

                                            intersection: (...lists: List<T>[]) => T[];
                                            • Computes the list of values that are the intersection of the wrapped list and the passed-in lists. Each value in the result is present in each of the lists.

                                              Parameter lists

                                              The lists (along with the wrapped list) to compute the intersection of.

                                              Returns

                                              The intersection of elements within the the wrapped list and lists.

                                            method invert

                                            invert: () => any;
                                            • Wrapped type object.

                                              See Also

                                              • _.invert

                                            method invoke

                                            invoke: (methodName: string, ...args: any[]) => any[];
                                            • Calls the method named by methodName on each value in the wrapped collection. Any extra arguments passed to invoke will be forwarded on to the method invocation.

                                              Parameter methodName

                                              The name of the method to call on each element in the wrapped collection.

                                              Parameter args

                                              Additional arguments to pass to method methodName.

                                              Returns

                                              An array containing the result of the method call for each item in the wrapped collection.

                                            method isArguments

                                            isArguments: () => boolean;
                                            • Returns true if the wrapped object is an Arguments object.

                                              Returns

                                              True if the wrapped object is an Arguments object, otherwise false.

                                            method isArray

                                            isArray: () => boolean;
                                            • Returns true if the wrapped object is an Array.

                                              Returns

                                              True if the wrapped object is an Array, otherwise false.

                                            method isArrayBuffer

                                            isArrayBuffer: () => boolean;
                                            • Returns true if the wrapped object is an ArrayBuffer.

                                              Returns

                                              True if the wrapped object is an ArrayBuffer, otherwise false.

                                            method isBoolean

                                            isBoolean: () => boolean;
                                            • Returns true if the wrapped object is a Boolean.

                                              Returns

                                              True if the wrapped object is a Boolean, otherwise false.

                                            method isDataView

                                            isDataView: () => boolean;
                                            • Returns true if the wrapped object is a DataView.

                                              Returns

                                              True if the wrapped object is a DataView, otherwise false.

                                            method isDate

                                            isDate: () => boolean;
                                            • Returns true if the wrapped object is a Date.

                                              Returns

                                              True if the wrapped object is a Date, otherwise false.

                                            method isElement

                                            isElement: () => boolean;
                                            • Returns true if the wrapped object is a DOM element.

                                              Returns

                                              True if the wrapped object is a DOM element, otherwise false.

                                            method isEmpty

                                            isEmpty: () => boolean;
                                            • Returns true if the wrapped collection contains no values. For strings and array-like objects checks if the length property is 0.

                                              Returns

                                              True if the wrapped collection has no elements.

                                            method isEqual

                                            isEqual: (other: any) => boolean;
                                            • Performs an optimized deep comparison between the wrapped object and other to determine if they should be considered equal.

                                              Parameter other

                                              Compare to the wrapped object.

                                              Returns

                                              True if the wrapped object should be considered equal to other.

                                            method isError

                                            isError: () => boolean;
                                            • Returns true if the wrapped object is a Error.

                                              Returns

                                              True if the wrapped object is a Error, otherwise false.

                                            method isFinite

                                            isFinite: () => boolean;
                                            • Returns true if the wrapped object is a finite Number.

                                              Returns

                                              True if the wrapped object is a finite Number.

                                            method isFunction

                                            isFunction: () => boolean;
                                            • Returns true if the wrapped object is a Function.

                                              Returns

                                              True if the wrapped object is a Function, otherwise false.

                                            method isMatch

                                            isMatch: (properties: any) => boolean;
                                            • Returns true if the keys and values in properties are contained in the wrapped object.

                                              Parameter properties

                                              The properties to check for in the wrapped object.

                                              Returns

                                              True if all keys and values in properties are also in the wrapped object.

                                            method isNaN

                                            isNaN: () => boolean;
                                            • Returns true if the wrapped object is NaN. Note: this is not the same as the native isNaN function, which will also return true if the variable is undefined.

                                              Returns

                                              True if the wrapped object is NaN, otherwise false.

                                            method isNull

                                            isNull: () => boolean;
                                            • Returns true if the wrapped object is null.

                                              Returns

                                              True if the wrapped object is null, otherwise false.

                                            method isNumber

                                            isNumber: () => boolean;
                                            • Returns true if the wrapped object is a Number (including NaN).

                                              Returns

                                              True if the wrapped object is a Number, otherwise false.

                                            method isObject

                                            isObject: () => boolean;
                                            • Returns true if the wrapped object is an Object. Note that JavaScript arrays and functions are objects, while (normal) strings and numbers are not.

                                              Returns

                                              True if the wrapped object is an Object, otherwise false.

                                            method isRegExp

                                            isRegExp: () => boolean;
                                            • Returns true if the wrapped object is a RegExp.

                                              Returns

                                              True if the wrapped object is a RegExp, otherwise false.

                                            method isString

                                            isString: () => boolean;
                                            • Returns true if the wrapped object is a String.

                                              Returns

                                              True if the wrapped object is a String, otherwise false.

                                            method isSymbol

                                            isSymbol: () => boolean;
                                            • Returns true if the wrapped object is a Symbol.

                                              Returns

                                              True if the wrapped object is a Symbol, otherwise false.

                                            method isTypedArray

                                            isTypedArray: () => boolean;
                                            • Returns true if the wrapped object is a TypedArray.

                                              Returns

                                              True if the wrapped object is a TypedArray, otherwise false.

                                            method isUndefined

                                            isUndefined: () => boolean;
                                            • Returns true if the wrapped object is undefined.

                                              Returns

                                              True if the wrapped object is undefined, otherwise false.

                                            method iteratee

                                            iteratee: (context?: any) => Function;
                                            • Wrapped type string|Function|Object.

                                              See Also

                                              • _.iteratee

                                            method keys

                                            keys: () => string[];
                                            • Wrapped type object.

                                              See Also

                                              • _.keys

                                            method last

                                            last: { (): T | undefined; (n: number): T[] };
                                            • Returns the last element of the wrapped list. Passing n will return the last n elements of the wrapped list.

                                              Parameter n

                                              The number of elements to retrieve, optional.

                                              Returns

                                              The last n elements of the wrapped list or the last element if n is omitted.

                                            method lastIndexOf

                                            lastIndexOf: (value: T, fromIndex?: number) => number;
                                            • Returns the index of the last occurrence of value in the wrapped list, or -1 if value is not present. Pass fromIndex to start your search at a given index.

                                              Parameter value

                                              The value to search for within the wrapped list.

                                              Parameter fromIndex

                                              The starting index for the search, optional.

                                              Returns

                                              The index of the last occurrence of value within the wrapped list or -1 if value is not found.

                                            method map

                                            map: <I extends Iteratee<V, any, TypeOfCollection<V, never>>>(
                                            iteratee: I,
                                            context?: any
                                            ) => IterateeResult<I, T>[];
                                            • Produces a new array of values by mapping each value in the wrapped collection through a transformation iteratee.

                                              Parameter iteratee

                                              The iteratee to use to transform each item in the wrapped collection.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              The mapped result.

                                            method mapObject

                                            mapObject: <I extends Iteratee<V, any, TypeOfCollection<V, any>>>(
                                            iteratee: I,
                                            context?: any
                                            ) => { [K in keyof V]: IterateeResult<I, V[K]> };
                                            • Like map, but for objects. Transform the value of each property in turn.

                                              Parameter iteratee

                                              The iteratee to use to transform property values.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              A new object with all of the wrapped object's property values transformed through iteratee.

                                            method matcher

                                            matcher: () => _.ListIterator<T, boolean>;
                                            • Wrapped type any[].

                                              See Also

                                              • _.matcher

                                            method matches

                                            matches: () => _.ListIterator<T, boolean>;
                                            • Wrapped type any[].

                                              See Also

                                              • _.matches

                                            method max

                                            max: (iteratee?: Iteratee<V, any>, context?: any) => T | number;
                                            • Returns the maximum value in the wrapped collection. If an iteratee is provided, it will be used on each element to generate the criterion by which the element is ranked. -Infinity is returned if list is empty. Non-numerical values returned by iteratee will be ignored.

                                              Parameter iteratee

                                              The iteratee that provides the criterion by which each element is ranked, optional if evaluating a collection of numbers.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              The maximum element within the wrapped collection or -Infinity if the wrapped collection is empty.

                                            method memoize

                                            memoize: (hashFn?: (n: any) => string) => Function;
                                            • Wrapped type Function.

                                              See Also

                                              • _.memoize

                                            method methods

                                            methods: () => string[];
                                            • See Also

                                              • _.functions

                                            method min

                                            min: (iteratee?: Iteratee<V, any>, context?: any) => T | number;
                                            • Returns the minimum value in the wrapped collection. If an iteratee is provided, it will be used on each element to generate the criterion by which the element is ranked. Infinity is returned if list is empty. Non-numerical values returned by iteratee will be ignored.

                                              Parameter iteratee

                                              The iteratee that provides the criterion by which each element is ranked, optional if evaluating a collection of numbers.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              The minimum element within the wrapped collection or Infinity if the wrapped collection is empty.

                                            method mixin

                                            mixin: () => void;
                                            • Wrapped type object.

                                              See Also

                                              • _.mixin

                                            method negate

                                            negate: () => (...args: any[]) => boolean;
                                            • Wrapped type Function.

                                              See Also

                                              • _.negate

                                            method noop

                                            noop: () => void;
                                            • Wrapped type any.

                                              See Also

                                              • _.noop

                                            method object

                                            object: {
                                            <TValue>(values: List<TValue>): Dictionary<TValue | undefined>;
                                            (): Dictionary<PairValue<T>>;
                                            };
                                            • Converts lists into objects. Call on either a wrapped list of [key, value] pairs, or a wrapped list of keys and a list of values. Passing by pairs is the reverse of pairs. If duplicate keys exist, the last value wins.

                                              Parameter values

                                              If the wrapped list is a list of keys, a list of values corresponding to those keys.

                                              Returns

                                              An object comprised of the provided keys and values.

                                            method omit

                                            omit: {
                                            <K extends string>(...keys: (K | K[])[]): _Omit<V, K>;
                                            (iterator: ObjectIterator<TypeOfDictionary<V, any>, boolean, V>): Partial<V>;
                                            };
                                            • Return a copy of the wrapped object that is filtered to omit the disallowed keys (or array of keys).

                                              Parameter keys

                                              The keys to omit from the wrapped object.

                                              Returns

                                              A copy of the wrapped object without the keys properties.

                                            • Return a copy of the wrapped object that is filtered to not have values for the keys selected by a truth test.

                                              Parameter iterator

                                              A truth test that selects the keys to omit from the wrapped object.

                                              Returns

                                              A copy of the wrapped object without the keys selected by iterator.

                                            method once

                                            once: () => Function;
                                            • Wrapped type Function.

                                              See Also

                                              • _.once

                                            method pairs

                                            pairs: () => [Extract<keyof V, string>, TypeOfCollection<V, any>][];
                                            • Convert the wrapped object into a list of [key, value] pairs. The opposite of the single-argument signature of _.object.

                                              Returns

                                              The list of [key, value] pairs from the wrapped object.

                                            method partial

                                            partial: (...args: any[]) => Function;
                                            • Wrapped type Function.

                                              See Also

                                              • _.partial

                                            method partition

                                            partition: (iteratee?: Iteratee<V, boolean>, context?: any) => [T[], T[]];
                                            • Splits the wrapped collection into two arrays: one whose elements all satisfy iteratee and one whose elements all do not satisfy iteratee.

                                              Parameter iteratee

                                              The iteratee that defines the partitioning scheme for each element in the wrapped collection.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              An array composed of two elements, where the first element contains the elements in the wrapped collection that satisfied the predicate and the second element contains the elements that did not.

                                            method pick

                                            pick: {
                                            <K extends string>(...keys: (K | K[])[]): _Pick<V, K>;
                                            (iterator: ObjectIterator<TypeOfDictionary<V, any>, boolean, V>): Partial<V>;
                                            };
                                            • Return a copy of the wrapped object that is filtered to only have values for the allowed keys (or array of keys).

                                              Parameter keys

                                              The keys to keep on the wrapped object.

                                              Returns

                                              A copy of the wrapped object with only the keys properties.

                                            • Return a copy of the wrapped object that is filtered to only have values for the keys selected by a truth test.

                                              Parameter iterator

                                              A truth test that selects the keys to keep on the wrapped object.

                                              Returns

                                              A copy of the wrapped object with only the keys selected by iterator.

                                            method pluck

                                            pluck: <K extends string | number>(propertyName: K) => PropertyTypeOrAny<T, K>[];
                                            • A convenient version of what is perhaps the most common use-case for map: extracting a list of property values.

                                              Parameter propertyName

                                              The name of a specific property to retrieve from all items in the wrapped collection.

                                              Returns

                                              The set of values for the specified propertyName for each item in the wrapped collection.

                                            method property

                                            property: () => (object: any) => any;
                                            • Wrapped type string.

                                              See Also

                                              • _.property

                                            method propertyOf

                                            propertyOf: () => (key: string) => any;
                                            • Wrapped type object.

                                              See Also

                                              • _.propertyOf

                                            method random

                                            random: { (): number; (max: number): number };
                                            • Wrapped type number.

                                              See Also

                                              • _.random

                                            method range

                                            range: (stop?: number, step?: number) => number[];
                                            • A function to create flexibly-numbered lists of integers, handy for each and map loops. Returns a list of integers from the wrapped value (inclusive) to stop (exclusive), incremented (or decremented) by step. Note that ranges that stop before they start are considered to be zero-length instead of negative - if you'd like a negative range, use a negative step.

                                              If stop is not specified, the wrapped value will be the number to stop at and the default start of 0 will be used.

                                              Parameter stop

                                              The number to stop at.

                                              Parameter step

                                              The number to count up by each iteration, optional, default = 1.

                                              Returns

                                              An array of numbers from start to stop with increments of step.

                                            method reduce

                                            reduce: {
                                            <TResult>(
                                            iteratee: MemoCollectionIterator<TypeOfCollection<V>, TResult, V>,
                                            memo: TResult,
                                            context?: any
                                            ): TResult;
                                            <TResult = TypeOfCollection<V, never>>(
                                            iteratee: MemoCollectionIterator<
                                            TypeOfCollection<V, never>,
                                            TypeOfCollection<V, never> | TResult,
                                            V
                                            >
                                            ): TypeOfCollection<V, never> | TResult;
                                            };
                                            • Also known as inject and foldl, reduce boils down the wrapped collection of values into a single value. memo is the initial state of the reduction, and each successive step of it should be returned by iteratee.

                                              If no memo is passed to the initial invocation of reduce, iteratee is not invoked on the first element of the wrapped collection. The first element is instead passed as the memo in the invocation of iteratee on the next element in the wrapped collection.

                                              Parameter iteratee

                                              The function to call on each iteration to reduce the collection.

                                              Parameter memo

                                              The initial reduce state or undefined to use the first item in collection as initial state.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              The reduced result.

                                            method reduceRight

                                            reduceRight: {
                                            <TResult>(
                                            iteratee: MemoCollectionIterator<TypeOfCollection<V>, TResult, V>,
                                            memo: TResult,
                                            context?: any
                                            ): TResult;
                                            <TResult = TypeOfCollection<V, never>>(
                                            iteratee: MemoCollectionIterator<
                                            TypeOfCollection<V, never>,
                                            TypeOfCollection<V, never> | TResult,
                                            V
                                            >
                                            ): TypeOfCollection<V, never> | TResult;
                                            };
                                            • The right-associative version of reduce.

                                              This is not as useful in JavaScript as it would be in a language with lazy evaluation.

                                              Parameter iteratee

                                              The function to call on each iteration to reduce the collection.

                                              Parameter memo

                                              The initial reduce state or undefined to use the first item in collection as the initial state.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              The reduced result.

                                            method reject

                                            reject: (iteratee?: Iteratee<V, boolean>, context?: any) => T[];
                                            • Returns the values in the wrapped collection without the elements that pass a truth test (iteratee). The opposite of filter.

                                              Parameter iteratee

                                              The truth test to apply.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              The set of values that fail the truth test.

                                            method rest

                                            rest: (n?: number) => T[];
                                            • Returns the rest of the elements in the wrapped list. Pass an index to return the values of the list from that index onward.

                                              Parameter index

                                              The index to start retrieving elements from, optional, default = 1.

                                              Returns

                                              The elements of the wrapped list from index to the end of the list.

                                            method restArgs

                                            restArgs: (starIndex?: number) => Function;
                                            • Wrapped type Function.

                                              See Also

                                              • _.once

                                            method result

                                            result: (property: string, defaultValue?: any) => any;
                                            • Wrapped type object.

                                              See Also

                                              • _.result

                                            method sample

                                            sample: { (n: number): T[]; (): T };
                                            • Produce a random sample from the wrapped collection. Pass a number to return n random elements from the wrapped collection. Otherwise a single random item will be returned.

                                              Parameter n

                                              The number of elements to sample from the wrapped collection.

                                              Returns

                                              A random sample of n elements from the wrapped collection or a single element if n is not specified.

                                            method shuffle

                                            shuffle: () => T[];
                                            • Returns a shuffled copy of the wrapped collection, using a version of the Fisher-Yates shuffle.

                                              Returns

                                              A shuffled copy of the wrapped collection.

                                            method size

                                            size: () => number;
                                            • Determines the number of values in the wrapped collection.

                                              Returns

                                              The number of values in the wrapped collection.

                                            method some

                                            some: (iteratee?: Iteratee<V, boolean>, context?: any) => boolean;
                                            • Returns true if any of the values in the wrapped collection pass the iteratee truth test. Short-circuits and stops traversing the wrapped collection if a true element is found.

                                              Parameter iteratee

                                              The truth test to apply.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              True if any element passed the truth test, otherwise false.

                                            method sortBy

                                            sortBy: (iteratee?: Iteratee<V, any>, context?: any) => T[];
                                            • Returns a (stably) sorted copy of the wrapped collection, ranked in ascending order by the results of running each value through iteratee.

                                              Parameter iteratee

                                              An iteratee that provides the value to sort by for each item in the wrapped collection.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              A sorted copy of the wrapped collection.

                                            method sortedIndex

                                            sortedIndex: (
                                            value: T,
                                            iteratee?: Iteratee<V | undefined, any>,
                                            context?: any
                                            ) => number;
                                            • Uses a binary search to determine the lowest index at which the value should be inserted into the wrapped list in order to maintain the wrapped list's sorted order. If an iteratee is provided, it will be used to compute the sort ranking of each value, including the value you pass.

                                              Parameter value

                                              The value to determine an insert index for to mainain the sorting in the wrapped list.

                                              Parameter iteratee

                                              Iteratee to compute the sort ranking of each element including value, optional.

                                              Parameter context

                                              this object in iteratee, optional.

                                              Returns

                                              The index where value should be inserted into the wrapped list.

                                            method tap

                                            tap: (interceptor: (...as: any[]) => any) => any;
                                            • Wrapped type object.

                                              See Also

                                              • _.tap

                                            method template

                                            template: (settings?: _.TemplateSettings) => CompiledTemplate;
                                            • Wrapped type string.

                                              See Also

                                              • _.template

                                            method throttle

                                            throttle: (
                                            wait: number,
                                            options?: _.ThrottleSettings
                                            ) => Function & _.Cancelable;
                                            • Wrapped type Function.

                                              See Also

                                              • _.throttle

                                            method times

                                            times: <TResult>(iterator: (n: number) => TResult, context?: any) => TResult[];
                                            • Wrapped type number.

                                              See Also

                                              • _.times

                                            method toArray

                                            toArray: () => T[];
                                            • Creates a real Array from the wrapped collection (anything that can be iterated over). Useful for transmuting the arguments object.

                                              Returns

                                              An array containing the elements of the wrapped collection.

                                            method transpose

                                            transpose: () => any[][];

                                              method unescape

                                              unescape: () => string;
                                              • Wrapped type string.

                                                See Also

                                                • _.unescape

                                              method union

                                              union: (...lists: List<T>[]) => T[];
                                              • Computes the union of the wrapped list and the passed-in lists: the list of unique items, examined in order from first list to last list, that are present in one or more of the lists.

                                                Parameter lists

                                                The lists (along with the wrapped list) to compute the union of.

                                                Returns

                                                The union of elements within the wrapped list and lists.

                                              method uniq

                                              uniq: {
                                              (isSorted?: boolean, iteratee?: Iteratee<V, any>, cotext?: any): T[];
                                              (
                                              iteratee?: Iteratee<V, any, TypeOfCollection<V, never>>,
                                              context?: any
                                              ): T[];
                                              };
                                              • Produces a duplicate-free version of the wrapped list, using === to test object equality. If you know in advance that the wrapped list is sorted, passing true for isSorted will run a much faster algorithm. If you want to compute unique items based on a transformation, pass an iteratee function.

                                                Parameter isSorted

                                                True if the wrapped list is already sorted, optional, default = false.

                                                Parameter iteratee

                                                Transform the elements of the wrapped list before comparisons for uniqueness.

                                                Parameter context

                                                'this' object in iteratee, optional.

                                                Returns

                                                An array containing only the unique elements in the wrapped list.

                                              method uniqueId

                                              uniqueId: () => string;
                                              • Wrapped type string.

                                                See Also

                                                • _.uniqueId

                                              method unzip

                                              unzip: () => any[][];
                                              • The opposite of zip. Given the wrapped list of lists, returns a series of new arrays, the first of which contains all of the first elements in the wrapped lists, the second of which contains all of the second elements, and so on. (alias: transpose)

                                                Returns

                                                The unzipped version of the wrapped lists.

                                              method value

                                              value: () => V;
                                              • Extracts the value of the wrapped object.

                                                Returns

                                                The value of the wrapped object.

                                              method values

                                              values: () => T[];
                                              • Wrapped type object.

                                                See Also

                                                • _.values

                                              method where

                                              where: (properties: Partial<T>) => T[];
                                              • Looks through each value in the wrapped collection, returning an array of all the elements that match the key-value pairs listed in properties.

                                                Parameter properties

                                                The properties to check for on the elements within the wrapped collection.

                                                Returns

                                                The elements in the wrapped collection that match properties.

                                              method without

                                              without: (...values: T[]) => T[];
                                              • Returns a copy of the wrapped list with all instances of values removed.

                                                Parameter values

                                                The values to exclude from the wrapped list.

                                                Returns

                                                An array that contains all elements of the wrapped list except for values.

                                              method wrap

                                              wrap: (wrapper: Function) => () => Function;
                                              • Wrapped type Function.

                                                See Also

                                                • _.wrap

                                              method zip

                                              zip: (...lists: List<any>[]) => any[][];
                                              • Merges together the values of each of the lists (including the wrapped list) with the values at the corresponding position. Useful when you have separate data sources that are coordinated through matching list indexes.

                                                Returns

                                                The zipped version of the wrapped list and lists.

                                              interface UnderscoreStatic

                                              interface UnderscoreStatic {}

                                                property all

                                                all: UnderscoreStatic['every'];
                                                • See Also

                                                  • every

                                                property any

                                                any: UnderscoreStatic['some'];
                                                • See Also

                                                  • some

                                                property collect

                                                collect: UnderscoreStatic['map'];
                                                • See Also

                                                  • map

                                                property detect

                                                detect: UnderscoreStatic['find'];
                                                • See Also

                                                  • find

                                                property drop

                                                drop: UnderscoreStatic['rest'];
                                                • See Also

                                                  • rest

                                                property foldl

                                                foldl: UnderscoreStatic['reduce'];
                                                • See Also

                                                  • reduce

                                                property foldr

                                                foldr: UnderscoreStatic['reduceRight'];
                                                • See Also

                                                  • reduceRight

                                                property forEach

                                                forEach: UnderscoreStatic['each'];
                                                • See Also

                                                  • each

                                                property head

                                                head: UnderscoreStatic['first'];
                                                • See Also

                                                  • first

                                                property include

                                                include: UnderscoreStatic['contains'];
                                                • See Also

                                                  • contains

                                                property includes

                                                includes: UnderscoreStatic['contains'];
                                                • See Also

                                                  • contains

                                                property inject

                                                inject: UnderscoreStatic['reduce'];
                                                • See Also

                                                  • reduce

                                                property select

                                                select: UnderscoreStatic['filter'];
                                                • See Also

                                                  • filter

                                                property tail

                                                tail: UnderscoreStatic['rest'];
                                                • See Also

                                                  • rest

                                                property take

                                                take: UnderscoreStatic['first'];
                                                • See Also

                                                  • first

                                                property templateSettings

                                                templateSettings: _.TemplateSettings;
                                                • By default, Underscore uses ERB-style template delimiters, change the following template settings to use alternative delimiters.

                                                property unique

                                                unique: UnderscoreStatic['uniq'];
                                                • See Also

                                                  • uniq

                                                property VERSION

                                                readonly VERSION: string;
                                                • Current version

                                                method after

                                                after: (count: number, fn: Function) => Function;
                                                • Creates a version of the function that will only be run after first being called count times. Useful for grouping asynchronous responses, where you want to be sure that all the async calls have finished, before proceeding.

                                                  Parameter number

                                                  count Number of times to be called before actually executing.

                                                  Parameter Function

                                                  fn The function to defer execution count times. Copy of fn that will not execute until it is invoked count times.

                                                method allKeys

                                                allKeys: (object: any) => string[];
                                                • Retrieve all the names of object's own and inherited properties.

                                                  Parameter object

                                                  Retrieve the key or property names from this object. List of all the property names on object.

                                                method assign

                                                assign: (destination: any, ...source: any[]) => any;
                                                • Like extend, but only copies own properties over to the destination object. (alias: extendOwn)

                                                method before

                                                before: (count: number, fn: Function) => Function;
                                                • Creates a version of the function that can be called no more than count times. The result of the last function call is memoized and returned when count has been reached.

                                                  Parameter number

                                                  count The maxmimum number of times the function can be called.

                                                  Parameter Function

                                                  fn The function to limit the number of times it can be called. Copy of fn that can only be called count times.

                                                method bind

                                                bind: (func: Function, context: any, ...args: any[]) => () => any;
                                                • Bind a function to an object, meaning that whenever the function is called, the value of this will be the object. Optionally, bind arguments to the function to pre-fill them, also known as partial application.

                                                  Parameter func

                                                  The function to bind this to object.

                                                  Parameter context

                                                  The this pointer whenever fn is called.

                                                  Parameter arguments

                                                  Additional arguments to pass to fn when called. fn with this bound to object.

                                                method bindAll

                                                bindAll: (object: any, ...methodNames: string[]) => any;
                                                • Binds a number of methods on the object, specified by methodNames, to be run in the context of that object whenever they are invoked. Very handy for binding functions that are going to be used as event handlers, which would otherwise be invoked with a fairly useless this. If no methodNames are provided, all of the object's function properties will be bound to it.

                                                  Parameter object

                                                  The object to bind the methods methodName to.

                                                  Parameter methodNames

                                                  The methods to bind to object, optional and if not provided all of object's methods are bound.

                                                method chain

                                                chain: <V>(value: V) => _Chain<TypeOfCollection<V>, V>;
                                                • Returns a wrapped object. Calling methods on this object will continue to return wrapped objects until value() is used.

                                                  Parameter value

                                                  The object to chain.

                                                  Returns

                                                  An underscore chain wrapper around the supplied value.

                                                method chunk

                                                chunk: <V extends List<any>>(list: V, length: number) => TypeOfList<V>[][];
                                                • Chunks list into multiple arrays, each containing length or fewer items.

                                                  Parameter list

                                                  The list to chunk.

                                                  Parameter length

                                                  The maximum size of the chunks.

                                                  Returns

                                                  The contents of list in chunks no greater than length in size.

                                                method clone

                                                clone: <T>(object: T) => T;
                                                • Create a shallow-copied clone of the object. Any nested objects or arrays will be copied by reference, not duplicated.

                                                  Parameter object

                                                  Object to clone. Copy of object.

                                                method compact

                                                compact: <V extends List<any>>(list: V) => Truthy<TypeOfList<V>>[];
                                                • Returns a copy of list with all falsy values removed. In JavaScript, false, null, 0, "", undefined and NaN are all falsy.

                                                  Parameter list

                                                  The list to compact.

                                                  Returns

                                                  An array containing the elements of list without falsy values.

                                                method compose

                                                compose: (...functions: Function[]) => Function;
                                                • Returns the composition of a list of functions, where each function consumes the return value of the function that follows. In math terms, composing the functions f(), g(), and h() produces f(g(h())).

                                                  Parameter functions

                                                  List of functions to compose. Composition of functions.

                                                method constant

                                                constant: <T>(value: T) => () => T;
                                                • Creates a function that returns the same value that is used as the argument of _.constant

                                                  Parameter value

                                                  Identity of this object. Function that return value.

                                                method contains

                                                contains: <V extends Collection<any>>(
                                                collection: V,
                                                value: any,
                                                fromIndex?: number
                                                ) => boolean;
                                                • Returns true if the value is present in collection. Uses indexOf internally, if collection is a List. Use fromIndex to start your search at a given index.

                                                  Parameter collection

                                                  The collection to check for value.

                                                  Parameter value

                                                  The value to check collection for.

                                                  Parameter fromIndex

                                                  The index to start searching from, optional, default = 0, only used when collection is a List.

                                                  Returns

                                                  True if value is present in collection after fromIndex, otherwise false.

                                                method countBy

                                                countBy: <V extends Collection<any>>(
                                                collection: V,
                                                iteratee?: Iteratee<V, string | number>,
                                                context?: any
                                                ) => Dictionary<number>;
                                                • Sorts collection into groups and returns a count for the number of objects in each group. Similar to groupBy, but instead of returning a list of values, returns a count for the number of values in that group.

                                                  Parameter collection

                                                  The collection to count.

                                                  Parameter iteratee

                                                  An iteratee that provides the value to count by for each item in collection.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  A dictionary with the group names provided by iteratee as properties where each property contains the count of the grouped elements from collection.

                                                method create

                                                create: (prototype: any, props?: object) => any;
                                                • Creates an object that inherits from the given prototype object. If additional properties are provided then they will be added to the created object.

                                                  Parameter prototype

                                                  The prototype that the returned object will inherit from.

                                                  Parameter props

                                                  Additional props added to the returned object.

                                                method debounce

                                                debounce: <T extends Function>(
                                                fn: T,
                                                wait: number,
                                                immediate?: boolean
                                                ) => T & _.Cancelable;
                                                • Creates and returns a new debounced version of the passed function that will postpone its execution until after wait milliseconds have elapsed since the last time it was invoked. Useful for implementing behavior that should only happen after the input has stopped arriving. For example: rendering a preview of a Markdown comment, recalculating a layout after the window has stopped being resized, and so on.

                                                  Pass true for the immediate parameter to cause debounce to trigger the function on the leading instead of the trailing edge of the wait interval. Useful in circumstances like preventing accidental double -clicks on a "submit" button from firing a second time.

                                                  Parameter fn

                                                  Function to debounce waitMS ms.

                                                  Parameter wait

                                                  The number of milliseconds to wait before fn can be invoked again.

                                                  Parameter immediate

                                                  True if fn should be invoked on the leading edge of waitMS instead of the trailing edge. Debounced version of fn that waits wait ms when invoked.

                                                method defaults

                                                defaults: (object: any, ...defaults: any[]) => any;
                                                • Fill in null and undefined properties in object with values from the defaults objects, and return the object. As soon as the property is filled, further defaults will have no effect.

                                                  Parameter object

                                                  Fill this object with default values.

                                                  Parameter defaults

                                                  The default values to add to object. object with added defaults values.

                                                method defer

                                                defer: (fn: Function, ...args: any[]) => void;
                                                • Defers invoking the function until the current call stack has cleared, similar to using setTimeout with a delay of 0. Useful for performing expensive computations or HTML rendering in chunks without blocking the UI thread from updating. If you pass the optional arguments, they will be forwarded on to the function when it is invoked.

                                                  Parameter fn

                                                  The function to defer.

                                                  Parameter arguments

                                                  Additional arguments to pass to fn.

                                                method delay

                                                delay: {
                                                (func: Function, wait: number, ...args: any[]): any;
                                                (func: Function, ...args: any[]): any;
                                                };
                                                • Much like setTimeout, invokes function after wait milliseconds. If you pass the optional arguments, they will be forwarded on to the function when it is invoked.

                                                  Parameter func

                                                  Function to delay waitMS amount of ms.

                                                  Parameter wait

                                                  The amount of milliseconds to delay fn. Additional arguments to pass to fn.

                                                • See Also

                                                  • _delay

                                                method difference

                                                difference: <T>(list: List<T>, ...others: List<T>[]) => T[];
                                                • Similar to without, but returns the values from list that are not present in others.

                                                  Parameter list

                                                  The starting list.

                                                  Parameter others

                                                  The lists of values to exclude from list.

                                                  Returns

                                                  The contents of list without the values in others.

                                                method each

                                                each: <V extends Collection<any>>(
                                                collection: V,
                                                iteratee: CollectionIterator<TypeOfCollection<V>, void, V>,
                                                context?: any
                                                ) => V;
                                                • Iterates over a collection of elements, yielding each in turn to an iteratee. The iteratee is bound to the context object, if one is passed.

                                                  Parameter collection

                                                  The collection of elements to iterate over.

                                                  Parameter iteratee

                                                  The iteratee to call for each element in collection.

                                                  Parameter context

                                                  'this' object in iteratee, optional.

                                                  Returns

                                                  The original collection.

                                                method escape

                                                escape: (str: string) => string;
                                                • Escapes a string for insertion into HTML, replacing &, <, >, ", ', and / characters.

                                                  Parameter str

                                                  Raw string to escape. str HTML escaped.

                                                method every

                                                every: <V extends Collection<any>>(
                                                collection: V,
                                                iteratee?: Iteratee<V, boolean>,
                                                context?: any
                                                ) => boolean;
                                                • Returns true if all of the values in collection pass the iteratee truth test. Short-circuits and stops traversing collection if a false element is found.

                                                  Parameter collection

                                                  The collection to evaluate.

                                                  Parameter iteratee

                                                  The truth test to apply.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  True if all elements pass the truth test, otherwise false.

                                                method extend

                                                extend: (destination: any, ...sources: any[]) => any;
                                                • Copy all of the properties in the source objects over to the destination object, and return the destination object. It's in-order, so the last source will override properties of the same name in previous arguments.

                                                  Parameter destination

                                                  Object to extend all the properties from sources.

                                                  Parameter sources

                                                  Extends destination with all properties from these source objects. destination extended with all the properties from the sources objects.

                                                method extendOwn

                                                extendOwn: (destination: any, ...source: any[]) => any;
                                                • Like extend, but only copies own properties over to the destination object. (alias: assign)

                                                method filter

                                                filter: <V extends Collection<any>>(
                                                collection: V,
                                                iteratee?: Iteratee<V, boolean>,
                                                context?: any
                                                ) => TypeOfCollection<V>[];
                                                • Looks through each value in collection, returning an array of all the values that pass a truth test (iteratee).

                                                  Parameter collection

                                                  The collection to filter.

                                                  Parameter iteratee

                                                  The truth test to apply.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  The set of values that pass the truth test.

                                                method find

                                                find: <V extends Collection<any>>(
                                                collection: V,
                                                iteratee?: Iteratee<V, boolean>,
                                                context?: any
                                                ) => TypeOfCollection<V> | undefined;
                                                • Looks through each value in collection, returning the first one that passes a truth test (iteratee), or undefined if no value passes the test. The function returns as soon as it finds an acceptable element, and doesn't traverse the entire collection.

                                                  Parameter collection

                                                  The collection to search.

                                                  Parameter iteratee

                                                  The truth test to apply.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  The first element in collection that passes the truth test or undefined if no elements pass.

                                                method findIndex

                                                findIndex: <V extends List<any>>(
                                                list: V,
                                                iteratee?: Iteratee<V, boolean>,
                                                context?: any
                                                ) => number;
                                                • Returns the first index of an element in list where the iteratee truth test passes, otherwise returns -1.

                                                  Parameter list

                                                  The list to search for the index of the first element that passes the truth test.

                                                  Parameter iteratee

                                                  The truth test to apply.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  The index of the first element in list where the truth test passes or -1 if no elements pass.

                                                method findKey

                                                findKey: <V extends object>(
                                                object: V,
                                                iteratee?: Iteratee<V, boolean, TypeOfCollection<V, any>>,
                                                context?: any
                                                ) => Extract<keyof V, string> | undefined;
                                                • Similar to findIndex but for keys in objects. Returns the key where the iteratee truth test passes or undefined.

                                                  Parameter object

                                                  The object to search.

                                                  Parameter iteratee

                                                  The truth test to apply.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  The first element in object that passes the truth test or undefined if no elements pass.

                                                method findLastIndex

                                                findLastIndex: <V extends List<any>>(
                                                list: V,
                                                iteratee?: Iteratee<V, boolean>,
                                                context?: any
                                                ) => number;
                                                • Returns the last index of an element in list where the iteratee truth test passes, otherwise returns -1.

                                                  Parameter list

                                                  The list to search for the index of the last element that passes the truth test.

                                                  Parameter iteratee

                                                  The truth test to apply.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  The index of the last element in list where the truth test passes or -1 if no elements pass.

                                                method findWhere

                                                findWhere: <V extends Collection<any>>(
                                                collection: V,
                                                properties: Partial<TypeOfCollection<V>>
                                                ) => TypeOfCollection<V> | undefined;
                                                • Looks through collection and returns the first value that matches all of the key-value pairs listed in properties. If no match is found, or if list is empty, undefined will be returned.

                                                  Parameter collection

                                                  The collection in which to find an element that matches properties.

                                                  Parameter properties

                                                  The properties to check for on the elements within collection.

                                                  Returns

                                                  The first element in collection that matches properties or undefined if no match is found.

                                                method first

                                                first: {
                                                <V extends List<any>>(list: V): TypeOfList<V> | undefined;
                                                <V extends List<any>>(list: V, n: number): TypeOfList<V>[];
                                                };
                                                • Returns the first element of list. Passing n will return the first n elements of list.

                                                  Parameter list

                                                  The list to retrieve elements from.

                                                  Parameter n

                                                  The number of elements to retrieve, optional.

                                                  Returns

                                                  The first n elements of list or the first element if n is omitted.

                                                method flatten

                                                flatten: {
                                                <V extends List<any>>(list: V, depth: 1 | true): ListItemOrSelf<
                                                TypeOfList<V>
                                                >[];
                                                <V extends List<any>>(
                                                list: V,
                                                depth?: number | false
                                                ): DeepestListItemOrSelf<TypeOfList<V>>[];
                                                };
                                                • Flattens a nested list (the nesting can be to any depth). If you pass true or 1 as the depth, the list will only be flattened a single level. Passing a greater number will cause the flattening to descend deeper into the nesting hierarchy. Omitting the depth argument, or passing false or Infinity, flattens the list all the way to the deepest nesting level.

                                                  Parameter list

                                                  The list to flatten.

                                                  Parameter depth

                                                  True to only flatten one level, optional, default = false.

                                                  Returns

                                                  The flattened list.

                                                method functions

                                                functions: (object: any) => string[];
                                                • Returns a sorted list of the names of every method in an object - that is to say, the name of every function property of the object.

                                                  Parameter object

                                                  Object to pluck all function property names from. List of all the function names on object.

                                                method get

                                                get: {
                                                (object: null | undefined, path: string | string[]): undefined;
                                                <U>(object: null, path: string | string[], defaultValue?: U): U;
                                                <V extends Collection<any>>(
                                                object: V,
                                                path: string | string[]
                                                ): TypeOfCollection<V, never>;
                                                <V extends Collection<any>, U>(
                                                object: V,
                                                path: string | string[],
                                                defaultValue?: U
                                                ): U | TypeOfCollection<V, never>;
                                                };
                                                • Returns the specified property of object. path may be specified as a simple key, or as an array of object keys or array indexes, for deep property fetching. If the property does not exist or is undefined, the optional default is returned.

                                                  Parameter object

                                                  The object that maybe contains the property.

                                                  Parameter path

                                                  The path to the property on object.

                                                  Parameter defaultValue

                                                  Default if not found.

                                                  Returns

                                                  The item on the object or the defaultValue

                                                method groupBy

                                                groupBy: <V extends Collection<any>>(
                                                collection: V,
                                                iteratee?: Iteratee<V, string | number>,
                                                context?: any
                                                ) => Dictionary<TypeOfCollection<V>[]>;
                                                • Splits collection into sets that are grouped by the result of running each value through iteratee.

                                                  Parameter collection

                                                  The collection to group.

                                                  Parameter iteratee

                                                  An iteratee that provides the value to group by for each item in collection.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  A dictionary with the group names provided by iteratee as properties where each property contains the grouped elements from collection.

                                                method has

                                                has: (object: any, key: string) => boolean;
                                                • Does the object contain the given key? Identical to object.hasOwnProperty(key), but uses a safe reference to the hasOwnProperty function, in case it's been overridden accidentally.

                                                  Parameter object

                                                  Object to check for key.

                                                  Parameter key

                                                  The key to check for on object. True if key is a property on object, otherwise false.

                                                method identity

                                                identity: <T>(value: T) => T;
                                                • Returns the same value that is used as the argument. In math: f(x) = x This function looks useless, but is used throughout Underscore as a default iterator.

                                                  Parameter value

                                                  Identity of this object. value.

                                                method indexBy

                                                indexBy: <V extends Collection<any>>(
                                                collection: V,
                                                iteratee?: Iteratee<V, string | number>,
                                                context?: any
                                                ) => Dictionary<TypeOfCollection<V>>;
                                                • Given a collection and an iteratee function that returns a key for each element in collection, returns an object that acts as an index of each item. Just like groupBy, but for when you know your keys are unique.

                                                  Parameter collection

                                                  The collection to index.

                                                  Parameter iteratee

                                                  An iteratee that provides the value to index by for each item in collection.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  A dictionary where each item in collection is assigned to the property designated by iteratee.

                                                method indexOf

                                                indexOf: <V extends List<any>>(
                                                list: V,
                                                value: TypeOfList<V>,
                                                isSortedOrFromIndex?: boolean | number
                                                ) => number;
                                                • Returns the index at which value can be found in list, or -1 if value is not present. If you're working with a large list and you know that the list is already sorted, pass true for isSortedOrFromIndex to use a faster binary search...or, pass a number in order to look for the first matching value in the list after the given index.

                                                  Parameter list

                                                  The list to search for the index of value.

                                                  Parameter value

                                                  The value to search for within list.

                                                  Parameter isSortedOrFromIndex

                                                  True if list is already sorted OR the starting index for the search, optional.

                                                  Returns

                                                  The index of the first occurrence of value within list or -1 if value is not found.

                                                method initial

                                                initial: <V extends List<any>>(list: V, n?: number) => TypeOfList<V>[];
                                                • Returns everything but the last entry of list. Especially useful on the arguments object. Pass n to exclude the last n elements from the result.

                                                  Parameter list

                                                  The list to retrieve elements from.

                                                  Parameter n

                                                  The number of elements from the end of list to omit, optional, default = 1.

                                                  Returns

                                                  The elements of list with the last n items omitted.

                                                method intersection

                                                intersection: <T>(...lists: List<T>[]) => T[];
                                                • Computes the list of values that are the intersection of the passed-in lists. Each value in the result is present in each of the lists.

                                                  Parameter lists

                                                  The lists to compute the intersection of.

                                                  Returns

                                                  The intersection of elements within the lists.

                                                method invert

                                                invert: (object: any) => any;
                                                • Returns a copy of the object where the keys have become the values and the values the keys. For this to work, all of your object's values should be unique and string serializable.

                                                  Parameter object

                                                  Object to invert key/value pairs. An inverted key/value paired version of object.

                                                method invoke

                                                invoke: (list: Collection<any>, methodName: string, ...args: any[]) => any[];
                                                • Calls the method named by methodName on each value in collection. Any extra arguments passed to invoke will be forwarded on to the method invocation.

                                                  Parameter collection

                                                  The collection of elements to invoke methodName on.

                                                  Parameter methodName

                                                  The name of the method to call on each element in collection.

                                                  Parameter args

                                                  Additional arguments to pass to method methodName.

                                                  Returns

                                                  An array containing the result of the method call for each item in collection.

                                                method isArguments

                                                isArguments: (object: any) => object is IArguments;
                                                • Returns true if object is an Arguments object.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is an Arguments object, otherwise false.

                                                method isArray

                                                isArray: (object: any) => object is any[];
                                                • Returns true if object is an Array.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is an Array, otherwise false.

                                                method isArrayBuffer

                                                isArrayBuffer: (object: any) => object is ArrayBuffer;
                                                • Returns true if object is an ArrayBuffer.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is an ArrayBuffer, otherwise false.

                                                method isBoolean

                                                isBoolean: (object: any) => object is boolean;
                                                • Returns true if object is a Boolean.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is a Boolean, otherwise false.

                                                method isDataView

                                                isDataView: (object: any) => object is DataView;
                                                • Returns true if object is a DataView.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is a DataView, otherwise false.

                                                method isDate

                                                isDate: (object: any) => object is Date;
                                                • Returns true if object is a Date.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is a Date, otherwise false.

                                                method isElement

                                                isElement: (object: any) => object is Element;
                                                • Returns true if object is a DOM element.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is a DOM element, otherwise false.

                                                method isEmpty

                                                isEmpty: (collection: any) => boolean;
                                                • Returns true if collection contains no values. For strings and array-like objects checks if the length property is 0.

                                                  Parameter collection

                                                  The collection to check.

                                                  Returns

                                                  True if collection has no elements.

                                                method isEqual

                                                isEqual: (object: any, other: any) => boolean;
                                                • Performs an optimized deep comparison between object and other to determine if they should be considered equal.

                                                  Parameter object

                                                  Compare to other.

                                                  Parameter other

                                                  Compare to object.

                                                  Returns

                                                  True if object should be considered equal to other.

                                                method isError

                                                isError: (object: any) => object is Error;
                                                • Returns true if object is an Error.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is a Error, otherwise false.

                                                method isFinite

                                                isFinite: (object: any) => boolean;
                                                • Returns true if object is a finite Number.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is a finite Number.

                                                method isFunction

                                                isFunction: (object: any) => object is Function;
                                                • Returns true if object is a Function.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is a Function, otherwise false.

                                                method isMatch

                                                isMatch: (object: any, properties: any) => boolean;
                                                • Returns true if the keys and values in properties are contained in object.

                                                  Parameter object

                                                  The object to check.

                                                  Parameter properties

                                                  The properties to check for in object.

                                                  Returns

                                                  True if all keys and values in properties are also in object.

                                                method isNaN

                                                isNaN: (object: any) => boolean;
                                                • Returns true if object is NaN. Note: this is not the same as the native isNaN function, which will also return true if the variable is undefined.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is NaN, otherwise false.

                                                method isNull

                                                isNull: (object: any) => object is null;
                                                • Returns true if object is null.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is null, otherwise false.

                                                method isNumber

                                                isNumber: (object: any) => object is number;
                                                • Returns true if object is a Number (including NaN).

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is a Number, otherwise false.

                                                method isObject

                                                isObject: (object: any) => object is Dictionary<any> & object;
                                                • Returns true if object is an Object. Note that JavaScript arrays and functions are objects, while (normal) strings and numbers are not.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is an Object, otherwise false.

                                                method isRegExp

                                                isRegExp: (object: any) => object is RegExp;
                                                • Returns true if object is a RegExp.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is a RegExp, otherwise false.

                                                method isString

                                                isString: (object: any) => object is string;
                                                • Returns true if object is a String.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is a String, otherwise false.

                                                method isSymbol

                                                isSymbol: (object: any) => object is symbol;
                                                • Returns true if object is a Symbol.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is a Symbol, otherwise false.

                                                method isTypedArray

                                                isTypedArray: (object: any) => object is TypedArray;
                                                • Returns true if object is a TypedArray.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is a TypedArray, otherwise false.

                                                method isUndefined

                                                isUndefined: (object: any) => object is undefined;
                                                • Returns true if object is undefined.

                                                  Parameter object

                                                  The object to check.

                                                  Returns

                                                  True if object is undefined, otherwise false.

                                                method iteratee

                                                iteratee: {
                                                (value: string): Function;
                                                (value: Function, context?: any): Function;
                                                (value: object): Function;
                                                };
                                                • A mostly-internal function to generate callbacks that can be applied to each element in a collection, returning the desired result -- either identity, an arbitrary callback, a property matcher, or a propetery accessor.

                                                  Parameter string

                                                  |Function|Object value The value to iterate over, usually the key.

                                                  Parameter any

                                                  context Callback that can be applied to each element in a collection.

                                                method keys

                                                keys: (object: any) => string[];
                                                • Retrieve all the names of the object's properties.

                                                  Parameter object

                                                  Retrieve the key or property names from this object. List of all the property names on object.

                                                method last

                                                last: {
                                                <V extends List<any>>(list: V): TypeOfList<V> | undefined;
                                                <V extends List<any>>(list: V, n: number): TypeOfList<V>[];
                                                };
                                                • Returns the last element of list. Passing n will return the last n elements of list.

                                                  Parameter list

                                                  The list to retrieve elements from.

                                                  Parameter n

                                                  The number of elements to retrieve, optional.

                                                  Returns

                                                  The last n elements of list or the last element if n is omitted.

                                                method lastIndexOf

                                                lastIndexOf: <V extends List<any>>(
                                                list: V,
                                                value: TypeOfList<V>,
                                                fromIndex?: number
                                                ) => number;
                                                • Returns the index of the last occurrence of value in list, or -1 if value is not present. Pass fromIndex to start your search at a given index.

                                                  Parameter list

                                                  The list to search for the last occurrence of value.

                                                  Parameter value

                                                  The value to search for within list.

                                                  Parameter fromIndex

                                                  The starting index for the search, optional.

                                                  Returns

                                                  The index of the last occurrence of value within list or -1 if value is not found.

                                                method map

                                                map: <
                                                V extends Collection<any>,
                                                I extends Iteratee<V, any, TypeOfCollection<V, never>>
                                                >(
                                                collection: V,
                                                iteratee: I,
                                                context?: any
                                                ) => IterateeResult<I, TypeOfCollection<V>>[];
                                                • Produces a new array of values by mapping each value in collection through a transformation iteratee.

                                                  Parameter collection

                                                  The collection to transform.

                                                  Parameter iteratee

                                                  The iteratee to use to transform each item in collection.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  The mapped result.

                                                method mapObject

                                                mapObject: <
                                                V extends object,
                                                I extends Iteratee<V, any, TypeOfCollection<V, any>>
                                                >(
                                                object: V,
                                                iteratee: I,
                                                context?: any
                                                ) => { [K in keyof V]: IterateeResult<I, V[K]> };
                                                • Like map, but for objects. Transform the value of each property in turn.

                                                  Parameter object

                                                  The object to transform.

                                                  Parameter iteratee

                                                  The iteratee to use to transform property values.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  A new object with all of object's property values transformed through iteratee.

                                                method matcher

                                                matcher: <T>(attrs: T) => _.Predicate<T>;
                                                • Returns a predicate function that will tell you if a passed in object contains all of the key/value properties present in attrs.

                                                  Parameter attrs

                                                  Object with key values pair Predicate function

                                                  See Also

                                                  • _.matches

                                                method matches

                                                matches: <T>(attrs: T) => _.Predicate<T>;
                                                • Returns a predicate function that will tell you if a passed in object contains all of the key/value properties present in attrs.

                                                  Parameter attrs

                                                  Object with key values pair Predicate function

                                                method max

                                                max: <V extends Collection<any>>(
                                                collection: V,
                                                iteratee?: Iteratee<V, any>,
                                                context?: any
                                                ) => TypeOfCollection<V> | number;
                                                • Returns the maximum value in collection. If an iteratee is provided, it will be used on each element to generate the criterion by which the element is ranked. -Infinity is returned if list is empty. Non-numerical values returned by iteratee will be ignored.

                                                  Parameter collection

                                                  The collection in which to find the maximum value.

                                                  Parameter iteratee

                                                  The iteratee that provides the criterion by which each element is ranked, optional if evaluating a collection of numbers.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  The maximum element within collection or -Infinity if collection is empty.

                                                method memoize

                                                memoize: <T = Function>(fn: T, hashFn?: (...args: any[]) => string) => T;
                                                • Memoizes a given function by caching the computed result. Useful for speeding up slow-running computations. If passed an optional hashFunction, it will be used to compute the hash key for storing the result, based on the arguments to the original function. The default hashFunction just uses the first argument to the memoized function as the key.

                                                  Parameter fn

                                                  Computationally expensive function that will now memoized results.

                                                  Parameter hashFn

                                                  Hash function for storing the result of fn. Memoized version of fn.

                                                method methods

                                                methods: (object: any) => string[];
                                                • See Also

                                                  • _functions

                                                method min

                                                min: <V extends Collection<any>>(
                                                list: V,
                                                iteratee?: Iteratee<V, any>,
                                                context?: any
                                                ) => TypeOfCollection<V> | number;
                                                • Returns the minimum value in collection. If an iteratee is provided, it will be used on each element to generate the criterion by which the element is ranked. Infinity is returned if list is empty. Non-numerical values returned by iteratee will be ignored.

                                                  Parameter collection

                                                  The collection in which to find the minimum value.

                                                  Parameter iteratee

                                                  The iteratee that provides the criterion by which each element is ranked, optional if evaluating a collection of numbers.

                                                  Parameter context

                                                  this object in iteratee, optional.

                                                  Returns

                                                  The minimum element within collection or Infinity if collection is empty.

                                                method mixin

                                                mixin: (object: any) => void;
                                                • Allows you to extend Underscore with your own utility functions. Pass a hash of {name: function} definitions to have your functions added to the Underscore object, as well as the OOP wrapper.

                                                  Parameter object

                                                  Mixin object containing key/function pairs to add to the Underscore object.

                                                method negate

                                                negate: (predicate: (...args: any[]) => boolean) => (...args: any[]) => boolean;
                                                • Returns a negated version of the pass-in predicate.

                                                  Parameter

                                                  (...args: any[]) => boolean predicate (...args: any[]) => boolean

                                                method noConflict

                                                noConflict: () => any;
                                                • Give control of the "_" variable back to its previous owner. Returns a reference to the Underscore object. Underscore object reference.

                                                method noop

                                                noop: () => void;
                                                • Returns undefined irrespective of the arguments passed to it. Useful as the default for optional callback arguments. Note there is no way to indicate a 'undefined' return, so it is currently typed as void. undefined

                                                method now

                                                now: () => number;
                                                • Returns an integer timestamp for the current time, using the fastest method available in the runtime. Useful for implementing timing/animation functions.

                                                method object

                                                object: {
                                                <TList extends List<string | number>, TValue>(
                                                list: TList,
                                                values: List<TValue>
                                                ): Dictionary<TValue | undefined>;
                                                <TList extends List<List<any>>>(list: TList): Dictionary<
                                                PairValue<TypeOfList<TList>>
                                                >;
                                                };
                                                • Converts lists into objects. Pass either a single list of [key, value] pairs, or a list of keys and a list of values. Passing by pairs is the reverse of pairs. If duplicate keys exist, the last value wins.

                                                  Parameter list

                                                  A list of [key, value] pairs or a list of keys.

                                                  Parameter values

                                                  If list is a list of keys, a list of values corresponding to those keys.

                                                  Returns

                                                  An object comprised of the provided keys and values.

                                                method omit

                                                omit: {
                                                <V, K extends string>(object: V, ...keys: (K | K[])[]): _Omit<V, K>;
                                                <V>(
                                                object: V,
                                                iterator: ObjectIterator<TypeOfDictionary<V, any>, boolean, V>
                                                ): Partial<V>;
                                                };
                                                • Return a copy of object that is filtered to omit the disallowed keys (or array of keys).

                                                  Parameter object

                                                  The object to omit specific keys from.

                                                  Parameter keys

                                                  The keys to omit from object.

                                                  Returns

                                                  A copy of object without the keys properties.

                                                • Return a copy of object that is filtered to not have values for the keys selected by a truth test.

                                                  Parameter object

                                                  The object to omit specific keys from.

                                                  Parameter iterator

                                                  A truth test that selects the keys to omit from object.

                                                  Returns

                                                  A copy of object without the keys selected by iterator.

                                                method once

                                                once: <T extends Function>(fn: T) => T;
                                                • Creates a version of the function that can only be called one time. Repeated calls to the modified function will have no effect, returning the value from the original call. Useful for initialization functions, instead of having to set a boolean flag and then check it later.

                                                  Parameter fn

                                                  Function to only execute once. Copy of fn that can only be invoked once.

                                                method pairs

                                                pairs: <V extends object>(
                                                object: V
                                                ) => [Extract<keyof V, string>, TypeOfCollection<V, any>][];
                                                • Converts object into a list of [key, value] pairs. The opposite of the single-argument signature of _.object.

                                                  Parameter object

                                                  The object to convert.

                                                  Returns

                                                  The list of [key, value] pairs from object.

                                                method partial

                                                partial: {
                                                <T1, T2>(fn: (p1: T1) => T2, p1: T1): { (): T2 };
                                                <T1, T2, T3>(fn: (p1: T1, p2: T2) => T3, p1: T1): (p2: T2) => T3;
                                                <T1, T2, T3>(fn: (p1: T1, p2: T2) => T3, p1: T1, p2: T2): () => T3;
                                                <T1, T2, T3>(fn: (p1: T1, p2: T2) => T3, stub1: UnderscoreStatic, p2: T2): (
                                                p1: T1
                                                ) => T3;
                                                <T1, T2, T3, T4>(fn: (p1: T1, p2: T2, p3: T3) => T4, p1: T1): (
                                                p2: T2,
                                                p3: T3
                                                ) => T4;
                                                <T1, T2, T3, T4>(fn: (p1: T1, p2: T2, p3: T3) => T4, p1: T1, p2: T2): (
                                                p3: T3
                                                ) => T4;
                                                <T1, T2, T3, T4>(
                                                fn: (p1: T1, p2: T2, p3: T3) => T4,
                                                stub1: UnderscoreStatic,
                                                p2: T2
                                                ): (p1: T1, p3: T3) => T4;
                                                <T1, T2, T3, T4>(
                                                fn: (p1: T1, p2: T2, p3: T3) => T4,
                                                p1: T1,
                                                p2: T2,
                                                p3: T3
                                                ): () => T4;
                                                <T1, T2, T3, T4>(
                                                fn: (p1: T1, p2: T2, p3: T3) => T4,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                p3: T3
                                                ): (p1: T1) => T4;
                                                <T1, T2, T3, T4>(
                                                fn: (p1: T1, p2: T2, p3: T3) => T4,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                p3: T3
                                                ): (p2: T2) => T4;
                                                <T1, T2, T3, T4>(
                                                fn: (p1: T1, p2: T2, p3: T3) => T4,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                p3: T3
                                                ): (p1: T1, p2: T2) => T4;
                                                <T1, T2, T3, T4, T5>(fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5, p1: T1): (
                                                p2: T2,
                                                p3: T3,
                                                p4: T4
                                                ) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                p1: T1,
                                                p2: T2
                                                ): (p3: T3, p4: T4) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                stub1: UnderscoreStatic,
                                                p2: T2
                                                ): (p1: T1, p3: T3, p4: T4) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                p1: T1,
                                                p2: T2,
                                                p3: T3
                                                ): (p4: T4) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                p3: T3
                                                ): (p1: T1, p4: T4) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                p3: T3
                                                ): (p2: T2, p4: T4) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                p3: T3
                                                ): (p1: T1, p2: T2, p4: T4) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                p1: T1,
                                                p2: T2,
                                                p3: T3,
                                                p4: T4
                                                ): () => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                p3: T3,
                                                p4: T4
                                                ): (p1: T1) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                p3: T3,
                                                p4: T4
                                                ): (p2: T2) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                p3: T3,
                                                p4: T4
                                                ): (p1: T1, p2: T2) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                p1: T1,
                                                p2: T2,
                                                stub3: UnderscoreStatic,
                                                p4: T4
                                                ): (p3: T3) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                stub3: UnderscoreStatic,
                                                p4: T4
                                                ): (p1: T1, p3: T3) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                stub3: UnderscoreStatic,
                                                p4: T4
                                                ): (p2: T2, p3: T3) => T5;
                                                <T1, T2, T3, T4, T5>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4) => T5,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                stub3: UnderscoreStatic,
                                                p4: T4
                                                ): (p1: T1, p2: T2, p3: T3) => T5;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1
                                                ): (p2: T2, p3: T3, p4: T4, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                p2: T2
                                                ): (p3: T3, p4: T4, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                p2: T2
                                                ): (p1: T1, p3: T3, p4: T4, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                p2: T2,
                                                p3: T3
                                                ): (p4: T4, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                p3: T3
                                                ): (p1: T1, p4: T4, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                p3: T3
                                                ): (p2: T2, p4: T4, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                p3: T3
                                                ): (p1: T1, p2: T2, p4: T4, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                p2: T2,
                                                p3: T3,
                                                p4: T4
                                                ): (p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                p3: T3,
                                                p4: T4
                                                ): (p1: T1, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                p3: T3,
                                                p4: T4
                                                ): (p2: T2, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                p3: T3,
                                                p4: T4
                                                ): (p1: T1, p2: T2, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                p2: T2,
                                                stub3: UnderscoreStatic,
                                                p4: T4
                                                ): (p3: T3, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                stub3: UnderscoreStatic,
                                                p4: T4
                                                ): (p1: T1, p3: T3, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                stub3: UnderscoreStatic,
                                                p4: T4
                                                ): (p2: T2, p3: T3, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                stub3: UnderscoreStatic,
                                                p4: T4
                                                ): (p1: T1, p2: T2, p3: T3, p5: T5) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                p2: T2,
                                                p3: T3,
                                                p4: T4,
                                                p5: T5
                                                ): () => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                p3: T3,
                                                p4: T4,
                                                p5: T5
                                                ): (p1: T1) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                p3: T3,
                                                p4: T4,
                                                p5: T5
                                                ): (p2: T2) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                p3: T3,
                                                p4: T4,
                                                p5: T5
                                                ): (p1: T1, p2: T2) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                p2: T2,
                                                stub3: UnderscoreStatic,
                                                p4: T4,
                                                p5: T5
                                                ): (p3: T3) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                stub3: UnderscoreStatic,
                                                p4: T4,
                                                p5: T5
                                                ): (p1: T1, p3: T3) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                stub3: UnderscoreStatic,
                                                p4: T4,
                                                p5: T5
                                                ): (p2: T2, p3: T3) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                stub3: UnderscoreStatic,
                                                p4: T4,
                                                p5: T5
                                                ): (p1: T1, p2: T2, p3: T3) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                p2: T2,
                                                p3: T3,
                                                stub4: UnderscoreStatic,
                                                p5: T5
                                                ): (p4: T4) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                p3: T3,
                                                stub4: UnderscoreStatic,
                                                p5: T5
                                                ): (p1: T1, p4: T4) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                p3: T3,
                                                stub4: UnderscoreStatic,
                                                p5: T5
                                                ): (p2: T2, p4: T4) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                p3: T3,
                                                stub4: UnderscoreStatic,
                                                p5: T5
                                                ): (p1: T1, p2: T2, p4: T4) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                p2: T2,
                                                stub3: UnderscoreStatic,
                                                stub4: UnderscoreStatic,
                                                p5: T5
                                                ): (p3: T3, p4: T4) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                stub3: UnderscoreStatic,
                                                stub4: UnderscoreStatic,
                                                p5: T5
                                                ): (p1: T1, p3: T3, p4: T4) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                stub3: UnderscoreStatic,
                                                stub4: UnderscoreStatic,
                                                p5: T5
                                                ): (p2: T2, p3: T3, p4: T4) => T6;
                                                <T1, T2, T3, T4, T5, T6>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T6,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                stub3: UnderscoreStatic,
                                                stub4: UnderscoreStatic,
                                                p5: T5
                                                ): (p1: T1, p2: T2, p3: T3, p4: T4) => T6;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                p1: T1
                                                ): (p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                p1: T1,
                                                p2: T2
                                                ): (p3: T3, p4: T4, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                stub1: UnderscoreStatic,
                                                p2: T2
                                                ): (p1: T1, p3: T3, p4: T4, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                p1: T1,
                                                p2: T2,
                                                p3: T3
                                                ): (p4: T4, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                p3: T3
                                                ): (p1: T1, p4: T4, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                p3: T3
                                                ): (p2: T2, p4: T4, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                p3: T3
                                                ): (p1: T1, p2: T2, p4: T4, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                p1: T1,
                                                p2: T2,
                                                p3: T3,
                                                p4: T4
                                                ): (p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                p3: T3,
                                                p4: T4
                                                ): (p1: T1, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                p3: T3,
                                                p4: T4
                                                ): (p2: T2, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                p3: T3,
                                                p4: T4
                                                ): (p1: T1, p2: T2, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                p1: T1,
                                                p2: T2,
                                                stub3: UnderscoreStatic,
                                                p4: T4
                                                ): (p3: T3, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                stub3: UnderscoreStatic,
                                                p4: T4
                                                ): (p1: T1, p3: T3, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                stub3: UnderscoreStatic,
                                                p4: T4
                                                ): (p2: T2, p3: T3, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                stub3: UnderscoreStatic,
                                                p4: T4
                                                ): (p1: T1, p2: T2, p3: T3, p5: T5, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                p1: T1,
                                                p2: T2,
                                                p3: T3,
                                                p4: T4,
                                                p5: T5
                                                ): (p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                p3: T3,
                                                p4: T4,
                                                p5: T5
                                                ): (p1: T1, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                p3: T3,
                                                p4: T4,
                                                p5: T5
                                                ): (p2: T2, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                p3: T3,
                                                p4: T4,
                                                p5: T5
                                                ): (p1: T1, p2: T2, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                p1: T1,
                                                p2: T2,
                                                stub3: UnderscoreStatic,
                                                p4: T4,
                                                p5: T5
                                                ): (p3: T3, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                stub1: UnderscoreStatic,
                                                p2: T2,
                                                stub3: UnderscoreStatic,
                                                p4: T4,
                                                p5: T5
                                                ): (p1: T1, p3: T3, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                p1: T1,
                                                stub2: UnderscoreStatic,
                                                stub3: UnderscoreStatic,
                                                p4: T4,
                                                p5: T5
                                                ): (p2: T2, p3: T3, p6: T6) => T7;
                                                <T1, T2, T3, T4, T5, T6, T7>(
                                                fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T7,
                                                stub1: UnderscoreStatic,
                                                stub2: UnderscoreStatic,
                                                stub3