import './array';
import { Dictionary } from './dictionary';
import * as enumerables from './enumerables';
import { IEqualityComparer } from './equality-comparer';
import { IGrouping } from './grouping';
import { List } from './list';
export interface IEnumerable<TSource> extends Iterable<TSource> {
    [Symbol.iterator](): IterableIterator<TSource>;
    All(predicate: (item: TSource) => boolean): boolean;
    Any(predicate?: (item: TSource) => boolean): boolean;
    AsEnumerable(): IEnumerable<TSource>;
    Average(selector?: (item: TSource) => number): number | null;
    Concat(second: IEnumerable<TSource>): IEnumerable<TSource>;
    Contains(value: TSource, comparer?: IEqualityComparer<TSource>): boolean;
    Count(predicate?: (item: TSource) => boolean): number;
    DefaultIfEmpty(defaultValue?: IEnumerable<TSource>): IEnumerable<TSource>;
    Distinct(comparer?: IEqualityComparer<TSource>): IEnumerable<TSource>;
    ElementAt(index: number): TSource;
    ElementAtOrDefault(defaultValue: TSource, index: number): TSource;
    Except(second: IEnumerable<TSource>, comparer?: IEqualityComparer<TSource>): IEnumerable<TSource>;
    First(predicate?: (item: TSource) => boolean): TSource;
    FirstOrDefault(defaultValue: TSource, predicate?: (item: TSource) => boolean): TSource;
    GroupBy<TKey, TElement = TSource>(keySelector: (item: TSource) => TKey, elementSelector?: (item: TSource) => TElement, comparer?: IEqualityComparer<TKey>): IEnumerable<IGrouping<TKey, TElement>>;
    GroupJoin<TInner, TKey, TResult = {
        Outer: TSource;
        Inners: IEnumerable<TInner>;
    }>(inner: IEnumerable<TInner>, outerKeySelector: (item: TSource) => TKey, innerKeySelector: (item: TInner) => TKey, resultSelector?: (item: TSource, inners: IEnumerable<TInner>) => TResult, comparer?: IEqualityComparer<TKey>): IEnumerable<TResult>;
    Intersect(second: IEnumerable<TSource>, comparer?: IEqualityComparer<TSource>): IEnumerable<TSource>;
    Join<TInner, TKey, TResult = {
        Outer: TSource;
        Inner: TInner;
    }>(inner: IEnumerable<TInner>, outerKeySelector: (item: TSource) => TKey, innerKeySelector: (item: TInner) => TKey, resultSelector?: (item: TSource, inners: TInner) => TResult, comparer?: IEqualityComparer<TKey>): IEnumerable<TResult>;
    Last(predicate?: (item: TSource) => boolean): TSource;
    LastOrDefault(defaultValue: TSource, predicate?: (item: TSource) => boolean): TSource;
    Max(selector?: (item: TSource) => number): number | null;
    Min(selector?: (item: TSource) => number): number | null;
    Reverse(): IEnumerable<TSource>;
    Select<TResult>(selector: (item: TSource, index?: number) => TResult): IEnumerable<TResult>;
    SelectMany<TCollection, TResult = TCollection>(collectionSelector: (item: TSource, index?: number) => IEnumerable<TCollection>, resultSelector?: (item: TSource, collection: TCollection) => TResult): IEnumerable<TResult>;
    SequenceEqual(second: Iterable<TSource>, comparer?: IEqualityComparer<TSource>): boolean;
    Single(predicate?: (item: TSource) => boolean): TSource;
    SingleOrDefault(defaultValue: TSource, predicate?: (item: TSource) => boolean): TSource;
    Skip(count: number): IEnumerable<TSource>;
    SkipWhile(predicate: (item: TSource, index?: number) => boolean): IEnumerable<TSource>;
    Sum(selector?: (item: TSource) => number): number | null;
    Take(count: number): IEnumerable<TSource>;
    TakeWhile(predicate: (item: TSource, index?: number) => boolean): IEnumerable<TSource>;
    ToArray(): Array<TSource>;
    ToDictionary<TKey, TElement = TSource>(keySelector: (item: TSource) => TKey, elementSelector?: (item: TSource) => TElement, comparer?: IEqualityComparer<TKey>): Dictionary<TKey, TElement>;
    ToList(): List<TSource>;
    Union(second: Iterable<TSource>, comparer?: IEqualityComparer<TSource>): IEnumerable<TSource>;
    Where(predicate: (item: TSource, index?: number) => boolean): IEnumerable<TSource>;
}
export declare class Enumerable {
    static AsEnumerable: typeof enumerables.asEnumerable;
    static All: typeof enumerables.all;
    static Any: typeof enumerables.any;
    static Average: typeof enumerables.average;
    static Concat: typeof enumerables.concat;
    static Contains: typeof enumerables.contains;
    static Count: typeof enumerables.count;
    static DefaultIfEmpty: typeof enumerables.defaultIfEmpty;
    static Distinct: typeof enumerables.distinct;
    static ElementAt: typeof enumerables.elementAt;
    static ElementAtOrDefault: typeof enumerables.elementAtOrDefault;
    static Empty: typeof enumerables.empty;
    static Except: typeof enumerables.except;
    static First: typeof enumerables.first;
    static FirstOrDefault: typeof enumerables.firstOrDefault;
    static GroupBy: typeof enumerables.groupBy;
    static GroupJoin: typeof enumerables.groupJoin;
    static Intersect: typeof enumerables.intersect;
    static Join: typeof enumerables.join;
    static Last: typeof enumerables.last;
    static LastOrDefault: typeof enumerables.lastOrDefault;
    static Max: typeof enumerables.max;
    static Min: typeof enumerables.min;
    static Reverse: typeof enumerables.reverse;
    static Select: typeof enumerables.select;
    static SelectMany: typeof enumerables.selectMany;
    static SequenceEqual: typeof enumerables.sequenceEqual;
    static Single: typeof enumerables.single;
    static SingleOrDefault: typeof enumerables.singleOrDefault;
    static Skip: typeof enumerables.skip;
    static SkipWhile: typeof enumerables.skipWhile;
    static Sum: typeof enumerables.sum;
    static Take: typeof enumerables.take;
    static TakeWhile: typeof enumerables.takeWhile;
    static ToArray: typeof enumerables.toArray;
    static ToDictionary: typeof enumerables.toDictionary;
    static ToList: typeof enumerables.toList;
    static Union: typeof enumerables.union;
    static Where: typeof enumerables.where;
}