ts-generic-collections-linq/lib/list.d.ts

TypeScript library provides strongly-typed, queryable collections.

import { IEnumerable, IComparer, IEqualityComparer } from './interfaces';
import { Group } from './common';
export interface IList<T> extends IEnumerable<T> {
    add(item: T): void;
    addRange(items: T[]): void;
    remove(predicate: (item: T) => boolean): void;
    removeAt(index: number): void;
    clear(): void;
}
export declare class List<T> implements IList<T> {
    private list;
    constructor(array?: Array<T>);
    add(item: T): void;
    addRange(items: T[]): void;
    remove(predicate: (item: T) => boolean): void;
    removeAt(index: number): void;
    clear(): void;
    asEnumerable(): IEnumerable<T>;
    readonly length: number;
    elementAt(index: number): T;
    any(predicate?: (item: T) => boolean): boolean;
    all(predicate?: (item: T) => boolean): boolean;
    single(predicate?: (item: T) => boolean): T;
    first(predicate?: (item: T) => boolean): T;
    last(predicate?: (item: T) => boolean): T;
    singleOrDefault(predicate: (item: T) => boolean): T;
    firstOrDefault(predicate: (item: T) => boolean): T;
    lastOrDefault(predicate: (item: T) => boolean): T;
    where(predicate: (item: T) => boolean): IEnumerable<T>;
    select<TResult>(predicate: (item: T) => TResult): IEnumerable<TResult>;
    forEach(predicate: (item: T) => void): void;
    toArray(): Array<T>;
    join<TOuter, TMatch, TResult>(outer: IEnumerable<TOuter>, conditionInner: (item: T) => TMatch, conditionOuter: (item: TOuter) => TMatch, select: (x: T, y: TOuter) => TResult, leftJoin?: boolean): IEnumerable<TResult>;
    groupBy(predicate: (item: T) => Array<any>): IEnumerable<Group<T>>;
    selectMany<TResult>(predicate: (item: T) => Array<TResult>): IEnumerable<TResult>;
    orderBy(comparer: IComparer<T>): IEnumerable<T>;
    union(list: IEnumerable<T>): IEnumerable<T>;
    reverse(): IEnumerable<T>;
    distinct(comparer: IEqualityComparer<T>): IEnumerable<T>;
    skip(no: number): IEnumerable<T>;
    take(no: number): IEnumerable<T>;
    sum(predicate: (item: T) => number): number;
    avg(predicate: (item: T) => number): number;
    min(predicate: (item: T) => number): number;
    max(predicate: (item: T) => number): number;
    count(predicate?: (item: T) => boolean): number;
}