import { Dictionary } from './dictionary';
import { IEnumerable } from './enumerable';
import { IEqualityComparer } from './equality-comparer';
import { IGrouping } from './grouping';
import { IList, List } from './list';
export interface IReadOnlyCollection<T> extends IEnumerable<T> {
}
export declare class ReadOnlyCollection<T> implements IReadOnlyCollection<T>, IList<T> {
    private list;
    constructor(list: IList<T>);
    get Length(): number;
    get IsReadOnly(): boolean;
    Set(index: number, item: T): void;
    Get(index: number): T;
    Add(item: T): void;
    Clear(): void;
    CopyTo(array: T[], arrayIndex: number): void;
    IndexOf(item: T): number;
    Insert(index: number, item: T): void;
    Remove(item: T): boolean;
    RemoveAt(index: number): void;
    [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>;
}