@types/lodash

Version 4.14.172
Published 30 days ago
859 kB
No dependencies
MIT license

Install

npm i @types/lodash

yarn add @types/lodash

pnpm add @types/lodash

Overview

TypeScript definitions for Lo-Dash

Index

Interfaces

interface Collection

interface Collection<T> {}

method pop

pop: () => T | undefined;

method push

push: (...items: T[]) => this;

method shift

shift: () => T | undefined;

method sort

sort: (compareFn?: (a: T, b: T) => number) => this;

method splice

splice: (start: number, deleteCount?: number, ...items: T[]) => this;

method unshift

unshift: (...items: T[]) => this;

interface Collection

interface Collection<T> extends LoDashImplicitWrapper<T[]> {}

interface Collection

interface Collection<T> {}

method chunk

chunk: (size?: number) => Collection<T[]>;

See Also
- _.chunk

interface Collection

interface Collection<T> {}

method compact

compact: () => Collection<Truthy<T>>;

See Also
- _.compact

interface Collection

interface Collection<T> {}

method concat

concat: (...values: Array<Many<T>>) => Collection<T>;

See Also
- _.concat

interface Collection

interface Collection<T> {}

method difference

difference: (...values: Array<List<T>>) => Collection<T>;

See Also
- _.difference

interface Collection

interface Collection<T> {}

method differenceBy

differenceBy: {
    <T2>(values1: List<T2>, iteratee?: ValueIteratee<T | T2>): Collection<T>;
    (...values: (List<unknown> | ValueIteratee<T>)[]): Collection<T>;
};

See Also
- _.differenceBy

interface Collection

interface Collection<T> {}

method differenceWith

differenceWith: {
    <T2>(values: List<T2>, comparator: Comparator2<T, T2>): Collection<T>;
    <T2, T3, T4>(
        ...values: (List<unknown> | Comparator2<T, never>)[]
    ): Collection<T>;
};

See Also
- _.differenceWith

interface Collection

interface Collection<T> {}

method drop

drop: (n?: number) => Collection<T>;

See Also
- _.drop

interface Collection

interface Collection<T> {}

method dropRight

dropRight: (n?: number) => Collection<T>;

See Also
- _.dropRight

interface Collection

interface Collection<T> {}

method dropRightWhile

dropRightWhile: (predicate?: ListIteratee<T>) => Collection<T>;

See Also
- _.dropRightWhile

interface Collection

interface Collection<T> {}

method dropWhile

dropWhile: (predicate?: ListIteratee<T>) => Collection<T>;

See Also
- _.dropWhile

interface Collection

interface Collection<T> {}

method fill

fill: <U>(value: U, start?: number, end?: number) => Collection<T | U>;

See Also
- _.fill

interface Collection

interface Collection<T> {}

method findIndex

findIndex: (
    predicate?: ListIterateeCustom<T, boolean>,
    fromIndex?: number
) => number;

See Also
- _.findIndex

interface Collection

interface Collection<T> {}

method findLastIndex

findLastIndex: (
    predicate?: ListIterateeCustom<T, boolean>,
    fromIndex?: number
) => number;

See Also
- _.findLastIndex

interface Collection

interface Collection<T> {}

method first

first: () => T | undefined;

See Also
- _.first

interface Collection

interface Collection<T> {}

method flatten

flatten: () => T extends Many<infer U> ? Collection<U> : Collection<T>;

See Also
- _.flatten

interface Collection

interface Collection<T> {}

method flattenDeep

flattenDeep: () => T extends ListOfRecursiveArraysOrValues<infer U>
    ? Collection<Flat<U>>
    : Collection<T>;

See Also
- _.flattenDeep

interface Collection

interface Collection<T> {}

method flattenDepth

flattenDepth: (depth?: number) => Collection<T>;

See Also
- _.flattenDepth

interface Collection

interface Collection<T> {}

method fromPairs

fromPairs: () => Object<Dictionary<T extends [PropertyName, infer U] ? U : any>>;

See Also
- _.fromPairs

interface Collection

interface Collection<T> {}

method head

head: () => T | undefined;

See Also
- _.head

interface Collection

interface Collection<T> {}

method indexOf

indexOf: (value: T, fromIndex?: number) => number;

See Also
- _.indexOf

interface Collection

interface Collection<T> {}

