@types/underscore

Version 1.13.0
Published 1 month ago
258 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

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 | undefined;

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

property evaluate

evaluate?: RegExp | undefined;

Default value is '/<%([\s\S]+?)%>/g'.

property interpolate

interpolate?: RegExp | undefined;

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

property variable

variable?: string | undefined;

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 | undefined;

If you'd like to disable the leading-edge call, pass this as false.

property trailing

trailing?: boolean | undefined;

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: () => Array<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: Array<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): Array<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): TypeOfCollection<V> | undefined;
    <U>(path: string, defaultValue?: U): TypeOfCollection<V, never> | U;
    <P extends (string | number)[], U = undefined>(
        path: [...P],
        defaultValue?: U
    ): U | DeepTypeOfCollection<V, P>;
};

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: Array<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 isMap

isMap: () => boolean;

Returns true if the wrapped object is a Map.
Returns
True if the wrapped object is a Map, 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 isSet

isSet: () => boolean;

Returns true if the wrapped object is a Set.
Returns
True if the wrapped object is a Set, 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 isWeakMap

isWeakMap: () => boolean;

Returns true if the wrapped object is a WeakMap.
Returns
True if the wrapped object is a WeakMap, otherwise false.

method isWeakSet

isWeakSet: () => boolean;

Returns true if the wrapped object is a WeakSet.
Returns
True if the wrapped object is a WeakSet, 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
) => Array<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: Array<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: () => Array<[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: Array<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
) => Array<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 toPath

toPath: () => V extends ReadonlyArray<string | number>
    ? V
    : V extends string | number
    ? [V]
    : never;

Ensures that path is an array.
Parameter path
1. If path is a string, it is wrapped in a single-element array; 2. if it is an array already, it is returned unmodified.

method transpose

transpose: () => T extends [infer A, infer B, infer C]
    ? [A[], B[], C[]]
    : T extends [infer A, infer B]
    ? [A[], B[]]
    : T extends [infer A]
    ? [A[]]
    : T extends List<infer A>
    ? A[][]
    : [];

method unescape

unescape: () => string;

Wrapped type string.
See Also
- _.unescape

method union

union: (...lists: Array<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: () => T extends [infer A, infer B, infer C]
    ? [A[], B[], C[]]
    : T extends [infer A, infer B]
    ? [A[], B[]]
    : T extends [infer A]
    ? [A[]]
    : T extends List<infer A>
    ? A[][]
    : [];

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: {
    (): V extends List<infer A> ? [A][] : [];
    <A, B>(lists_0: List<A>, lists_1: List<B>): [T, A, B][];
    <A>(list: List<A>): [T, A][];
    (...lists: List<T>[]): T[][];
    (...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
) => Array<Array<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) => Array<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.
Parameter args
Additional arguments to pass to fn.
See Also
- _delay

method difference

difference: <T>(list: List<T>, ...others: Array<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
) => Array<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): Array<
        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): TypeOfCollection<
        V,
        never
    >;
    <V extends Collection<any>, U>(object: V, path: string, defaultValue?: U):
        | U
        | TypeOfCollection<V, never>;
    <V extends Collection<any>, P extends (string | number)[], U = undefined>(
        object: V,
        path: readonly [...P],
        defaultValue?: U
    ): U | DeepTypeOfCollection<V, P>;
};

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<Array<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) => Array<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: Array<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 isMap

isMap: (object: any) => object is Map<any, any>;

Returns true if object is a Map.
Parameter object
The object to check.
Returns
True if object is a Map, 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 isSet

isSet: (object: any) => object is Set<any>;

Returns true if object is a Set.
Parameter object
The object to check.
Returns
True if object is a Set, 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 isWeakMap

isWeakMap: (object: any) => object is WeakMap<any, any>;

Returns true if object is a WeakMap.
Parameter object
The object to check.
Returns
True if object is a WeakMap, otherwise false.

method isWeakSet

isWeakSet: (object: any) => object is WeakSet<any>;

