import Queue from './Queue';
declare type Result<A> = IteratorResult<A>;
/**
 * Async iterable iterator with a non-optional [[return]] method.
 */
interface BalancerAsyncIterableIterator<A> extends AsyncIterableIterator<A> {
    return(value?: A): Promise<Result<A>>;
}
/**
 * Balances a push queue with a pull queue. Pulling with an empty push
 * queue
 */
export default class Balancer<A> implements AsyncIterableIterator<A> {
    /** XXX */
    readonly pushOverflow: Queue<IteratorResult<A>>;
    /** XXX */
    readonly pullOverflow: Queue<(a: IteratorResult<A>) => void>;
    /** XXX */
    closed: boolean;
    /**
     * Pull a promise of the next [[IteratorResult]].
     */
    next(): Promise<Result<A>>;
    /**
     * Push the next value.
     *
     * @throws Throws if the balancer is closed
     */
    push(value: A): void;
    /**
     * Returns itself, since it's already an iterator;
     */
    [Symbol.asyncIterator](): this;
    /**
     * Closes the iterator; clears the queues and makes [[Balancer.next]] only
     * return [[closedResult]].
     *
     * @param value The result value to be returned
     */
    return(value?: A): Promise<Result<A>>;
    /**
     * Convert [[Balancer]] to a generic async iterable iterator to hide implementation details.
     *
     * @param onReturn Optional callback for when the iterator is closed with [[Balancer.return]]
     */
    wrap(onReturn?: () => void): BalancerAsyncIterableIterator<A>;
}
export {};