method initial

initial: () => Collection<T>;

See Also
- _.initial

interface Collection

interface Collection<T> {}

method intersection

intersection: (...arrays: Array<List<T> | null | undefined>) => Collection<T>;

See Also
- _.intersection

interface Collection

interface Collection<T> {}

method intersectionBy

intersectionBy: {
    <T2>(values: List<T2>, iteratee: ValueIteratee<T | T2>): Collection<T>;
    (...values: (List<unknown> | ValueIteratee<T>)[]): Collection<T>;
};

See Also
- _.intersectionBy

interface Collection

interface Collection<T> {}

method intersectionWith

intersectionWith: {
    <T2>(values: List<T2>, comparator: Comparator2<T, T2>): Collection<T>;
    (...values: (List<unknown> | Comparator2<T, never>)[]): Collection<T>;
};

See Also
- _.intersectionWith

interface Collection

interface Collection<T> {}

method join

join: (separator?: string) => string;

See Also
- _.join

interface Collection

interface Collection<T> {}

method last

last: () => T | undefined;

See Also
- _.last

interface Collection

interface Collection<T> {}

method lastIndexOf

lastIndexOf: (value: T, fromIndex?: true | number) => number;

See Also
- _.lastIndexOf

interface Collection

interface Collection<T> {}

method nth

nth: (n?: number) => T | undefined;

See Also
- _.nth

interface Collection

interface Collection<T> {}

method pull

pull: (...values: T[]) => Collection<T>;

See Also
- _.pull

interface Collection

interface Collection<T> {}

method pullAll

pullAll: (values?: List<T>) => Collection<T>;

See Also
- _.pullAll

interface Collection

interface Collection<T> {}

method pullAllBy

pullAllBy: <T2>(
    values?: List<T2>,
    iteratee?: ValueIteratee<T | T2>
) => Collection<T>;

See Also
- _.pullAllBy

interface Collection

interface Collection<T> {}

method pullAllWith

pullAllWith: <T2>(
    values?: List<T2>,
    comparator?: Comparator2<T, T2>
) => Collection<T>;

See Also
- _.pullAllWith

interface Collection

interface Collection<T> {}

method pullAt

pullAt: (...indexes: Array<Many<number>>) => Collection<T>;

See Also
- _.pullAt

interface Collection

interface Collection<T> {}

method remove

remove: (predicate?: ListIteratee<T>) => Collection<T>;

See Also
- _.remove

interface Collection

interface Collection<T> {}

method slice

slice: (start?: number, end?: number) => Collection<T>;

See Also
- _.slice

interface Collection

interface Collection<T> {}

method sortedIndex

sortedIndex: { (value: T): number; (value: T): number };

See Also
- _.sortedIndex

interface Collection

interface Collection<T> {}

method sortedIndex

sortedIndex: { (value: T): number; (value: T): number };

See Also
- _.sortedIndex

interface Collection

interface Collection<T> {}

method sortedIndexBy

sortedIndexBy: (value: T, iteratee?: ValueIteratee<T>) => number;

See Also
- _.sortedIndexBy

interface Collection

interface Collection<T> {}

method sortedIndexOf

sortedIndexOf: (value: T) => number;

See Also
- _.sortedIndexOf

interface Collection

interface Collection<T> {}

method sortedLastIndex

sortedLastIndex: (value: T) => number;

See Also
- _.sortedLastIndex

interface Collection

interface Collection<T> {}

method sortedLastIndexBy

sortedLastIndexBy: (value: T, iteratee: ValueIteratee<T>) => number;

See Also
- _.sortedLastIndexBy

interface Collection

interface Collection<T> {}

method sortedLastIndexOf

sortedLastIndexOf: (value: T) => number;

See Also
- _.sortedLastIndexOf

interface Collection

interface Collection<T> {}

method sortedUniq

sortedUniq: () => Collection<T>;

See Also
- _.sortedUniq

interface Collection

interface Collection<T> {}

method sortedUniqBy

sortedUniqBy: (iteratee: ValueIteratee<T>) => Collection<T>;

See Also
- _.sortedUniqBy

interface Collection

interface Collection<T> {}

method tail

tail: () => Collection<T>;

See Also
- _.tail

interface Collection

interface Collection<T> {}

method take

take: (n?: number) => Collection<T>;

See Also
- _.take