Returns true if object is a WeakSet.
Parameter object
The object to check.
Returns
True if object is a WeakSet, 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
) => Array<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: Array<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
) => Array<[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: UnderscoreStatic,
        p4: T4,
        p5: T5
    ): (p1: T1, 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,
        p1: T1,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p4: T4, 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,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p1: T1, p4: T4, 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,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p2: T2, p4: T4, 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,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p1: T1, p2: T2, p4: T4, 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,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p3: T3, p4: T4, 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,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p1: T1, p3: T3, p4: T4, 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,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p2: T2, p3: T3, p4: T4, 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,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p1: T1, p2: T2, p3: T3, p4: T4, 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,
        p6: T6
    ): (p1: T1) => 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,
        p6: T6
    ): (p2: T2) => 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,
        p6: T6
    ): (p1: T1, p2: T2) => 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,
        p6: T6
    ): (p3: T3) => 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,
        p6: T6
    ): (p1: T1, p3: T3) => 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,
        p6: T6
    ): (p2: T2, p3: T3) => 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,
        p5: T5,
        p6: T6
    ): (p1: T1, p2: T2, p3: T3) => 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,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p4: T4) => 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,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p1: T1, p4: T4) => 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,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p2: T2, p4: T4) => 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,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p1: T1, p2: T2, p4: T4) => 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,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p3: T3, p4: T4) => 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,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p1: T1, p3: T3, p4: T4) => 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,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p2: T2, p3: T3, p4: T4) => 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,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p1: T1, p2: T2, p3: T3, p4: T4) => 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,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p5: T5) => 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,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p5: T5) => 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,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p2: T2, p5: T5) => 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,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p2: T2, p5: T5) => 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,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p3: T3, p5: T5) => 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,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p3: T3, p5: T5) => 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,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p2: T2, p3: T3, p5: T5) => 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,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p2: T2, p3: T3, p5: T5) => 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,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p4: T4, p5: T5) => 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,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p4: T4, p5: T5) => 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,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p2: T2, p4: T4, p5: T5) => 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,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p2: T2, p4: T4, p5: T5) => 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,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p3: T3, p4: T4, p5: T5) => 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,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p3: T3, p4: T4, p5: T5) => 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,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p2: T2, p3: T3, p4: T4, p5: T5) => 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,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T7;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1
    ): (p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2
    ): (p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2
    ): (p1: T1, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3
    ): (p4: T4, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3
    ): (p1: T1, p4: T4, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3
    ): (p2: T2, p4: T4, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3
    ): (p1: T1, p2: T2, p4: T4, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        p4: T4
    ): (p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        p4: T4
    ): (p1: T1, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4
    ): (p2: T2, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4
    ): (p1: T1, p2: T2, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4
    ): (p3: T3, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4
    ): (p1: T1, p3: T3, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4
    ): (p2: T2, p3: T3, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4
    ): (p1: T1, p2: T2, p3: T3, p5: T5, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        p4: T4,
        p5: T5
    ): (p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        p4: T4,
        p5: T5
    ): (p1: T1, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        p5: T5
    ): (p2: T2, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        p5: T5
    ): (p1: T1, p2: T2, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5
    ): (p3: T3, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5
    ): (p1: T1, p3: T3, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5
    ): (p2: T2, p3: T3, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5
    ): (p1: T1, p2: T2, p3: T3, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p4: T4, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p1: T1, p4: T4, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p2: T2, p4: T4, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p1: T1, p2: T2, p4: T4, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p3: T3, p4: T4, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p1: T1, p3: T3, p4: T4, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p2: T2, p3: T3, p4: T4, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5
    ): (p1: T1, p2: T2, p3: T3, p4: T4, p6: T6, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        p4: T4,
        p5: T5,
        p6: T6
    ): (p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        p4: T4,
        p5: T5,
        p6: T6
    ): (p1: T1, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        p5: T5,
        p6: T6
    ): (p2: T2, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        p5: T5,
        p6: T6
    ): (p1: T1, p2: T2, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5,
        p6: T6
    ): (p3: T3, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5,
        p6: T6
    ): (p1: T1, p3: T3, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5,
        p6: T6
    ): (p2: T2, p3: T3, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5,
        p6: T6
    ): (p1: T1, p2: T2, p3: T3, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p4: T4, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p1: T1, p4: T4, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p2: T2, p4: T4, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p1: T1, p2: T2, p4: T4, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p3: T3, p4: T4, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p1: T1, p3: T3, p4: T4, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p2: T2, p3: T3, p4: T4, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6
    ): (p1: T1, p2: T2, p3: T3, p4: T4, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p2: T2, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p2: T2, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p3: T3, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p3: T3, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p2: T2, p3: T3, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p2: T2, p3: T3, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p4: T4, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p4: T4, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p2: T2, p4: T4, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p2: T2, p4: T4, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p3: T3, p4: T4, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p3: T3, p4: T4, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p2: T2, p3: T3, p4: T4, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6
    ): (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p7: T7) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        p4: T4,
        p5: T5,
        p6: T6,
        p7: T7
    ): () => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        p4: T4,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p1: T1) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p2: T2) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p1: T1, p2: T2) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p3: T3) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p1: T1, p3: T3) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p2: T2, p3: T3) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p1: T1, p2: T2, p3: T3) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p4: T4) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p1: T1, p4: T4) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p2: T2, p4: T4) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p1: T1, p2: T2, p4: T4) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p3: T3, p4: T4) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p1: T1, p3: T3, p4: T4) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p2: T2, p3: T3, p4: T4) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5,
        p6: T6,
        p7: T7
    ): (p1: T1, p2: T2, p3: T3, p4: T4) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p1: T1, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p2: T2, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p1: T1, p2: T2, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p3: T3, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p1: T1, p3: T3, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p2: T2, p3: T3, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p1: T1, p2: T2, p3: T3, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p4: T4, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p1: T1, p4: T4, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p2: T2, p4: T4, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p1: T1, p2: T2, p4: T4, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p3: T3, p4: T4, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p1: T1, p3: T3, p4: T4, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p2: T2, p3: T3, p4: T4, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        p6: T6,
        p7: T7
    ): (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        p4: T4,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        p4: T4,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p2: T2, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p2: T2, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p3: T3, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p3: T3, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p2: T2, p3: T3, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p2: T2, p3: T3, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p4: T4, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p4: T4, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p2: T2, p4: T4, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p2: T2, p4: T4, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p3: T3, p4: T4, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p3: T3, p4: T4, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p2: T2, p3: T3, p4: T4, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        p5: T5,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p2: T2, p3: T3, p4: T4, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        p4: T4,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        p4: T4,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p2: T2, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        p4: T4,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p2: T2, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p3: T3, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        p4: T4,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p3: T3, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p2: T2, p3: T3, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        p4: T4,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p2: T2, p3: T3, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p4: T4, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        p3: T3,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p4: T4, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p2: T2, p4: T4, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        p3: T3,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p2: T2, p4: T4, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p3: T3, p4: T4, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        p2: T2,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p3: T3, p4: T4, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        p1: T1,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T8;
    <T1, T2, T3, T4, T5, T6, T7, T8>(
        fn: (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6, p7: T7) => T8,
        stub1: UnderscoreStatic,
        stub2: UnderscoreStatic,
        stub3: UnderscoreStatic,
        stub4: UnderscoreStatic,
        stub5: UnderscoreStatic,
        stub6: UnderscoreStatic,
        p7: T7
    ): (p1: T1, p2: T2, p3: T3, p4: T4, p5: T5, p6: T6) => T8;
};

