import type { MutableQueue } from "../../support";
import { AtomicBoolean } from "../../support";
import type { XPromise } from "../XPromise";
import * as T from "./_internal/task";
import type { Queue } from "./model";
export declare const unsafeOfferAll: <A>(q: MutableQueue<A>, as: readonly A[]) => readonly A[];
export declare const unsafePollAll: <A>(q: MutableQueue<A>) => readonly A[];
export declare const unsafeCompletePromise: <A>(p: XPromise<never, A>, a: A) => void;
export declare const unsafeRemove: <A>(q: MutableQueue<A>, a: A) => void;
export declare const unsafePollN: <A>(q: MutableQueue<A>, max: number) => readonly A[];
export declare const unsafeCompleteTakers: <A>(
   strategy: Strategy<A>,
   queue: MutableQueue<A>,
   takers: MutableQueue<XPromise<never, A>>
) => void;
export interface Strategy<A> {
   readonly handleSurplus: (
      as: readonly A[],
      queue: MutableQueue<A>,
      takers: MutableQueue<XPromise<never, A>>,
      isShutdown: AtomicBoolean
   ) => T.IO<boolean>;
   readonly unsafeOnQueueEmptySpace: (queue: MutableQueue<A>) => void;
   readonly surplusSize: number;
   readonly shutdown: T.IO<void>;
}
export declare class BackPressureStrategy<A> implements Strategy<A> {
   private putters;
   handleSurplus(
      as: readonly A[],
      queue: MutableQueue<A>,
      takers: MutableQueue<XPromise<never, A>>,
      isShutdown: AtomicBoolean
   ): T.IO<boolean>;
   unsafeRemove(p: XPromise<never, boolean>): void;
   unsafeOffer(as: readonly A[], p: XPromise<never, boolean>): void;
   unsafeOnQueueEmptySpace(queue: MutableQueue<A>): void;
   get shutdown(): T.IO<void>;
   get surplusSize(): number;
}
export declare class DroppingStrategy<A> implements Strategy<A> {
   handleSurplus(
      _as: readonly A[],
      _queue: MutableQueue<A>,
      _takers: MutableQueue<XPromise<never, A>>,
      _isShutdown: AtomicBoolean
   ): T.IO<boolean>;
   unsafeOnQueueEmptySpace(_queue: MutableQueue<A>): void;
   get shutdown(): T.IO<void>;
   get surplusSize(): number;
}
export declare class SlidingStrategy<A> implements Strategy<A> {
   handleSurplus(
      as: readonly A[],
      queue: MutableQueue<A>,
      takers: MutableQueue<XPromise<never, A>>,
      _isShutdown: AtomicBoolean
   ): T.IO<boolean>;
   unsafeOnQueueEmptySpace(_queue: MutableQueue<A>): void;
   get shutdown(): T.IO<void>;
   get surplusSize(): number;
   private unsafeSlidingOffer;
}
export declare const unsafeCreate: <A>(
   queue: MutableQueue<A>,
   takers: MutableQueue<XPromise<never, A>>,
   shutdownHook: XPromise<never, void>,
   shutdownFlag: AtomicBoolean,
   strategy: Strategy<A>
) => Queue<A>;
export declare const createQueue: <A>(
   strategy: Strategy<A>
) => (queue: MutableQueue<A>) => T.Task<unknown, never, Queue<A>>;
export declare const makeSliding: <A>(capacity: number) => T.IO<Queue<A>>;
export declare const makeUnbounded: <A>() => T.IO<Queue<A>>;
export declare const makeDropping: <A>(capacity: number) => T.IO<Queue<A>>;
export declare const makeBounded: <A>(capacity: number) => T.IO<Queue<A>>;
//# sourceMappingURL=implementation.d.ts.map