curray/types/index.d.ts

Curray is an extension library for the native JavaScript Array object.

import { OrderedArray } from './helpers';
declare global {
    export interface Array<T> {
        addRange<T>(elements: T[]): void;
        aggregate<U, R>(accumulator: (accum: U, value?: T, index?: number, list?: T[]) => R, initialValue?: U): R;
        all(predicate: (value: T, index?: number, list?: T[]) => boolean): boolean;
        any(): boolean;
        any(predicate: (value: T, index?: number, list?: T[]) => boolean): boolean;
        any(predicate?: (value?: T, index?: number, list?: T[]) => boolean): boolean;
        average(): number;
        average(transform: (value: T, index?: number, list?: T[]) => number): number;
        average(transform?: (value?: T, index?: number, list?: T[]) => number): number;
        cast<U>(): U[];
        contains(element: T): boolean;
        count(): number;
        count(predicate: (value: T, index?: number, list?: T[]) => boolean): number;
        count(predicate?: (value?: T, index?: number, list?: T[]) => boolean): number;
        defaultIfEmpty(defaultValue?: T): T[];
        distinctBy(keySelector: (key: T) => string | number): T[];
        elementAt(index: number): T;
        elementAtOrDefault(index: number): T | null;
        except(source: T[]): T[];
        first(): T;
        first(predicate: (value: T, index?: number, list?: T[]) => boolean): T;
        first(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T;
        firstOrDefault(): T | null;
        firstOrDefault(predicate: (value: T, index?: number, list?: T[]) => boolean): T | null;
        firstOrDefault(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T | null;
        groupBy<TResult = T>(grouper: (key: T) => string | number, mapper?: (element: T) => TResult): {
            [key: string]: TResult[];
        };
        groupJoin<U, TKey, TResult>(list: U[], key1: (k: T) => TKey, key2: (k: U) => TKey, result: (first: T, second: U[]) => TResult): TResult[];
        indexOf(element: T): number;
        insert(index: number, element: T): void | Error;
        intersect(source: T[]): T[];
        last(): T;
        last(predicate: (value: T, index?: number, list?: T[]) => boolean): T;
        last(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T;
        lastOrDefault(): T | null;
        lastOrDefault(predicate: (value: T, index?: number, list?: T[]) => boolean): T | null;
        lastOrDefault(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T | null;
        max(): number;
        max(selector: (value: T, index?: number, array?: T[]) => number): number;
        max(selector?: (value?: T, index?: number, array?: T[]) => number): number;
        min(): number;
        min(selector: (value: T, index?: number, array?: T[]) => number): number;
        min(selector?: (value?: T, index?: number, array?: T[]) => number): number;
        ofType<U>(type: unknown): U[];
        orderBy<TKey>(keySelector: (key: T) => TKey): OrderedArray<T, TKey>;
        orderByDescending<TKey>(keySelector: (key: T) => TKey): OrderedArray<T, TKey>;
        removeAll(predicate: (value: T, index?: number, list?: T[]) => boolean): T[];
        select<TOut>(selector: (element: T, index: number) => TOut): TOut[];
        selectMany<TResult>(selector: (element: T, index: number) => TResult[]): TResult[];
        sequenceEqual(list: T[]): boolean;
        single(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T;
        singleOrDefault(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T | null;
        skip(amount: number): T[];
        skipWhile(predicate: (value: T, index?: number, list?: T[]) => boolean): T[];
        sum(): number;
        sum(transform: (value: T, index?: number, list?: T[]) => number): number;
        sum(transform?: (value?: T, index?: number, list?: T[]) => number): number;
        take(amount: number): T[];
        takeWhile(predicate: (value: T, index?: number, list?: T[]) => boolean): T[];
        union(list: T[]): T[];
        where(predicate: (value: T, index?: number, list?: T[]) => boolean): T[];
        zip<U, T, TOut>(list: U[], result: (first: T, second: U) => TOut): TOut[];
    }
}
//# sourceMappingURL=index.d.ts.map