import { ICollection } from './collection';
import { Dictionary } from './dictionary';
import { IEnumerable } from './enumerable';
import { IEqualityComparer } from './equality-comparer';
import { IGrouping } from './grouping';
import { Predicate } from './predicate';
import { ReadOnlyCollection } from './read-only-collection';
export interface IList<T> extends IEnumerable<T>, ICollection<T> {
    Set(index: number, item: T): void;
    Get(index: number): T;
    IndexOf(item: T): number;
    Insert(index: number, item: T): void;
    RemoveAt(index: number): void;
}
export declare class List<T> implements IList<T> {
    private items;
    constructor(collection?: Iterable<T>);
    get Length(): number;
    get IsReadOnly(): boolean;
    Set(index: number, item: T): void;
    Get(index: number): T;
    Add(item: T): void;
    AddRange(collection: Iterable<T>): void;
    AsReadOnly(): ReadOnlyCollection<T>;
    Clear(): void;
    CopyTo(array: T[], arrayIndex: number): void;
    Exists(match: Predicate<T>): boolean;
    Find(match: Predicate<T>): T;
    FindAll(match: Predicate<T>): List<T>;
    FindIndex(startIndex: number, count: number, match: Predicate<T>): number;
    FindLast(match: Predicate<T>): T;
    FindLastIndex(startIndex: number, count: number, match: Predicate<T>): number;
    GetRange(index: number, count: number): List<T>;
    IndexOf(item: T): number;
    Insert(index: number, item: T): void;
    Remove(item: T): boolean;
    RemoveAt(index: number): void;
    TrueForAll(match: Predicate<T>): boolean;
    [Symbol.iterator](): IterableIterator<T>;
    All(predicate: (item: T) => boolean): boolean;
    Any(predicate?: (item: T) => boolean): boolean;
    AsEnumerable(): IEnumerable<T>;
    Average(selector?: (item: T) => number): number | null;
    Concat(second: IEnumerable<T>): IEnumerable<T>;
    Contains(value: T, comparer?: IEqualityComparer<T>): boolean;
    Count(predicate?: (item: T) => boolean): number;
    DefaultIfEmpty(defaultValue?: IEnumerable<T>): IEnumerable<T>;
    Distinct(comparer?: IEqualityComparer<T>): IEnumerable<T>;
    ElementAt(index: number): T;
    ElementAtOrDefault(defaultValue: T, index: number): T;
    Except(second: IEnumerable<T>, comparer?: IEqualityComparer<T>): IEnumerable<T>;
    First(predicate?: (item: T) => boolean): T;
    FirstOrDefault(defaultValue: T, predicate?: (item: T) => boolean): T;
    GroupBy<TKey, TElement = T>(keySelector: (item: T) => TKey, elementSelector?: (item: T) => TElement, comparer?: IEqualityComparer<TKey>): IEnumerable<IGrouping<TKey, TElement>>;
    GroupJoin<TInner, TKey, TResult = {
        Outer: T;
        Inners: IEnumerable<TInner>;
    }>(inner: IEnumerable<TInner>, outerKeySelector: (item: T) => TKey, innerKeySelector: (item: TInner) => TKey, resultSelector?: (item: T, inners: IEnumerable<TInner>) => TResult, comparer?: IEqualityComparer<TKey>): IEnumerable<TResult>;
    Intersect(second: IEnumerable<T>, comparer?: IEqualityComparer<T>): IEnumerable<T>;
    Join<TInner, TKey, TResult = {
        Outer: T;
        Inner: TInner;
    }>(inner: IEnumerable<TInner>, outerKeySelector: (item: T) => TKey, innerKeySelector: (item: TInner) => TKey, resultSelector?: (item: T, inners: TInner) => TResult, comparer?: IEqualityComparer<TKey>): IEnumerable<TResult>;
    Last(predicate?: (item: T) => boolean): T;
    LastOrDefault(defaultValue: T, predicate?: (item: T) => boolean): T;
    Max(selector?: (item: T) => number): number | null;
    Min(selector?: (item: T) => number): number | null;
    Reverse(): IEnumerable<T>;
    Select<TResult>(selector: (item: T, index?: number) => TResult): IEnumerable<TResult>;
    SelectMany<TCollection, TResult = TCollection>(collectionSelector: (item: T, index?: number) => IEnumerable<TCollection>, resultSelector?: (item: T, collection: TCollection) => TResult): IEnumerable<TResult>;
    SequenceEqual(second: Iterable<T>, comparer?: IEqualityComparer<T>): boolean;
    Single(predicate?: (item: T) => boolean): T;
    SingleOrDefault(defaultValue: T, predicate?: (item: T) => boolean): T;
    Skip(count: number): IEnumerable<T>;
    SkipWhile(predicate: (item: T, index?: number) => boolean): IEnumerable<T>;
    Sum(selector?: (item: T) => number): number | null;
    Take(count: number): IEnumerable<T>;
    TakeWhile(predicate: (item: T, index?: number) => boolean): IEnumerable<T>;
    ToArray(): Array<T>;
    ToDictionary<TKey, TElement = T>(keySelector: (item: T) => TKey, elementSelector?: (item: T) => TElement, comparer?: IEqualityComparer<TKey>): Dictionary<TKey, TElement>;
    ToList(): List<T>;
    Union(second: Iterable<T>, comparer?: IEqualityComparer<T>): IEnumerable<T>;
    Where(predicate: (item: T, index?: number) => boolean): IEnumerable<T>;
}