import { Comparator } from '../core/Comparator';
import { Func, Predicate } from '../core/Func';
import { IEnumerable } from '../core/IEnumerable';
import { IGroup } from './IGroup';
import { IOrderedQueryable } from './IOrderedQueryable';
import { IQueryable } from './IQuerable';
import { IList } from '../collections/IList';
import { ICollection } from '../collections/ICollection';
export declare class Enumerable<T> implements IQueryable<T> {
    private enumerable;
    private options?;
    collect<U>(factory?: (...args: any[]) => U): U;
    static from<TSource>(enumerable: IEnumerable<TSource> | Iterable<TSource>): IQueryable<TSource>;
    static repeat<TSource>(result: TSource | Function, count: number): IQueryable<TSource>;
    static range(start: number, count: number, step?: number): IQueryable<number>;
    protected static comparator<TSource>(a: TSource, b: TSource): number;
    protected static equalityComparator(a: any, b: any): number;
    protected static selector<TSource>(t: TSource): TSource;
    constructor(enumerable: IEnumerable<any> | Iterable<any>, options?: {});
    aggregate(action: (seed: T, item: T, index?: number, source?: IEnumerable<T>) => T, seed?: T): T;
    all(predicate?: Predicate<T>): boolean;
    any(predicate?: Predicate<T>): boolean;
    first(predicate?: Predicate<T>, defValue?: T): T;
    last(predicate?: Predicate<T>, defValue?: T): T;
    single(predicate: Predicate<T>, defValue?: T): T;
    contains(item: T): boolean;
    isEmpty(): boolean;
    skip(count: number): IQueryable<T>;
    skipWhile(predicate: Predicate<T>): IQueryable<T>;
    take(count: number): IQueryable<T>;
    takeWhile(predicate: Predicate<T>): IQueryable<T>;
    distinct(): IQueryable<T>;
    reverse(): IQueryable<T>;
    shuffles(count?: number): IQueryable<T>;
    asEnumerable(): IEnumerable<T>;
    select<TResult>(selector?: Func<TResult, T>): IQueryable<TResult>;
    selectMany<TCollection, TResult>(selector: Func<IEnumerable<TResult>, T>, collectionSelector?: Func<TResult, TCollection>): IQueryable<TResult>;
    indexOf(item: T): number;
    lastIndexOf(item: T): number;
    join<TOuter, TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerSelector: Func<TKey, TOuter>, innerSelector: Func<TKey, TInner>, resultSelector: (outerItem: TOuter, innerItem: TInner) => TResult): IQueryable<TResult>;
    where(predicate: Predicate<T>): IQueryable<T>;
    except(predicate: Predicate<T>): IQueryable<T>;
    orderBy<TSelected>(selector: Func<TSelected, T>, comparator?: Comparator<T, T>): IOrderedQueryable<T>;
    orderByDesc<TSelected>(selector: Func<TSelected, T>, comparator?: Comparator<T, T>): IOrderedQueryable<T>;
    private internalGroupBy;
    groupBy<TKey>(keySelector: Func<TKey, T>): IQueryable<IGroup<TKey, T>>;
    count(predicate?: Predicate<T>): number;
    average(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    max(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    min(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    sum(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    stdDev(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    stdDevP(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    variance(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    rootMeanSquare(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    covariance(other: IQueryable<T>, selector?: Func<number, T>, predicate?: Predicate<T>): number;
    pearson(other: IQueryable<T>, selector?: Func<number, T>, predicate?: Predicate<T>): number;
    varianceP(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    percentile(percentile: number, selector?: Func<number, T>, predicate?: Predicate<T>): number;
    percentileInclusive(percentile: number, selector?: Func<number, T>, predicate?: Predicate<T>): number;
    percentileExclusive(percentile: number, selector?: Func<number, T>, predicate?: Predicate<T>): number;
    percentRank(value: number, selector?: Func<number, T>, predicate?: Predicate<T>): number;
    mean(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    median(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    mode(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    range(selector?: Func<number, T>, predicate?: Predicate<T>): number;
    get(index: number): T;
    forEach(action: (element: T, index: number) => void): void;
    toArray(): T[];
    toList(): IList<T>;
    toCollection(): ICollection<T>;
    intersect(source: IEnumerable<T>, equalityComparator?: Comparator<T, T>): IQueryable<T>;
    subtract(source: IEnumerable<T>, equalityComparator?: Comparator<T, T>): IQueryable<T>;
    union(source: IEnumerable<T>, equalityComparator?: Comparator<T, T>): IQueryable<T>;
    zip<TSecond, TResult>(second: IEnumerable<TSecond>, selector: (tfirst: T, tsecond: TSecond) => TResult): IQueryable<TResult>;
    [Symbol.iterator](): Iterator<T>;
}
export declare class OrderedEnumerable<T> extends Enumerable<T> implements IOrderedQueryable<T> {
    constructor(enumerable: IEnumerable<any> | Iterable<any>, options?: {});
    thenBy<TSelected>(selector: (item: T) => TSelected, comparator?: (a: any, b: any) => number): IOrderedQueryable<T>;
    thenByDesc<TSelected>(selector: (item: T) => TSelected, comparator?: (a: any, b: any) => number): IOrderedQueryable<T>;
}