import type { Either } from "../../Either";
import { ImmutableQueue } from "../../support";
import * as M from "../Managed/_core";
import * as T from "../Task/_core";
import type { XPromise } from "../XPromise";
import type { Ref } from "../XRef/model";
export declare type Entry = [XPromise<never, void>, number];
export declare type State = Either<ImmutableQueue<Entry>, number>;
export declare const assertNonNegative: (n: number) => T.IO<void>;
export declare class Acquisition {
   readonly waitAcquire: T.IO<void>;
   readonly release: T.IO<void>;
   constructor(waitAcquire: T.IO<void>, release: T.IO<void>);
}
/**
 * An asynchronous semaphore, which is a generalization of a mutex. Semaphores
 * have a certain number of permits, which can be held and released
 * concurrently by different parties. Attempts to acquire more permits than
 * available result in the acquiring fiber being suspended until the specified
 * number of permits become available.
 **/
export declare class Semaphore {
   private readonly state;
   constructor(state: Ref<State>);
   get available(): T.Task<unknown, never, number>;
   private loop;
   private releaseN;
   private restore;
   prepare(n: number): T.IO<Acquisition>;
}
/**
 * Acquires `n` permits, executes the action and releases the permits right after.
 */
export declare const withPermits: (n: number) => (s: Semaphore) => <R, E, A>(e: T.Task<R, E, A>) => T.Task<R, E, A>;
/**
 * Acquires a permit, executes the action and releases the permit right after.
 */
export declare const withPermit: (s: Semaphore) => <R, E, A>(e: T.Task<R, E, A>) => T.Task<R, E, A>;
/**
 * Acquires `n` permits in a [[Managed]] and releases the permits in the finalizer.
 */
export declare const withPermitsManaged: (n: number) => (s: Semaphore) => M.Managed<unknown, never, void>;
/**
 * Acquires a permit in a [[Managed]] and releases the permit in the finalizer.
 */
export declare const withPermitManaged: (s: Semaphore) => M.Managed<unknown, never, void>;
/**
 * The number of permits currently available.
 */
export declare const available: (s: Semaphore) => T.Task<unknown, never, number>;
/**
 * Creates a new `Sempahore` with the specified number of permits.
 */
export declare const makeSemaphore: (permits: number) => T.Task<unknown, never, Semaphore>;
/**
 * Creates a new `Sempahore` with the specified number of permits.
 */
export declare const unsafeMakeSemaphore: (permits: number) => Semaphore;
//# sourceMappingURL=model.d.ts.map