/**
 * Stream Transformer
 *
 * Provides composable stream transformation utilities
 * for mapping, filtering, and aggregating stream data.
 */
export type TransformFunction<T, R> = (chunk: T) => R | Promise<R>;
export type FilterFunction<T> = (chunk: T) => boolean | Promise<boolean>;
export type AggregateFunction<T, R> = (accumulator: R, chunk: T) => R | Promise<R>;
export interface TransformPipeline<T, R> {
    source: AsyncIterable<T>;
    transform: TransformFunction<T, R>;
}
export declare class StreamTransformer<_T = unknown> {
    /**
     * Map each chunk through a transform function
     */
    static map<T, R>(source: AsyncIterable<T>, transform: TransformFunction<T, R>): AsyncGenerator<R, void, unknown>;
    /**
     * Filter chunks based on a predicate
     */
    static filter<T>(source: AsyncIterable<T>, predicate: FilterFunction<T>): AsyncGenerator<T, void, unknown>;
    /**
     * Take first n chunks
     */
    static take<T>(source: AsyncIterable<T>, count: number): AsyncGenerator<T, void, unknown>;
    /**
     * Skip first n chunks
     */
    static skip<T>(source: AsyncIterable<T>, count: number): AsyncGenerator<T, void, unknown>;
    /**
     * Take chunks while predicate is true
     */
    static takeWhile<T>(source: AsyncIterable<T>, predicate: FilterFunction<T>): AsyncGenerator<T, void, unknown>;
    /**
     * Skip chunks while predicate is true
     */
    static skipWhile<T>(source: AsyncIterable<T>, predicate: FilterFunction<T>): AsyncGenerator<T, void, unknown>;
    /**
     * Flatten nested async iterables
     */
    static flatten<T>(source: AsyncIterable<AsyncIterable<T> | T[]>): AsyncGenerator<T, void, unknown>;
    /**
     * Batch chunks into arrays of specified size
     */
    static batch<T>(source: AsyncIterable<T>, size: number): AsyncGenerator<T[], void, unknown>;
    /**
     * Debounce stream - only emit after specified quiet period
     */
    static debounce<T>(source: AsyncIterable<T>, delayMs: number): AsyncGenerator<T, void, unknown>;
    /**
     * Throttle stream - emit at most once per interval
     */
    static throttle<T>(source: AsyncIterable<T>, intervalMs: number): AsyncGenerator<T, void, unknown>;
    /**
     * Add delay between chunks
     */
    static delay<T>(source: AsyncIterable<T>, delayMs: number): AsyncGenerator<T, void, unknown>;
    /**
     * Buffer chunks until a flush condition is met
     */
    static buffer<T>(source: AsyncIterable<T>, shouldFlush: (buffer: T[], newChunk: T) => boolean): AsyncGenerator<T[], void, unknown>;
    /**
     * Merge multiple streams into one
     */
    static merge<T>(...sources: AsyncIterable<T>[]): AsyncGenerator<T, void, unknown>;
    /**
     * Concatenate multiple streams sequentially
     */
    static concat<T>(...sources: AsyncIterable<T>[]): AsyncGenerator<T, void, unknown>;
    /**
     * Zip multiple streams together
     */
    static zip<T>(...sources: AsyncIterable<T>[]): AsyncGenerator<T[], void, unknown>;
    /**
     * Create a tee - duplicate stream for multiple consumers
     */
    static tee<T>(source: AsyncIterable<T>, count?: number): AsyncIterable<T>[];
    /**
     * Create a pipeline of transformations
     */
    static pipe<T, R>(source: AsyncIterable<T>, ...transforms: Array<(input: AsyncIterable<unknown>) => AsyncIterable<unknown>>): AsyncIterable<R>;
    /**
     * Reduce stream to a single value
     */
    static reduce<T, R>(source: AsyncIterable<T>, reducer: AggregateFunction<T, R>, initial: R): Promise<R>;
    /**
     * Collect all chunks into an array
     */
    static collect<T>(source: AsyncIterable<T>): Promise<T[]>;
    /**
     * Get first chunk
     */
    static first<T>(source: AsyncIterable<T>): Promise<T | undefined>;
    /**
     * Get last chunk
     */
    static last<T>(source: AsyncIterable<T>): Promise<T | undefined>;
    /**
     * Count chunks
     */
    static count<T>(source: AsyncIterable<T>): Promise<number>;
    /**
     * Check if any chunk matches predicate
     */
    static some<T>(source: AsyncIterable<T>, predicate: FilterFunction<T>): Promise<boolean>;
    /**
     * Check if all chunks match predicate
     */
    static every<T>(source: AsyncIterable<T>, predicate: FilterFunction<T>): Promise<boolean>;
    /**
     * Find first chunk matching predicate
     */
    static find<T>(source: AsyncIterable<T>, predicate: FilterFunction<T>): Promise<T | undefined>;
}
