interface AbortOptions {
    signal?: AbortSignal;
}
interface BasePushable<T> {
    /**
     * End the iterable after all values in the buffer (if any) have been yielded. If an
     * error is passed the buffer is cleared immediately and the next iteration will
     * throw the passed error
     */
    end(err?: Error): this;
    /**
     * Push a value into the iterable. Values are yielded from the iterable in the order
     * they are pushed. Values not yet consumed from the iterable are buffered.
     */
    push(value: T): this;
    /**
     * Returns a promise that resolves when the underlying queue becomes empty (e.g.
     * this.readableLength === 0).
     *
     * If an AbortSignal is passed as an option and that signal aborts, it only
     * causes the returned promise to reject - it does not end the pushable.
     */
    onEmpty(options?: AbortOptions): Promise<void>;
    /**
     * This property contains the number of bytes (or objects) in the queue ready to be read.
     *
     * If `objectMode` is true, this is the number of objects in the queue, if false it's the
     * total number of bytes in the queue.
     */
    readableLength: number;
}
/**
 * An iterable that you can push values into.
 */
interface Pushable<T, R = void, N = unknown> extends AsyncGenerator<T, R, N>, BasePushable<T> {
}

declare function mapAsync<T, U>(stream: AsyncIterable<T>, mapFn: (value: T) => U | PromiseLike<U>): AsyncGenerator<U>;
declare function cloneAsync<T>(stream: AsyncIterable<T>, target: Pushable<T>): AsyncGenerator<T>;
declare function joinAsync(stream: AsyncIterable<string[]>, separator?: string): AsyncGenerator<string>;
declare function splitAsync(stream: AsyncIterable<string>, ...separator: string[]): AsyncGenerator<string>;
declare function filterAsync<T, TFiltered extends T>(stream: AsyncIterable<T>, filterFn: (value: T) => value is TFiltered): AsyncGenerator<TFiltered>;
declare function castAsync<T>(e: AsyncIterable<any>): AsyncGenerator<Awaited<T>, void, unknown>;
type BatchAsyncParams<T> = {
    stream: AsyncIterable<T>;
    split?: (i: T) => boolean;
};
declare function batchAsync<T extends any, TIterable extends AsyncIterable<T> = AsyncIterable<T>>(stream: TIterable, split?: (current: T, buffer: T[]) => boolean): AsyncGenerator<T[]>;
declare function delayAsync<T>(stream: AsyncIterable<T>, ms?: number): AsyncGenerator<T>;
declare function teeAsync<T>(stream: AsyncIterable<T>): [AsyncIterable<T>, AsyncIterable<T>];
declare function teePushableAsync<T>(stream: Pushable<T>): [AsyncIterable<T>, Pushable<T>];
declare function concatAsync<T>(...streams: AsyncIterable<T>[]): AsyncGenerator<T>;
declare function flatAsync<T>(composed: AsyncGenerator<AsyncGenerator<T>>): AsyncGenerator<T>;

export { type BatchAsyncParams as B, type Pushable as P, castAsync as a, batchAsync as b, cloneAsync as c, delayAsync as d, teePushableAsync as e, filterAsync as f, concatAsync as g, flatAsync as h, joinAsync as j, mapAsync as m, splitAsync as s, teeAsync as t };