import type { Deferred } from "../util/async.js";
import { AbstractSequence } from "./AbstractSequence.js";
/**
 * Deferred sequence of values that can be async iterated and new values can be published.
 * - Implements `AsyncIterable` so values can be iterated over using `for await...of`
 * - Implements `Promise` so the next value can be awaited.
 * - Implements `Deferred` so next values can be resolved or rejected.
 */
export declare class DeferredSequence<T = void> extends AbstractSequence<T, void, void> implements Deferred<T>, Promise<T> {
    /**
     * Next deferred to be rejected/resolved, or `undefined` if we haven't requested one yet..
     * - Only create the deferred on demand, because we don't want to reject a deferred that isn't used to or it would throw an unhandled promise error.
     */
    private _deferred;
    /** Get the next promise to be deferred/rejected. */
    get promise(): Promise<T>;
    /** Resolve the current deferred in the sequence. */
    resolve(value: T): void;
    private _nextValue;
    /** Reject the current deferred in the sequence. */
    reject(reason: unknown): void;
    private _nextReason;
    /** Fulfill the current deferred by resolving or rejecting it. */
    private _fulfill;
    next(): Promise<IteratorResult<T, void>>;
    then<X = T, Y = never>(onNext?: (v: T) => X | PromiseLike<X>, onError?: (r: unknown) => Y | PromiseLike<Y>): Promise<X | Y>;
    catch<Y>(onError: (r: unknown) => Y | PromiseLike<Y>): Promise<T | Y>;
    finally(onFinally: () => void): Promise<T>;
    /** Resolve the current deferred from a sequence of values. */
    through(sequence: AsyncIterable<T>): AsyncIterator<T>;
}