export declare type ToKeyFunction<T> = (value: T, idx: number) => string;
export interface TypedDictionary<T> {
    [key: string]: T;
}
export declare type PartitionKey<K> = [string, K];
export declare type ToPartitionKeyFunction<K, T> = (value: T) => PartitionKey<K>;
export interface MutablePartition<K, V> {
    readonly id: string;
    readonly key: K;
    readonly values: V[];
}
export interface Partition<K, V> {
    readonly id: string;
    readonly key: K;
    readonly values: ReadonlyArray<V>;
}
export declare type PartitionMap<K, V> = Readonly<{
    [id: string]: MutablePartition<K, V>;
}>;
export interface IValueWithIndex<V> {
    readonly index: number;
    readonly value: V;
}
export declare type ScanTuple<V> = [V, boolean];
export declare type ScanHandler<T, V> = (record: T, index: number) => ScanTuple<V>;
export declare class ArrayStream<T> {
    private values;
    constructor(values: ReadonlyArray<T>);
    scan<V>(start: number, delta: number, handler: ScanHandler<T, V>): ArrayStream<V>;
    debug(handler: (values: ReadonlyArray<T>) => void): ArrayStream<T>;
    filter(predicate: (record: T, index: number) => boolean): ArrayStream<T>;
    head(limit: number): ArrayStream<T>;
    sort(compareFn: (a: T, b: T) => number): ArrayStream<T>;
    shuffle(): ArrayStream<T>;
    unique(toKey?: ToKeyFunction<T>): ArrayStream<T>;
    reverse(): ArrayStream<T>;
    group(toKey?: ToKeyFunction<T>): ArrayStream<ReadonlyArray<T>>;
    partition<K>(toPartitionKey: ToPartitionKeyFunction<K, T>): PartitionMap<K, T>;
    merge(predicate: (v0: T, v1: T) => boolean): ArrayStream<readonly T[]>;
    map<V>(mapper: (record: T, index: number) => V): ArrayStream<V>;
    flatMap<V>(mapper: (currentValue: T, index: number) => ReadonlyArray<V>): ArrayStream<V>;
    withIndex(): ArrayStream<IValueWithIndex<T>>;
    first(): T | undefined;
    last(): T | undefined;
    collect(): ReadonlyArray<T>;
    transferTo(callback: (values: ReadonlyArray<T>) => void): void;
    toMap(toKey?: ToKeyFunction<T>): TypedDictionary<T>;
    toMap2<V>(toKey: (value: T, index: number) => string, toValue: (value: T, index: number) => V): {
        [key: string]: V;
    };
}
export declare function arrayStream<T>(values: ReadonlyArray<T>): ArrayStream<T>;
export declare namespace ArrayStreams {
    function create<T>(values: ReadonlyArray<T>): ArrayStream<T>;
    function ofMapValues<T>(values: {
        [key: string]: T;
    } | null | undefined): ArrayStream<T>;
}