export interface MapItemResult<T> {
    index: number;
    item: unknown;
    result: T;
    success: boolean;
    error?: Error;
    duration: number;
}
export interface MapProgressEvent<T> {
    total: number;
    completed: number;
    successful: number;
    failed: number;
    currentItem?: MapItemResult<T>;
    pending: number;
    running: number;
}
export interface MapNodeConfig<S, T> {
    name: string;
    items: (state: S) => unknown[];
    mapper: (item: unknown, index: number, state: S) => Promise<T> | T;
    concurrency?: number;
    continueOnError?: boolean;
    onProgress?: (progress: MapProgressEvent<T>) => void;
    filter?: (item: unknown, index: number, state: S) => boolean;
    transform?: (item: unknown, index: number, state: S) => unknown;
    timeout?: number;
    retry?: {
        maxAttempts: number;
        delay?: number;
        backoff?: 'linear' | 'exponential';
    };
}
export interface ReduceNodeConfig<S, T, R> {
    name: string;
    initial: R | ((state: S) => R);
    reducer: (accumulator: R, item: MapItemResult<T>, state: S) => R;
    streaming?: boolean;
    successOnly?: boolean;
    finalize?: (result: R, state: S) => R;
}
export interface MapReduceResult<T, R> {
    results: MapItemResult<T>[];
    reduced: R;
    stats: {
        total: number;
        successful: number;
        failed: number;
        duration: number;
        avgItemDuration: number;
    };
}
export interface MapReduceNodeConfig<S, T, R> {
    name: string;
    map: Omit<MapNodeConfig<S, T>, 'name'>;
    reduce: Omit<ReduceNodeConfig<S, T, R>, 'name'>;
}
export declare function executeMap<S, T>(state: S, config: MapNodeConfig<S, T>): Promise<MapItemResult<T>[]>;
export declare function executeReduce<S, T, R>(results: MapItemResult<T>[], state: S, config: ReduceNodeConfig<S, T, R>): R;
export declare function executeMapReduce<S, T, R>(state: S, config: MapReduceNodeConfig<S, T, R>): Promise<MapReduceResult<T, R>>;
export declare function mapNode<S, T>(name: string, config: Omit<MapNodeConfig<S, T>, 'name'>): MapNodeConfig<S, T>;
export declare function reduceNode<S, T, R>(name: string, config: Omit<ReduceNodeConfig<S, T, R>, 'name'>): ReduceNodeConfig<S, T, R>;
export declare function mapReduceNode<S, T, R>(name: string, config: Omit<MapReduceNodeConfig<S, T, R>, 'name'>): MapReduceNodeConfig<S, T, R>;
export declare function parallelMap<S, T>(state: S, items: (state: S) => unknown[], mapper: (item: unknown, index: number, state: S) => Promise<T> | T, options?: {
    continueOnError?: boolean;
    onProgress?: (progress: MapProgressEvent<T>) => void;
}): Promise<MapItemResult<T>[]>;
export declare function sequentialMap<S, T>(state: S, items: (state: S) => unknown[], mapper: (item: unknown, index: number, state: S) => Promise<T> | T, options?: {
    continueOnError?: boolean;
    onProgress?: (progress: MapProgressEvent<T>) => void;
}): Promise<MapItemResult<T>[]>;
export declare function batchedMap<S, T>(state: S, items: (state: S) => unknown[], mapper: (item: unknown, index: number, state: S) => Promise<T> | T, batchSize: number, options?: {
    continueOnError?: boolean;
    onProgress?: (progress: MapProgressEvent<T>) => void;
}): Promise<MapItemResult<T>[]>;
export declare function collect<T>(): Omit<ReduceNodeConfig<unknown, T, T[]>, 'name'>;
export declare function sum(): Omit<ReduceNodeConfig<unknown, number, number>, 'name'>;
export declare function count(): Omit<ReduceNodeConfig<unknown, unknown, number>, 'name'>;
export declare function first<T>(): Omit<ReduceNodeConfig<unknown, T, T | undefined>, 'name'>;
export declare function last<T>(): Omit<ReduceNodeConfig<unknown, T, T | undefined>, 'name'>;
export declare function groupBy<T, K extends string | number>(keyFn: (result: T, item: MapItemResult<T>) => K): Omit<ReduceNodeConfig<unknown, T, Record<K, T[]>>, 'name'>;
export declare function partition<T>(predicate: (result: T, item: MapItemResult<T>) => boolean): Omit<ReduceNodeConfig<unknown, T, {
    pass: T[];
    fail: T[];
}>, 'name'>;
export declare function flatMap<T>(): Omit<ReduceNodeConfig<unknown, T[], T[]>, 'name'>;
export declare function stats(): Omit<ReduceNodeConfig<unknown, number, {
    count: number;
    sum: number;
    avg: number;
    min: number;
    max: number;
}>, 'name'>;
//# sourceMappingURL=map-reduce.d.ts.map