export declare class Flux<T> implements AsyncGenerator<T>, Promise<T[]> {
    private readonly generator;
    private readonly upstream?;
    private readonly handleCancel?;
    private _closed;
    private constructor();
    [Symbol.asyncIterator](): AsyncGenerator<T, any, unknown>;
    next(...args: [] | [unknown]): Promise<IteratorResult<T>>;
    next(...args: [] | [unknown]): Promise<IteratorResult<T>>;
    return(value?: any): Promise<IteratorResult<T, undefined>>;
    throw(e: any): Promise<IteratorResult<T>>;
    cancel(e?: unknown): Promise<void>;
    then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T[] | TResult>;
    finally(onfinally?: (() => void) | null): Promise<T[]>;
    get [Symbol.toStringTag](): string;
    subscribe(callback?: (value: T) => void): {
        unsubscribe: () => Promise<IteratorResult<T, undefined>>;
    };
    filter<O = T>(predicate: (value: T) => boolean): Flux<O>;
    /**
     * Flux until predicate is true; the rest is dropped. The first
     * value that is dropped is the value for which the predicate
     * is true.
     *
     * @param predicate
     */
    untilExcl(predicate: (value: T) => boolean): Flux<Awaited<T>>;
    doOnEach(callback: (value: T) => void): Flux<T>;
    doAfterLast(callback: (allEvents: T[]) => (void | Promise<void>)): Flux<T>;
    map<O>(mapper: (value: T) => O): Flux<O>;
    take(n: number): Flux<T>;
    /**
     * Delay each of this Flux elements (Subscriber.onNext signals) by a given duration.
     * Signals are delayed and continue on the parallel default Scheduler, but empty
     * sequences or immediate error signals are not delayed.
     *
     * @param delayMillis - The duration in milliseconds to delay each element emission
     * @returns A new Flux with delayed element emissions
     *
     * @example
     * ```typescript
     * const flux = Flux.fromArray([1, 2, 3])
     * const delayed = flux.delayElements(1000) // Each element delayed by 1 second
     * for await (const value of delayed) {
     *   console.log(value) // Prints 1, 2, 3 with 1 second delay between each
     * }
     * ```
     */
    delayElements(delayMillis: number): Flux<T>;
    flatMap<O>(mapper: (value: T) => O[]): Flux<O>;
    flatMap<O>(mapper: (value: T) => Flux<O>, options?: {
        concurrency?: number;
    }): Flux<O>;
    flatMap<O>(mapper: (value: T) => Promise<O>, options?: {
        concurrency?: number;
    }): Flux<O>;
    transform<O>(defineGenerator: (thisFlux: Flux<T>) => AsyncGenerator<O>): Flux<O>;
    reduce<O>(reducer: (reduction: O, newValue: T) => O, initialValue: O): Promise<O>;
    reduce<O>(reducer: (reduction: O | undefined, newValue: T) => O): Promise<O | undefined>;
    asList(): Promise<T[]>;
    whenComplete(): Promise<void>;
    static create<T>(creator: (push: (value: T) => void, complete: () => void, reject: (err: any) => void) => (void | Promise<void>)): Flux<T>;
    static just<T>(...array: T[]): Flux<T>;
    static from<T>(array: T[]): Flux<T>;
    static from<T>(generator: AsyncGenerator<T>, handleCancel?: (e?: any) => void): Flux<T>;
    static from<T>(stream: ReadableStream<T>, handleCancel?: (e?: any) => void): Flux<T>;
    static from<T>(fn: () => AsyncGenerator<T>, handleCancel?: (e?: any) => void): Flux<T>;
    static fromArray<T>(array: T[]): Flux<T>;
    static constructFromGeneratorFunction<T>(fn: () => AsyncGenerator<T>, upstream: Flux<unknown> | undefined, handleCancel?: (e?: any) => void): Flux<T>;
    static fromGeneratorFunction<T>(fn: () => AsyncGenerator<T>, handleCancel?: (e?: any) => void): Flux<T>;
    static fromGenerator<T>(generator: AsyncGenerator<T>, handleCancel?: (e?: any) => void): Flux<T>;
    static fromReadableStream<T>(stream: ReadableStream<T>, handleCancel?: (e?: any) => void): Flux<T>;
    get closed(): boolean;
}