@types/lodash

  • Version 4.14.170
  • Published
  • 858 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

Type Aliases

Namespaces

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>
                                                                                                                                                                                                                                                                              ): CollectionChain<