import { Observable } from '../observer';
import { NextObserver } from '../observer';
import { ErrorObserver } from '../observer';
import { CompletionObserver } from '../observer';
import { IterableX } from '../iterable';
import { GroupedIterable } from './groupby';
import { OrderedIterableX } from './orderby';
import { OrderedIterableBaseX } from './orderby';
export declare type IterableX<T> = IterableX<T>;
export declare type Observable<T> = Observable<T>;
export declare type NextObserver<T> = NextObserver<T>;
export declare type ErrorObserver<T> = ErrorObserver<T>;
export declare type CompletionObserver<T> = CompletionObserver<T>;
export declare type GroupedIterable<TKey, TValue> = GroupedIterable<TKey, TValue>;
export declare type OrderedIterableX<TKey, TSource> = OrderedIterableX<TKey, TSource>;
export declare type OrderedIterableBaseX<TSource> = OrderedIterableBaseX<TSource>;
declare const _default: {
    average: {
        (source: Iterable<number>, selector?: (x: number) => number): number;
        <T>(source: Iterable<T>, selector?: (x: T) => number): number;
    };
    buffer: <TSource>(source: Iterable<TSource>, count: number, skip?: number) => IterableX<TSource[]>;
    _case: <TSource, TResult>(selector: () => TSource, sources: Map<TSource, Iterable<TResult>>, defaultSource?: Iterable<TResult>) => IterableX<TResult>;
    _catch: <TSource>(source: Iterable<TSource>, ...args: Iterable<TSource>[]) => IterableX<TSource>;
    _catchStatic: <TSource>(...source: Iterable<TSource>[]) => IterableX<TSource>;
    catchWith: <TSource>(source: Iterable<TSource>, handler: (error: any) => Iterable<TSource>) => IterableX<TSource>;
    chain: <TSource, TResult>(source: Iterable<TSource>, selector: (source: Iterable<TSource>) => Iterable<TResult>) => IterableX<TResult>;
    concat: <T>(source: Iterable<T>, ...args: Iterable<T>[]) => IterableX<T>;
    concatAll: <TSource>(source: Iterable<Iterable<TSource>>) => IterableX<TSource>;
    concatStatic: <T>(...args: Iterable<T>[]) => IterableX<T>;
    count: <T>(source: Iterable<T>, predicate?: (value: T) => boolean) => number;
    create: <T>(getIterator: () => Iterator<T>) => IterableX<T>;
    defaultIfEmpty: <T>(source: Iterable<T>, defaultValue: T) => IterableX<T>;
    defer: <TSource>(factory: () => Iterable<TSource>) => IterableX<TSource>;
    distinct: <TSource, TKey>(source: Iterable<TSource>, keySelector?: (value: TSource) => TKey, comparer?: (x: TKey, y: TKey) => boolean) => IterableX<TSource>;
    distinctUntilChanged: <TSource, TKey>(source: Iterable<TSource>, keySelector?: (value: TSource) => TKey, comparer?: (first: TKey, second: TKey) => boolean) => IterableX<TSource>;
    doWhile: <TSource>(source: Iterable<TSource>, condition: () => boolean) => IterableX<TSource>;
    elementAt: <T>(source: Iterable<T>, index: number) => T;
    empty: <TSource>() => IterableX<TSource>;
    every: <T>(source: Iterable<T>, comparer: (value: T, index: number) => boolean) => boolean;
    except: <TSource>(first: Iterable<TSource>, second: Iterable<TSource>, comparer?: (x: TSource, y: TSource) => boolean) => IterableX<TSource>;
    expand: <TSource>(source: Iterable<TSource>, selector: (value: TSource) => Iterable<TSource>) => IterableX<TSource>;
    filter: <T>(source: Iterable<T>, predicate: (value: T, index: number) => boolean, thisArg?: any) => IterableX<T>;
    _finally: <TSource>(source: Iterable<TSource>, action: () => void) => IterableX<TSource>;
    find: <T>(source: Iterable<T>, predicate: (value: T, index: number) => boolean, thisArg?: any) => T;
    findIndex: <T>(source: Iterable<T>, fn: (value: T, index: number) => boolean, thisArg?: any) => number;
    first: <T>(source: Iterable<T>, selector?: (value: T) => boolean) => T;
    flatMap: <TSource, TResult>(source: Iterable<TSource>, selector: (value: TSource) => Iterable<TResult>, thisArg?: any) => IterableX<TResult>;
    flatten: <T>(source: Iterable<T>, depth?: number) => IterableX<T>;
    _for: <TSource, TResult>(source: Iterable<TSource>, resultSelector: (value: TSource) => Iterable<TResult>) => IterableX<TResult>;
    forEach: <TSource>(source: Iterable<TSource>, callback: (value: TSource, index: number) => void, thisArg?: any) => void;
    from: <TSource, TResult = TSource>(source: Iterable<TSource> | ArrayLike<TSource>, fn?: (value: TSource, index: number) => TResult, thisArg?: any) => IterableX<TResult>;
    generate: <TState, TResult>(initialState: TState, condition: (value: TState) => boolean, iterate: (value: TState) => TState, resultSelector: (value: TState) => TResult) => IterableX<TResult>;
    groupBy: {
        <TSource, TKey>(source: Iterable<TSource>, keySelector: (value: TSource) => TKey): IterableX<GroupedIterable<TKey, TSource>>;
        <TSource, TKey, TValue>(source: Iterable<TSource>, keySelector: (value: TSource) => TKey, elementSelector?: (value: TSource) => TValue): IterableX<GroupedIterable<TKey, TValue>>;
        <TSource, TKey, TValue, TResult>(source: Iterable<TSource>, keySelector: (value: TSource) => TKey, elementSelector?: (value: TSource) => TValue, resultSelector?: (key: TKey, values: Iterable<TValue>) => TResult): IterableX<TResult>;
    };
    groupJoin: <TOuter, TInner, TKey, TResult>(outer: Iterable<TOuter>, inner: Iterable<TInner>, outerSelector: (value: TOuter) => TKey, innerSelector: (value: TInner) => TKey, resultSelector: (outer: TOuter, inner: Iterable<TInner>) => TResult) => IterableX<TResult>;
    _if: <TSource>(fn: () => boolean, thenSource: Iterable<TSource>, elseSource?: Iterable<TSource>) => IterableX<TSource>;
    ignoreElements: <TSource>(source: Iterable<TSource>) => IterableX<TSource>;
    includes: <T>(source: Iterable<T>, searchElement: T, fromIndex?: number) => boolean;
    innerJoin: <TOuter, TInner, TKey, TResult>(outer: Iterable<TOuter>, inner: Iterable<TInner>, outerSelector: (value: TOuter) => TKey, innerSelector: (value: TInner) => TKey, resultSelector: (outer: TOuter, inner: TInner) => TResult) => IterableX<TResult>;
    intersect: <TSource>(first: Iterable<TSource>, second: Iterable<TSource>, comparer?: (x: TSource, y: TSource) => boolean) => IterableX<TSource>;
    isEmpty: <T>(source: Iterable<T>) => boolean;
    last: <T>(source: Iterable<T>, fn?: (value: T) => boolean) => T;
    map: <TSource, TResult>(source: Iterable<TSource>, selector: (value: TSource, index: number) => TResult, thisArg?: any) => IterableX<TResult>;
    max: {
        (source: Iterable<number>, fn?: (x: number) => number): number;
        <T>(source: Iterable<T>, fn: (x: T) => number): number;
    };
    maxBy: <TSource, TKey>(source: Iterable<TSource>, keySelector: (x: TSource) => TKey, comparer?: (x: TKey, y: TKey) => number) => IterableX<TSource>;
    memoize: {
        <TSource>(source: Iterable<TSource>, readerCount?: number): IterableX<TSource>;
        <TSource, TResult>(source: Iterable<TSource>, readerCount?: number, selector?: (value: Iterable<TSource>) => Iterable<TResult>): IterableX<TResult>;
    };
    min: {
        (source: Iterable<number>, fn?: (x: number) => number): number;
        <T>(source: Iterable<T>, fn: (x: T) => number): number;
    };
    minBy: <TSource, TKey>(source: Iterable<TSource>, keySelector: (x: TSource) => TKey, comparer?: (x: TKey, y: TKey) => number) => IterableX<TSource>;
    of: <TSource>(...args: TSource[]) => IterableX<TSource>;
    ofEntries: <TSource>(source: {
        [key: string]: TSource;
    }) => IterableX<[string, TSource]>;
    ofKeys: <TSource>(source: {
        [key: string]: TSource;
    }) => IterableX<string>;
    ofValues: <TSource>(source: {
        [key: string]: TSource;
    }) => IterableX<TSource>;
    onErrorResumeNext: <T>(source: Iterable<T>, ...args: Iterable<T>[]) => IterableX<T>;
    orderBy: <TKey, TSource>(source: Iterable<TSource>, keySelector: (item: TSource) => TKey, comparer?: (fst: TKey, snd: TKey) => number) => OrderedIterableX<TKey, TSource>;
    orderByDescending: <TKey, TSource>(source: Iterable<TSource>, keySelector: (item: TSource) => TKey, comparer?: (fst: TKey, snd: TKey) => number) => OrderedIterableX<TKey, TSource>;
    thenBy: <TKey, TSource>(source: OrderedIterableBaseX<TSource>, keySelector: (item: TSource) => TKey, comparer?: (fst: TKey, snd: TKey) => number) => OrderedIterableX<TKey, TSource>;
    thenByDescending: <TKey, TSource>(source: OrderedIterableBaseX<TSource>, keySelector: (item: TSource) => TKey, comparer?: (fst: TKey, snd: TKey) => number) => OrderedIterableX<TKey, TSource>;
    pairwise: <TSource>(source: Iterable<TSource>) => IterableX<TSource[]>;
    partition: <TSource>(source: Iterable<TSource>, predicate: (value: TSource, index: number) => boolean, thisArg?: any) => IterableX<TSource>[];
    pluck: <TSource, TResult>(source: Iterable<TSource>, ...args: string[]) => IterableX<TResult>;
    publish: {
        <TSource>(source: Iterable<TSource>): IterableX<TSource>;
        <TSource, TResult>(source: Iterable<TSource>, selector?: (value: Iterable<TSource>) => Iterable<TResult>): IterableX<TResult>;
    };
    range: (start: number, count: number) => IterableX<number>;
    reduce: {
        <T>(source: Iterable<T>, accumulator: (acc: T, value: T, index: number) => T, seed?: T): T;
        <T>(source: Iterable<T>, accumulator: (acc: T[], value: T, index: number) => T[], seed?: T[]): T[];
        <T, R>(source: Iterable<T>, accumulator: (acc: R, value: T, index: number) => R, seed?: R): R;
    };
    reduceRight: {
        <T>(source: Iterable<T>, accumulator: (acc: T, value: T, index: number) => T, seed?: T): T;
        <T>(source: Iterable<T>, accumulator: (acc: T[], value: T, index: number) => T[], seed?: T[]): T[];
        <T, R>(source: Iterable<T>, accumulator: (acc: R, value: T, index: number) => R, seed?: R): R;
    };
    repeat: <TSource>(source: Iterable<TSource>, count?: number) => IterableX<TSource>;
    repeatStatic: <TSource>(value: TSource, count?: number) => IterableX<TSource>;
    retry: <TSource>(source: Iterable<TSource>, count?: number) => IterableX<TSource>;
    reverse: <TSource>(source: Iterable<TSource>) => IterableX<TSource>;
    scan: {
        <T>(source: Iterable<T>, accumulator: (acc: T, value: T, index: number) => T): IterableX<T>;
        <T, R = T>(source: Iterable<T>, accumulator: (acc: R, value: T, index: number) => R, seed: R): IterableX<R>;
    };
    scanRight: {
        <T>(source: Iterable<T>, accumulator: (acc: T, value: T, index: number) => T): IterableX<T>;
        <T, R = T>(source: Iterable<T>, accumulator: (acc: R, value: T, index: number) => R, seed: R): IterableX<R>;
    };
    sequenceEqual: <T>(source: Iterable<T>, other: Iterable<T>, comparer?: (first: T, second: T) => boolean) => boolean;
    share: {
        <TSource>(source: Iterable<TSource>): IterableX<TSource>;
        <TSource, TResult>(source: Iterable<TSource>, fn?: (value: Iterable<TSource>) => Iterable<TResult>): IterableX<TResult>;
    };
    single: <T>(source: Iterable<T>, fn?: (value: T) => boolean) => T;
    skip: <TSource>(source: Iterable<TSource>, count: number) => IterableX<TSource>;
    skipLast: <TSource>(source: Iterable<TSource>, count: number) => IterableX<TSource>;
    skipWhile: <TSource>(source: Iterable<TSource>, predicate: (value: TSource, index: number) => boolean) => IterableX<TSource>;
    slice: <TSource>(source: Iterable<TSource>, begin: number, end?: number) => IterableX<TSource>;
    some: <T>(source: Iterable<T>, comparer: (value: T, index: number) => boolean) => boolean;
    startWith: <TSource>(source: Iterable<TSource>, ...args: TSource[]) => IterableX<TSource>;
    sum: {
        (source: Iterable<number>, fn?: (x: number) => number): number;
        <T>(source: Iterable<T>, fn: (x: T) => number): number;
    };
    take: <TSource>(source: Iterable<TSource>, count: number) => IterableX<TSource>;
    takeLast: <TSource>(source: Iterable<TSource>, count: number) => IterableX<TSource>;
    takeWhile: <TSource>(source: Iterable<TSource>, predicate: (value: TSource, index: number) => boolean) => IterableX<TSource>;
    tap: <TSource>(source: Iterable<TSource>, observer: NextObserver<TSource> | ErrorObserver<TSource> | CompletionObserver<TSource>) => IterableX<TSource>;
    _throw: <TSource>(error: any) => IterableX<TSource>;
    toArray: <TSource>(source: Iterable<TSource>) => TSource[];
    toMap: {
        <TSource, TKey>(source: Iterable<TSource>, keySelector: (item: TSource) => TKey): Map<TKey, TSource>;
        <TSource, TKey, TElement = TSource>(source: Iterable<TSource>, keySelector: (item: TSource) => TKey, elementSelector?: (item: TSource) => TElement): Map<TKey, TElement>;
    };
    toSet: <TSource>(source: Iterable<TSource>) => Set<TSource>;
    union: <TSource>(left: Iterable<TSource>, right: Iterable<TSource>, comparer?: (x: TSource, y: TSource) => boolean) => IterableX<TSource>;
    _while: <TSource>(condition: () => boolean, source: Iterable<TSource>) => IterableX<TSource>;
    zip: <TSource, TResult>(left: Iterable<TSource>, right: Iterable<TSource>, fn: (left: TSource, right: TSource) => TResult) => IterableX<TResult>;
};
export default _default;