import type * as Chunk from "../Collections/Immutable/Chunk";
import type { Effect, UIO } from "../Effect/effect";
export declare const _RA: unique symbol;
export declare type _RA = typeof _RA;
export declare const _RB: unique symbol;
export declare type _RB = typeof _RB;
export declare const _EA: unique symbol;
export declare type _EA = typeof _EA;
export declare const _EB: unique symbol;
export declare type _EB = typeof _EB;
export declare const _A: unique symbol;
export declare type _A = typeof _A;
export declare const _B: unique symbol;
export declare type _B = typeof _B;
/**
 * A `XQueue<RA, RB, EA, EB, A, B>` is a lightweight, asynchronous queue into which values of
 * type `A` can be enqueued and of which elements of type `B` can be dequeued. The queue's
 * enqueueing operations may utilize an environment of type `RA` and may fail with errors of
 * type `EA`. The dequeueing operations may utilize an environment of type `RB` and may fail
 * with errors of type `EB`.
 */
export interface XQueue<RA, RB, EA, EB, A, B> {
    readonly [_RA]: (_: RA) => void;
    readonly [_RB]: (_: RB) => void;
    readonly [_EA]: () => EA;
    readonly [_EB]: () => EB;
    readonly [_A]: (_: A) => void;
    readonly [_B]: () => B;
}
/**
 * @ets_optimize remove
 */
export declare function concreteQueue<RA, RB, EA, EB, A, B>(_: XQueue<RA, RB, EA, EB, A, B>): asserts _ is XQueueInternal<RA, RB, EA, EB, A, B>;
export declare abstract class XQueueInternal<RA, RB, EA, EB, A, B> implements XQueue<RA, RB, EA, EB, A, B> {
    readonly [_RA]: (_: RA) => void;
    readonly [_RB]: (_: RB) => void;
    readonly [_EA]: () => EA;
    readonly [_EB]: () => EB;
    readonly [_A]: (_: A) => void;
    readonly [_B]: () => B;
    /**
     * Waits until the queue is shutdown.
     * The `IO` returned by this method will not resume until the queue has been shutdown.
     * If the queue is already shutdown, the `IO` will resume right away.
     */
    abstract readonly awaitShutdown: UIO<void>;
    /**
     * How many elements can hold in the queue
     */
    abstract readonly capacity: number;
    /**
     * `true` if `shutdown` has been called.
     */
    abstract readonly isShutdown: UIO<boolean>;
    /**
     * Places one value in the queue.
     */
    abstract offer(a: A): Effect<RA, EA, boolean>;
    /**
     * For Bounded Queue: uses the `BackPressure` Strategy, places the values in the queue and always returns true.
     * If the queue has reached capacity, then
     * the fiber performing the `offerAll` will be suspended until there is room in
     * the queue.
     *
     * For Unbounded Queue:
     * Places all values in the queue and returns true.
     *
     * For Sliding Queue: uses `Sliding` Strategy
     * If there is room in the queue, it places the values otherwise it removes the old elements and
     * enqueues the new ones. Always returns true.
     *
     * For Dropping Queue: uses `Dropping` Strategy,
     * It places the values in the queue but if there is no room it will not enqueue them and return false.
     *
     */
    abstract offerAll(as: Iterable<A>): Effect<RA, EA, boolean>;
    /**
     * Interrupts any fibers that are suspended on `offer` or `take`.
     * Future calls to `offer*` and `take*` will be interrupted immediately.
     */
    abstract readonly shutdown: UIO<void>;
    /**
     * Retrieves the size of the queue, which is equal to the number of elements
     * in the queue. This may be negative if fibers are suspended waiting for
     * elements to be added to the queue.
     */
    abstract readonly size: UIO<number>;
    /**
     * Removes the oldest value in the queue. If the queue is empty, this will
     * return a computation that resumes when an item has been added to the queue.
     */
    abstract readonly take: Effect<RB, EB, B>;
    /**
     * Removes all the values in the queue and returns the list of the values. If the queue
     * is empty returns empty list.
     */
    abstract readonly takeAll: Effect<RB, EB, Chunk.Chunk<B>>;
    /**
     * Takes up to max number of values in the queue.
     */
    abstract takeUpTo(n: number): Effect<RB, EB, Chunk.Chunk<B>>;
}
/**
 * A `Queue<A>` is a lightweight, asynchronous queue into which
 * values of type `A` can be enqueued and dequeued.
 */
export interface Queue<A> extends XQueue<unknown, unknown, never, never, A, A> {
}
/**
 * A queue that can only be dequeued.
 */
export interface Dequeue<A> extends XQueue<never, unknown, unknown, never, never, A> {
}
/**
 * A queue that can only be enqueued.
 */
export interface Enqueue<A> extends XQueue<unknown, never, never, unknown, A, any> {
}
//# sourceMappingURL=xqueue.d.ts.map