import type { IEnumerable } from './enumerable';
import type { IEnumerator } from './enumerator';
export declare type Predicate<T, A extends any[] = any> = (source: T, ...args: A) => boolean;
export declare type JoinResultSelector<TOuter, TInner, TResult> = (outer: TOuter, inner: TInner) => TResult;
export declare type GroupByResultSelector<TKey, TElement, TResult> = (key: TKey, elements: IEnumerable<TElement>) => TResult;
export declare type Action<T> = (source: T) => void;
export declare class ResultSelector<TSource, TResult> {
    static get default(): ResultSelector<any, any>;
}
export interface ResultSelector<TSource, TResult> {
    (source: TSource): TResult;
}
export interface ResultSelectorWithIndex<TSource, TResult> {
    (source: TSource, index?: number): TResult;
}
export interface Comparer<TSource, TCompareTo> {
    (element: TSource, compareTo: TCompareTo): number;
}
export declare class Comparer<TSource, TCompareTo> {
    static get default(): Comparer<any, any>;
}
export interface EqualityComparer<T> {
    (x: T, y: T): boolean;
}
export declare class EqualityComparer<T> {
    static get default(): EqualityComparer<unknown>;
}
export declare type IteratorType<T extends Iterator<T>> = {
    prototype: {
        [Symbol.iterator](): T;
    };
} & Function;
export declare type IteratorFunction<T, R extends Iterator<T> = Iterator<T>> = () => R;
export declare type EnumerableSource<T> = IEnumerator<T> | Iterable<T> | IteratorFunction<T>;
export declare type Nil = null | undefined;