interface Collection

interface Collection<T> {}

method takeRight

takeRight: (n?: number) => Collection<T>;

See Also
- _.takeRight

interface Collection

interface Collection<T> {}

method takeRightWhile

takeRightWhile: (predicate?: ListIteratee<T>) => Collection<T>;

See Also
- _.takeRightWhile

interface Collection

interface Collection<T> {}

method takeWhile

takeWhile: (predicate?: ListIteratee<T>) => Collection<T>;

See Also
- _.takeWhile

interface Collection

interface Collection<T> {}

method union

union: (...arrays: Array<List<T> | null | undefined>) => Collection<T>;

See Also
- _.union

interface Collection

interface Collection<T> {}

method unionBy

unionBy: {
    (
        arrays2: List<T> | null | undefined,
        iteratee?: ValueIteratee<T>
    ): Collection<T>;
    (...iteratee: (List<T> | ValueIteratee<T>)[]): Collection<T>;
};

See Also
- _.unionBy

interface Collection

interface Collection<T> {}

method unionWith

unionWith: {
    (
        arrays2: List<T> | null | undefined,
        comparator?: Comparator<T>
    ): Collection<T>;
    (...comparator: (List<T> | Comparator<T>)[]): Collection<T>;
};

See Also
- _.unionWith

interface Collection

interface Collection<T> {}

method uniq

uniq: () => Collection<T>;

See Also
- _.uniq

interface Collection

interface Collection<T> {}

method uniqBy

uniqBy: (iteratee: ValueIteratee<T>) => Collection<T>;

See Also
- _.uniqBy

interface Collection

interface Collection<T> {}

method uniqWith

uniqWith: (comparator?: Comparator<T>) => Collection<T>;

See Also
- _.uniqWith

interface Collection

interface Collection<T> {}

method unzip

unzip: () => T extends List<infer U> ? Collection<U[]> : unknown;

See Also
- _.unzip

interface Collection

interface Collection<T> {}

method unzipWith

unzipWith: {
    <TResult>(
        iteratee: (
            ...values: (T extends List<infer U> ? U : unknown)[]
        ) => TResult
    ): Collection<TResult>;
    (): T extends List<infer U> ? Collection<U[]> : unknown;
};

See Also
- _.unzipWith

interface Collection

interface Collection<T> {}

method without

without: (...values: T[]) => Collection<T>;

See Also
- _.without

interface Collection

interface Collection<T> {}

method xor

xor: (...arrays: Array<List<T> | null | undefined>) => Collection<T>;

See Also
- _.xor

interface Collection

interface Collection<T> {}

method xorBy

xorBy: {
    (
        arrays2: List<T> | null | undefined,
        iteratee?: ValueIteratee<T>
    ): Collection<T>;
    (...iteratee: (List<T> | ValueIteratee<T>)[]): Collection<T>;
};

See Also
- _.xorBy

interface Collection

interface Collection<T> {}

method xorWith

xorWith: {
    (
        arrays2: List<T> | null | undefined,
        comparator?: Comparator<T>
    ): Collection<T>;
    (...comparator: (List<T> | Comparator<T>)[]): Collection<T>;
};

See Also
- _.xorWith

interface Collection

interface Collection<T> {}

method zip

zip: {
    <T2>(arrays2: List<T2>): Collection<[T | undefined, T2 | undefined]>;
    (...arrays: List<T>[]): Collection<T[]>;
};

See Also
- _.zip

interface Collection

interface Collection<T> {}

method zipObject

zipObject: {
    <U>(values: List<U>): Object<Dictionary<U>>;
    (): Object<Dictionary<undefined>>;
};

See Also
- _.zipObject

interface Collection

interface Collection<T> {}

method zipObjectDeep

zipObjectDeep: (values?: List<any>) => Object<object>;

See Also
- _.zipObjectDeep

interface Collection

interface Collection<T> {}

method zipWith

zipWith: {
    <T2, TResult>(
        arrays2: List<T2>,
        iteratee: (value1: T, value2: T2) => TResult
    ): Collection<TResult>;
    <T2, T3, TResult>(
        arrays2: List<T2>,
        arrays3: List<T3>,
        iteratee: (value1: T, value2: T2, value3: T3) => TResult
    ): Collection<TResult>;
    <TResult>(
        ...iteratee: (List<T> | ((...group: T[]) => TResult))[]
    ): Collection<TResult>;
};

