import { Dictionary } from './dictionary';
import { IEnumerable } from './enumerable';
import { IEqualityComparer } from './equality-comparer';
import { List } from './list';
export interface IGrouping<TKey, TElement> extends IEnumerable<TElement> {
    readonly Key: TKey;
    readonly Items: IEnumerable<TElement>;
}
export declare class Grouping<TKey, TElement> implements IGrouping<TKey, TElement> {
    private key;
    private source;
    constructor(key: TKey, source: IEnumerable<TElement>);
    get Key(): TKey;
    get Items(): IEnumerable<TElement>;
    [Symbol.iterator](): IterableIterator<TElement>;
    All(predicate: (item: TElement) => boolean): boolean;
    Any(predicate?: (item: TElement) => boolean): boolean;
    AsEnumerable(): IEnumerable<TElement>;
    Average(selector?: (item: TElement) => number): number | null;
    Concat(second: IEnumerable<TElement>): IEnumerable<TElement>;
    Contains(value: TElement, comparer?: IEqualityComparer<TElement>): boolean;
    Count(predicate?: (item: TElement) => boolean): number;
    DefaultIfEmpty(defaultValue?: IEnumerable<TElement>): IEnumerable<TElement>;
    Distinct(comparer?: IEqualityComparer<TElement>): IEnumerable<TElement>;
    ElementAt(index: number): TElement;
    ElementAtOrDefault(defaultValue: TElement, index: number): TElement;
    Except(second: IEnumerable<TElement>, comparer?: IEqualityComparer<TElement>): IEnumerable<TElement>;
    First(predicate?: (item: TElement) => boolean): TElement;
    FirstOrDefault(defaultValue: TElement, predicate?: (item: TElement) => boolean): TElement;
    GroupBy<TKey, TGroupElement = TElement>(keySelector: (item: TElement) => TKey, elementSelector?: (item: TElement) => TGroupElement, comparer?: IEqualityComparer<TKey>): IEnumerable<IGrouping<TKey, TGroupElement>>;
    GroupJoin<TInner, TKey, TResult = {
        Outer: TElement;
        Inners: IEnumerable<TInner>;
    }>(inner: IEnumerable<TInner>, outerKeySelector: (item: TElement) => TKey, innerKeySelector: (item: TInner) => TKey, resultSelector?: (item: TElement, inners: IEnumerable<TInner>) => TResult, comparer?: IEqualityComparer<TKey>): IEnumerable<TResult>;
    Intersect(second: IEnumerable<TElement>, comparer?: IEqualityComparer<TElement>): IEnumerable<TElement>;
    Join<TInner, TKey, TResult = {
        Outer: TElement;
        Inner: TInner;
    }>(inner: IEnumerable<TInner>, outerKeySelector: (item: TElement) => TKey, innerKeySelector: (item: TInner) => TKey, resultSelector?: (item: TElement, inners: TInner) => TResult, comparer?: IEqualityComparer<TKey>): IEnumerable<TResult>;
    Last(predicate?: (item: TElement) => boolean): TElement;
    LastOrDefault(defaultValue: TElement, predicate?: (item: TElement) => boolean): TElement;
    Max(selector?: (item: TElement) => number): number | null;
    Min(selector?: (item: TElement) => number): number | null;
    Reverse(): IEnumerable<TElement>;
    Select<TResult>(selector: (item: TElement, index?: number) => TResult): IEnumerable<TResult>;
    SelectMany<TCollection, TResult = TCollection>(collectionSelector: (item: TElement, index?: number) => IEnumerable<TCollection>, resultSelector?: (item: TElement, collection: TCollection) => TResult): IEnumerable<TResult>;
    SequenceEqual(second: Iterable<TElement>, comparer?: IEqualityComparer<TElement>): boolean;
    Single(predicate?: (item: TElement) => boolean): TElement;
    SingleOrDefault(defaultValue: TElement, predicate?: (item: TElement) => boolean): TElement;
    Skip(count: number): IEnumerable<TElement>;
    SkipWhile(predicate: (item: TElement, index?: number) => boolean): IEnumerable<TElement>;
    Sum(selector?: (item: TElement) => number): number | null;
    Take(count: number): IEnumerable<TElement>;
    TakeWhile(predicate: (item: TElement, index?: number) => boolean): IEnumerable<TElement>;
    ToArray(): Array<TElement>;
    ToDictionary<TKey, TDictionaryElement = TElement>(keySelector: (item: TElement) => TKey, elementSelector?: (item: TElement) => TDictionaryElement, comparer?: IEqualityComparer<TKey>): Dictionary<TKey, TDictionaryElement>;
    ToList(): List<TElement>;
    Union(second: Iterable<TElement>, comparer?: IEqualityComparer<TElement>): IEnumerable<TElement>;
    Where(predicate: (item: TElement, index?: number) => boolean): IEnumerable<TElement>;
}