Partially apply a function by filling in any number of its arguments, without changing its dynamic this value. A close cousin of bind. You may pass _ in your list of arguments to specify an argument that should not be pre-filled, but left open to supply at call-time.
Parameter fn
Function to partially fill in arguments.
Parameter arguments
The partial arguments. fn with partially filled in arguments.

method partition

partition: <V extends Collection<any>>(
    list: V,
    iteratee?: Iteratee<V, boolean>,
    context?: any
) => [Array<TypeOfCollection<V>>, Array<TypeOfCollection<V>>];

Splits collection into two arrays: one whose elements all satisfy iteratee and one whose elements all do not satisfy iteratee.
Parameter collection
The collection to partition.
Parameter iteratee
The iteratee that defines the partitioning scheme for each element in collection.
Parameter context
this object in iteratee, optional.
Returns
An array composed of two elements, where the first element contains the elements in collection that satisfied the predicate and the second element contains the elements that did not.

method pick

pick: {
    <V, K extends string>(object: V, ...keys: Array<K | K[]>): _Pick<V, K>;
    <V>(
        object: V,
        iterator: ObjectIterator<TypeOfDictionary<V, any>, boolean, V>
    ): Partial<V>;
};

Return a copy of object that is filtered to only have values for the allowed keys (or array of keys).
Parameter object
The object to pick specific keys in.
Parameter keys
The keys to keep on object.
Returns
A copy of object with only the keys properties.
Return a copy of object that is filtered to only have values for the keys selected by a truth test.
Parameter object
The object to pick specific keys in.
Parameter iterator
A truth test that selects the keys to keep on object.
Returns
A copy of object with only the keys selected by iterator.