See Also
- _.zipWith

interface Collection

interface Collection<T> {}

method countBy

countBy: (iteratee?: ValueIteratee<T>) => Object<Dictionary<number>>;

See Also
- _.countBy

interface Collection

interface Collection<T> {}

property each

each: Collection<T>['forEach'];

See Also
- _.each

interface Collection

interface Collection<T> {}

property eachRight

eachRight: Collection<T>['forEachRight'];

See Also
- _.eachRight

interface Collection

interface Collection<T> {}

method every

every: (predicate?: ListIterateeCustom<T, boolean>) => boolean;

See Also
- _.every

interface Collection

interface Collection<T> {}

method filter

filter: {
    <S extends T>(predicate: ListIteratorTypeGuard<T, S>): Collection<S>;
    (predicate?: ListIterateeCustom<T, boolean>): Collection<T>;
};

See Also
- _.filter

interface Collection

interface Collection<T> {}

method find

find: {
    <S extends T>(predicate: ListIteratorTypeGuard<T, S>, fromIndex?: number):
        | S
        | undefined;
    (predicate?: ListIterateeCustom<T, boolean>, fromIndex?: number): T;
};

See Also
- _.find

interface Collection

interface Collection<T> {}

method findLast

findLast: {
    <S extends T>(predicate: ListIteratorTypeGuard<T, S>, fromIndex?: number):
        | S
        | undefined;
    (predicate?: ListIterateeCustom<T, boolean>, fromIndex?: number): T;
};

See Also
- _.findLast

interface Collection

interface Collection<T> {}

method flatMap

flatMap: {
    <TResult = any>(
        iteratee: ListIterator<T, Many<TResult>> | PropertyName
    ): Collection<TResult>;
    (iteratee: object | [PropertyName, any]): Collection<boolean>;
    (): T extends Many<infer U> ? Collection<U> : Collection<T>;
};

See Also
- _.flatMap

interface Collection

interface Collection<T> {}

method flatMapDeep

flatMapDeep: {
    <TResult = any>(
        iteratee:
            | ListIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult>
            | PropertyName
    ): Collection<TResult>;
    (iteratee: object | [PropertyName, any]): Collection<boolean>;
    (): Collection<T>;
};

See Also
- _.flatMapDeep

interface Collection

interface Collection<T> {}

method flatMapDepth

flatMapDepth: {
    <TResult = any>(
        iteratee:
            | ListIterator<T, ListOfRecursiveArraysOrValues<TResult> | TResult>
            | PropertyName,
        depth?: number
    ): Collection<TResult>;
    (
        iteratee: object | [PropertyName, any],
        depth?: number
    ): Collection<boolean>;
    (depth?: number): Collection<T>;
};

See Also
- _.flatMapDepth

interface Collection

interface Collection<T> {}

method forEach

forEach: (iteratee?: ListIterator<T, any>) => Collection<T>;

See Also
- _.forEach

interface Collection

interface Collection<T> {}

method forEachRight

forEachRight: (iteratee?: ListIterator<T, any>) => Collection<T>;

See Also
- _.forEachRight

interface Collection

interface Collection<T> {}

method groupBy

groupBy: (iteratee?: ValueIteratee<T>) => Object<Dictionary<T[]>>;

See Also
- _.groupBy

interface Collection

interface Collection<T> {}

method includes

includes: (target: T, fromIndex?: number) => boolean;

See Also
- _.includes

interface Collection

interface Collection<T> {}

method keyBy

keyBy: (
    iteratee?: ValueIterateeCustom<T, PropertyName>
) => Object<Dictionary<T>>;

See Also
- _.keyBy

interface Collection

interface Collection<T> {}

method map

map: {
    <K extends keyof T>(key: K): Collection<T[K]>;
    <TResult>(iteratee: ListIterator<T, TResult>): Collection<TResult>;
    (iteratee: PropertyName): Collection<any>;
    (iteratee: object | [PropertyName, any]): Collection<boolean>;
    (): Collection<T>;
};

See Also
- _.map

interface Collection

interface Collection<T> {}

method orderBy

orderBy: (
    iteratees?: Many<
        ListIterator<T, NotVoid> | PropertyName | PartialShallow<T>
    >,
    orders?: Many<boolean | 'asc' | 'desc'>
) => Collection<T>;