method pluck

pluck: <V extends Collection<any>, K extends string | number>(
    collection: V,
    propertyName: K
) => Array<PropertyTypeOrAny<TypeOfCollection<V>, K>>;

A convenient version of what is perhaps the most common use-case for map: extracting a list of property values.
Parameter collection
The collection of items.
Parameter propertyName
The name of a specific property to retrieve from all items in collection.
Returns
The set of values for the specified propertyName for each item in collection.

method property

property: (
    key: string | number | Array<string | number>
) => (object: any) => any;

Returns a function that will itself return the key property of any passed-in object.
Parameter key
Property of the object. Function which accept an object an returns the value of key in that object.

method propertyOf

propertyOf: (
    object: object
) => (key: string | number | Array<string | number>) => any;

Returns a function that will itself return the value of a object key property.
Parameter key
The object to get the property value from. Function which accept a key property in object and returns its value.

method random

random: { (max: number): number; (min: number, max: number): number };

Returns a random integer between min and max, inclusive. If you only pass one argument, it will return a number between 0 and that number.
Parameter max
The maximum random number. A random number between 0 and max.
Parameter min
The minimum random number. A random number between min and max.
See Also
- _.random

method range

range: (startOrStop: number, 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 startOrStop (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, startOrStop will be the number to stop at and the default start of 0 will be used.
Parameter startOrStop
If stop is specified, the number to start at. Otherwise, this is 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: {
    <V extends Collection<any>, TResult>(
        collection: V,
        iteratee: MemoCollectionIterator<TypeOfCollection<V>, TResult, V>,
        memo: TResult,
        context?: any
    ): TResult;
    <V extends Collection<any>, TResult = TypeOfCollection<V, never>>(
        collection: V,
        iteratee: MemoCollectionIterator<
            TypeOfCollection<V, never>,
            TResult | TypeOfCollection<V, never>,
            V
        >
    ): TResult | TypeOfCollection<V, never>;
};

Also known as inject and foldl, reduce boils down a 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 collection. The first element is instead passed as the memo in the invocation of iteratee on the next element in collection.
Parameter collection
The collection to reduce.
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: {
    <V extends Collection<any>, TResult>(
        collection: V,
        iteratee: MemoCollectionIterator<TypeOfCollection<V>, TResult, V>,
        memo: TResult,
        context?: any
    ): TResult;
    <V extends Collection<any>, TResult = TypeOfCollection<V, never>>(
        collection: V,
        iteratee: MemoCollectionIterator<
            TypeOfCollection<V, never>,
            TResult | TypeOfCollection<V, never>,
            V
        >
    ): TResult | TypeOfCollection<V, never>;
};

The right-associative version of reduce.
This is not as useful in JavaScript as it would be in a language with lazy evaluation.
Parameter collection
The collection to reduce.
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: <V extends Collection<any>>(
    collection: V,
    iteratee?: Iteratee<V, boolean>,
    context?: any
) => Array<TypeOfCollection<V>>;

Returns the values in collection without the elements that pass a truth test (iteratee). The opposite of filter.
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 fail the truth test.

method rest

rest: <V extends List<any>>(list: V, index?: number) => Array<TypeOfList<V>>;

Returns the rest of the elements in list. Pass an index to return the values of the list from that index onward.
Parameter list
The list to retrieve elements from.
Parameter index
The index to start retrieving elements from, optional, default = 1.
Returns
The elements of list from index to the end of the list.

method restArgs

restArgs: (func: Function, starIndex?: number) => Function;

Similar to ES6's rest param (http://ariya.ofilabs.com/2013/03/es6-and-rest-parameter.html) This accumulates the arguments passed into an array, after a given index.

method result

result: (object: any, property: string, defaultValue?: any) => any;

If the value of the named property is a function then invoke it; otherwise, return it.
Parameter object
Object to maybe invoke function property on.
Parameter property
The function by name to invoke on object.
Parameter defaultValue
The value to be returned in case property doesn't exist or is undefined. The result of invoking the function property on `object.

method sample

sample: {
    <V extends Collection<any>>(collection: V, n: number): Array<
        TypeOfCollection<V>
    >;
    <V extends Collection<any>>(collection: V): TypeOfCollection<V, never>;
};

Produce a random sample from collection. Pass a number to return n random elements from collection. Otherwise a single random item will be returned.
Parameter collection
The collection to sample.
Parameter n
The number of elements to sample from collection.
Returns
A random sample of n elements from collection or a single element if n is not specified.

method shuffle

shuffle: <V extends Collection<any>>(
    collection: V
) => Array<TypeOfCollection<V>>;

Returns a shuffled copy of collection, using a version of the Fisher-Yates shuffle.
Parameter collection
The collection to shuffle.
Returns
A shuffled copy of collection.

method size

size: (collection: Collection<any>) => number;

Determines the number of values in collection.
Parameter collection
The collection to determine the number of values for.
Returns
The number of values in collection.

method some

some: <V extends Collection<any>>(
    collection: V,
    iteratee?: Iteratee<V, boolean>,
    context?: any
) => boolean;

Returns true if any of the values in collection pass the iteratee truth test. Short-circuits and stops traversing collection if a true 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 any element passed the truth test, otherwise false.

method sortBy

sortBy: <V extends Collection<any>>(
    collection: V,
    iteratee?: Iteratee<V, any>,
    context?: any
) => Array<TypeOfCollection<V>>;

Returns a (stably) sorted copy of collection, ranked in ascending order by the results of running each value through iteratee.
Parameter collection
The collection to sort.
Parameter iteratee
An iteratee that provides the value to sort by for each item in collection.
Parameter context
this object in iteratee, optional.
Returns
A sorted copy of collection.

method sortedIndex

sortedIndex: <V extends List<any>>(
    list: V,
    value: TypeOfList<V>,
    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 list in order to maintain 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 list
A sorted list.
Parameter value
The value to determine an insert index for to mainain the sorting in 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 list.

method tap

tap: <T>(object: T, intercepter: Function) => T;

Invokes interceptor with the object, and then returns object. The primary purpose of this method is to "tap into" a method chain, in order to perform operations on intermediate results within the chain.
Parameter object
Argument to interceptor.
Parameter intercepter
The function to modify object before continuing the method chain. Modified object.

method template

template: (
    templateString: string,
    settings?: _.TemplateSettings
) => CompiledTemplate;

Compiles JavaScript templates into functions that can be evaluated for rendering. Useful for rendering complicated bits of HTML from JSON data sources. Template functions can both interpolate variables, using <%= ... %>, as well as execute arbitrary JavaScript code, with <% ... %>. If you wish to interpolate a value, and have it be HTML-escaped, use <%- ... %> When you evaluate a template function, pass in a data object that has properties corresponding to the template's free variables. If you're writing a one-off, you can pass the data object as the second parameter to template in order to render immediately instead of returning a template function. The settings argument should be a hash containing any _.templateSettings that should be overridden.
Parameter templateString
Underscore HTML template.
Parameter data
Data to use when compiling templateString.
Parameter settings
Settings to use while compiling. Returns the compiled Underscore HTML template.

method throttle

throttle: <T extends Function>(
    func: T,
    wait: number,
    options?: _.ThrottleSettings
) => T & _.Cancelable;

Creates and returns a new, throttled version of the passed function, that, when invoked repeatedly, will only actually call the original function at most once per every wait milliseconds. Useful for rate-limiting events that occur faster than you can keep up with. By default, throttle will execute the function as soon as you call it for the first time, and, if you call it again any number of times during the wait period, as soon as that period is over. If you'd like to disable the leading-edge call, pass {leading: false}, and if you'd like to disable the execution on the trailing-edge, pass {trailing: false}.
Parameter func
Function to throttle waitMS ms.
Parameter wait
The number of milliseconds to wait before fn can be invoked again.
Parameter options
Allows for disabling execution of the throttled function on either the leading or trailing edge. fn with a throttle of wait.

method times

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

Invokes the given iterator function n times. Each invocation of iterator is called with an index argument
Parameter n
Number of times to invoke iterator.
Parameter iterator
Function iterator to invoke n times.
Parameter context
this object in iterator, optional.

method toArray

toArray: <V extends Collection<any>>(
    collection: V
) => Array<TypeOfCollection<V>>;

Creates a real Array from collection (anything that can be iterated over). Useful for transmuting the arguments object.
Parameter collection
The collection to transform into an array.
Returns
An array containing the elements of collection.

method toPath

toPath: <P>(
    path: P
) => P extends ReadonlyArray<string | number>
    ? P
    : P extends string | number
    ? [P]
    : never;

Ensures that path is an array.
Parameter path
1. If path is a string, it is wrapped in a single-element array; 2. if it is an array already, it is returned unmodified.

method transpose

transpose: {
    <T, U, V>(lists: List<[T, U, V]>): [T[], U[], V[]];
    <T, U>(lists: List<[T, U]>): [T[], U[]];
    <T>(lists: List<[T]>): [T[]];
    <T>(lists: List<List<T>>): T[][];
    (lists: List<List<any>>): any[][];
    (): [];
};

method unescape

unescape: (str: string) => string;

The opposite of escape, replaces &, <, >, ", and ' with their unescaped counterparts.
Parameter str
HTML escaped string. str Raw string.

method union

union: <T>(...lists: Array<List<T>>) => T[];

Computes the union of 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 to compute the union of.
Returns
The union of elements within lists.

method uniq

uniq: {
    <V extends List<any>>(
        list: V,
        isSorted?: boolean,
        iteratee?: Iteratee<V, any>,
        context?: any
    ): Array<TypeOfList<V>>;
    <V extends List<any>>(
        list: V,
        iteratee?: Iteratee<V, any, TypeOfCollection<V, never>>,
        context?: any
    ): TypeOfList<V>[];
};

Produces a duplicate-free version of list, using === to test object equality. If you know in advance that 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 list
The list to remove duplicates from.
Parameter isSorted
True if list is already sorted, optional, default = false.
Parameter iteratee
Transform the elements of list before comparisons for uniqueness.
Parameter context
'this' object in iteratee, optional.
Returns
An array containing only the unique elements in list.

method uniqueId

uniqueId: (prefix?: string) => string;

Generate a globally-unique id for client-side models or DOM elements that need one. If prefix is passed, the id will be appended to it. Without prefix, returns an integer.
Parameter prefix
A prefix string to start the unique ID with. Unique string ID beginning with prefix.

method unzip

unzip: {
    <T, U, V>(lists: List<[T, U, V]>): [T[], U[], V[]];
    <T, U>(lists: List<[T, U]>): [T[], U[]];
    <T>(lists: List<[T]>): [T[]];
    <T>(lists: List<List<T>>): T[][];
    (lists: List<List<any>>): any[][];
    (): [];
};

The opposite of zip. Given a list of lists, returns a series of new arrays, the first of which contains all of the first elements in the input lists, the second of which contains all of the second elements, and so on. (alias: transpose)
Parameter lists
The lists to unzip.
Returns
The unzipped version of lists.

method values

values: { <T>(object: _.Dictionary<T>): T[]; (object: any): any[] };

Return all of the values of the object's properties.
Parameter object
Retrieve the values of all the properties on this object. List of all the values on object.

method where

where: <V extends Collection<any>>(
    collection: V,
    properties: Partial<TypeOfCollection<V>>
) => Array<TypeOfCollection<V>>;

Looks through each value in collection, returning an array of all the elements that match the key-value pairs listed in properties.
Parameter collection
The collection in which to find elements that match properties.
Parameter properties
The properties to check for on the elements within collection.
Returns
The elements in collection that match properties.

method without

without: <V extends List<any>>(
    list: V,
    ...values: Array<TypeOfList<V>>
) => Array<TypeOfList<V>>;

Returns a copy of list with all instances of values removed.
Parameter list
The list to exclude values from.
Parameter values
The values to exclude from list.
Returns
An array that contains all elements of list except for values.

method wrap

wrap: (fn: Function, wrapper: (fn: Function, ...args: any[]) => any) => Function;

Wraps the first function inside of the wrapper function, passing it as the first argument. This allows the wrapper to execute code before and after the function runs, adjust the arguments, and execute it conditionally.
Parameter fn
Function to wrap.
Parameter wrapper
The function that will wrap fn. Wrapped version of `fn.

method zip

zip: {
    (): [];
    <T, U, V>(lists_0: List<T>, lists_1: List<U>, lists_2: List<V>): [T, U, V][];
    <T, U>(lists_0: List<T>, lists_1: List<U>): [T, U][];
    <T>(lists_0: List<T>): [T][];
    <T>(...lists: List<T>[]): T[][];
    (...lists: List<any>[]): any[][];
};

Merges together the values of each of the lists with the values at the corresponding position. Useful when you have separate data sources that are coordinated through matching list indexes.
Parameter lists
The lists to zip.
Returns
The zipped version of lists.

call signature

<V>(value: V): Underscore<TypeOfCollection<V>, V>;

Underscore OOP Wrapper, all Underscore functions that take an object as the first parameter can be invoked through this function.
Parameter value
First argument to Underscore object functions.
Returns
An Underscore wrapper around the supplied value.

Type Aliases

type AnyFalsy

type AnyFalsy = undefined | null | false | '' | 0;

type Collection

type Collection<T> = List<T> | Dictionary<T>;

type CollectionKey

type CollectionKey<V> = V extends never
    ? any
    : V extends List<any>
    ? number
    : V extends Dictionary<any>
    ? string
    : V extends undefined
    ? undefined
    : never;

type DeepestListItemOrSelf

type DeepestListItemOrSelf<T> = T extends List<infer TItem> & object
    ? TItem extends List<any> & object
        ? any
        : TItem
    : T;

type DeepTypeOfCollection

type DeepTypeOfCollection<V, P> = P extends [infer H, ...infer R]
    ? H extends keyof V
        ? DeepTypeOfCollection<V[H], R>
        : never
    : V;

type Iteratee

type Iteratee<V, R, T extends TypeOfCollection<V, any> = TypeOfCollection<V>> =
    | CollectionIterator<T, R, V>
    | string
    | number
    | Array<string | number>
    | Partial<T>
    | null
    | undefined;

type IterateeResult

type IterateeResult<I, T> = I extends (...args: any[]) => infer R
    ? R
    : I extends keyof T
    ? T[I]
    : I extends string | number | Array<string | number>
    ? any
    : I extends object
    ? boolean
    : I extends null | undefined
    ? T
    : never;

type ListItemOrSelf

type ListItemOrSelf<T> = T extends List<infer TItem> ? TItem : T;

type PairValue

type PairValue<T> = T extends Readonly<[string | number, infer TValue]>
    ? TValue
    : T extends List<infer TValue>
    ? TValue
    : never;

type PropertyTypeOrAny

type PropertyTypeOrAny<T, K> = K extends keyof T ? T[K] : any;

type Truthy

type Truthy<T> = Exclude<T, AnyFalsy>;

type TypedArray

type TypedArray =
    | Int8Array
    | Uint8Array
    | Int16Array
    | Uint16Array
    | Int32Array
    | Uint32Array
    | Uint8ClampedArray
    | Float32Array
    | Float64Array;

type TypeOfCollection

type TypeOfCollection<V, TObjectDefault = never> = V extends List<any>
    ? TypeOfList<V>
    : TypeOfDictionary<V, TObjectDefault>;

type TypeOfDictionary

type TypeOfDictionary<V, TDefault = never> = V extends never
    ? any
    : V extends Dictionary<infer T>
    ? T
    : TDefault;

type TypeOfList

type TypeOfList<V> = V extends never ? any : V extends List<infer T> ? T : never;

Namespaces

namespace global

namespace global {}

interface Element

interface Element {}

Package Files (1)

index.d.ts

Dependencies (0)

No dependencies.

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/underscore.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/underscore)

HTML

<a href="https://www.jsdocs.io/package/@types/underscore"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 month ago.
Package analyzed in 8836 ms.
Missing or incorrect documentation? Open an issue for this package.

@types/underscore

Install

Overview

Index

Interfaces

Type Aliases

Namespaces

Interfaces

interface Cancelable

method cancel

interface CollectionIterator

call signature

interface CompiledTemplate

property source

call signature

interface Dictionary

index signature

interface List

property length

index signature

interface ListIterator

interface MemoCollectionIterator

call signature

interface MemoIterator

interface MemoObjectIterator

interface ObjectIterator

interface Predicate

call signature

interface TemplateSettings

property escape

property evaluate

property interpolate

property variable

interface ThrottleSettings

property leading

property trailing

interface Underscore

property all

See Also

property any

See Also

property collect

See Also

property detect

See Also

property drop

See Also

property foldl

See Also

property foldr

See Also

property forEach

See Also

property head

See Also

property include

See Also

property includes

See Also

property inject

See Also

property select

See Also

property tail

See Also

property take

See Also

property unique

See Also

method after

See Also

method allKeys

See Also

method before

See Also

method bind

See Also

method bindAll

See Also

method chain