See Also
- _.orderBy

interface Collection

interface Collection<T> {}

method partition

partition: {
    <U extends T>(callback: ValueIteratorTypeGuard<T, U>): LoDashImplicitWrapper<
        [U[], Array<Exclude<T, U>>]
    >;
    (callback: ValueIteratee<T>): LoDashImplicitWrapper<[T[], T[]]>;
};

See Also
- _.partition

interface Collection

interface Collection<T> {}

method reduce

reduce: {
    <TResult>(
        callback: MemoListIterator<T, TResult, List<T>>,
        accumulator: TResult
    ): TResult;
    (callback: MemoListIterator<T, T, List<T>>): T;
};

See Also
- _.reduce

interface Collection

interface Collection<T> {}

method reduceRight

reduceRight: {
    <TResult>(
        callback: MemoListIterator<T, TResult, List<T>>,
        accumulator: TResult
    ): TResult;
    (callback: MemoListIterator<T, T, List<T>>): T;
};

See Also
- _.reduceRight

interface Collection

interface Collection<T> {}

method reject

reject: (predicate?: ListIterateeCustom<T, boolean>) => Collection<T>;

See Also
- _.reject

interface Collection

interface Collection<T> {}

method sample

sample: () => T | undefined;

See Also
- _.sample

interface Collection

interface Collection<T> {}

method sampleSize

sampleSize: (n?: number) => Collection<T>;

See Also
- _.sampleSize

interface Collection

interface Collection<T> {}

method shuffle

shuffle: () => Collection<T>;

See Also
- _.shuffle

interface Collection

interface Collection<T> {}

method some

some: (predicate?: ListIterateeCustom<T, boolean>) => boolean;

See Also
- _.some

interface Collection

interface Collection<T> {}

method sortBy

sortBy: (...iteratees: Array<Many<ListIteratee<T>>>) => Collection<T>;

See Also
- _.sortBy

interface Collection

interface Collection<T> {}

method castArray

castArray: () => Collection<T>;

See Also
- _.castArray

interface Collection

interface Collection<T> {}

method toArray

toArray: () => Collection<T>;

See Also
- _.toArray

interface Collection

interface Collection<T> {}

method max

max: () => T | undefined;

See Also
- _.max

interface Collection

interface Collection<T> {}

method maxBy

maxBy: (iteratee?: ValueIteratee<T>) => T | undefined;

See Also
- _.maxBy

interface Collection

interface Collection<T> {}

method meanBy

meanBy: (iteratee?: ValueIteratee<T>) => number;

See Also
- _.meanBy

interface Collection

interface Collection<T> {}

method min

min: () => T | undefined;

See Also
- _.min

interface Collection

interface Collection<T> {}

method minBy

minBy: (iteratee?: ValueIteratee<T>) => T | undefined;

See Also
- _.minBy

interface Collection

interface Collection<T> {}

method sumBy

sumBy: (iteratee?: string | ((value: T) => number)) => number;

See Also
- _.sumBy

interface Collection

interface Collection<T> {}

method at

at: (...props: PropertyPath[]) => Collection<T>;

See Also
- _.at

interface Collection

interface Collection<T> {}

method get

get: {
    (path: number): T;
    <TDefault>(path: number, defaultValue: TDefault): T | TDefault;
};

See Also
- _.get

interface Collection

interface Collection<T> {}

method invertBy

invertBy: (iteratee?: ValueIteratee<T>) => Object<Dictionary<string[]>>;

See Also
- _.invertBy

interface Collection

interface Collection<T> {}

method mapKeys

mapKeys: (iteratee?: ListIteratee<T>) => Object<Dictionary<T>>;

See Also
- _.mapKeys

interface Collection

interface Collection<T> {}

method mapValues

mapValues: {
    <TResult>(callback: DictionaryIterator<T, TResult>): Object<
        Dictionary<TResult>
    >;
    <TKey extends keyof T>(iteratee: TKey): Object<Dictionary<T[TKey]>>;
    (iteratee: object): Object<Dictionary<boolean>>;
    (iteratee: string): Object<Dictionary<any>>;
    (): Object<Dictionary<T>>;
};

See Also
- _.mapValues

interface Collection

interface Collection<T> {}

method omit

omit: (...paths: Array<Many<PropertyName>>) => Collection<T>;

See Also
- _.omit

interface Collection

interface Collection<T> {}

method omitBy

omitBy: (predicate?: ValueKeyIteratee<T>) => Object<Dictionary<T>>;

See Also
- _.omitBy

interface Collection

interface Collection<T> {}

method pickBy

pickBy: {
    <S extends T>(predicate: ValueKeyIterateeTypeGuard<T, S>): Object<
        Dictionary<S>
    >;
    (predicate?: ValueKeyIteratee<T>): Object<Dictionary<T>>;
};

See Also
- _.pickBy

interface Collection

interface Collection<T> {}

method transform

transform: {
    <TResult>(
        iteratee: MemoVoidArrayIterator<T, TResult>,
        accumulator?: TResult
    ): ImpChain<TResult>;
    (): Collection<any>;
};

See Also
- _.transform

interface Collection

interface Collection<T> {}

method chain

chain: () => CollectionChain<T>;

See Also
- _.chain

interface Collection

interface Collection<T> {}

method iteratee

iteratee: () => Function<(o: object) => boolean>;

See Also
- _.iteratee

interface Collection

interface Collection<T> {}

method over

over: <TResult>(
    ...iteratees: Many<(...args: any[]) => TResult>[]
) => Function<(...args: any[]) => TResult[]>;

See Also
- _.over

interface Collection

interface Collection<T> {}

method overEvery

overEvery: <TArgs>(
    ...iteratees: Many<(...args: TArgs[]) => boolean>[]
) => Function<(...args: TArgs[]) => boolean>;

See Also
- _.overEvery

interface Collection

interface Collection<T> {}

method overSome

overSome: <TArgs>(
    ...iteratees: Many<(...args: TArgs[]) => boolean>[]
) => Function<(...args: TArgs[]) => boolean>;

See Also
- _.overSome

interface CollectionChain

interface CollectionChain<T> {}

method pop

pop: () => ExpChain<T | undefined>;

method push

push: (...items: T[]) => this;

method shift

shift: () => ExpChain<T | undefined>;

method sort

sort: (compareFn?: (a: T, b: T) => number) => this;

method splice

splice: (start: number, deleteCount?: number, ...items: T[]) => this;

method unshift

unshift: (...items: T[]) => this;

interface CollectionChain

interface CollectionChain<T> extends LoDashExplicitWrapper<T[]> {}

interface CollectionChain

interface CollectionChain<T> {}

method chunk

chunk: (size?: number) => CollectionChain<T[]>;

See Also
- _.chunk

interface CollectionChain

interface CollectionChain<T> {}

method compact

compact: () => CollectionChain<Truthy<T>>;

See Also
- _.compact

interface CollectionChain

interface CollectionChain<T> {}

method concat

concat: (...values: Array<Many<T>>) => CollectionChain<T>;

See Also
- _.concat

interface CollectionChain

interface CollectionChain<T> {}

method difference

difference: (...values: Array<List<T>>) => CollectionChain<T>;

See Also
- _.difference

interface CollectionChain

interface CollectionChain<T> {}

method differenceBy

differenceBy: {
    <T2>(
        values1: List<T2>,
        iteratee?: ValueIteratee<T | T2>
    )

@types/lodash

Install

Overview

Index

Interfaces

Type Aliases

Namespaces

Interfaces

interface Collection

method pop

method push

method shift

method sort

method splice

method unshift

interface Collection

interface Collection

method chunk

See Also

interface Collection

method compact

See Also

interface Collection

method concat

See Also

interface Collection

method difference

See Also

interface Collection

method differenceBy

See Also

interface Collection

method differenceWith

See Also

interface Collection

method drop

See Also

interface Collection

method dropRight

See Also

interface Collection

method dropRightWhile

See Also

interface Collection

method dropWhile

See Also

interface Collection

method fill

See Also

interface Collection

method findIndex

See Also

interface Collection

method findLastIndex

See Also

interface Collection

method first

See Also

interface Collection

method flatten

See Also

interface Collection

method flattenDeep

See Also

interface Collection

method flattenDepth

See Also

interface Collection

method fromPairs

See Also

interface Collection

method head

See Also

interface Collection

method indexOf

See Also

interface Collection

method initial

See Also

interface Collection