import { Ref } from "@effect/core/io/Ref/definition";
import { Deferred } from "@effect/core/io/Deferred/definition";
import { Effect } from "@effect/core/io/Effect/definition";
export declare const CountdownLatchSym: unique symbol;
export type CountdownLatchSym = typeof CountdownLatchSym;
/**
 * A synchronization aid that allows one or more fibers to wait until a set of
 * operations being performed in other fibers completes.
 *
 * A `CountDownLatch` is initialized with a given count. The `await` method
 * block until the current count reaches zero due to invocations of the
 * `countDown` method, after which all waiting fibers are released and any
 * subsequent invocations of `await` return immediately. This is a one-shot
 * phenomenon -- the count cannot be reset. If you need a version that resets
 * the count, consider using a `CyclicBarrier`.
 *
 * A `CountDownLatch` is a versatile synchronization tool and can be used for a
 * number of purposes. A `CountDownLatch` initialized with a count of one serves
 * as a simple on/off latch, or gate: all fibers invoking `await` wait at the
 * gate until it is opened by a fiber invoking `countDown`. A `CountDownLatch`
 * initialized to N can be used to make one fiber wait until N fibers have
 * completed some action, or some action has been completed N times.
 *
 * A useful property of a `CountDownLatch` is that it doesn't require that
 * fibers calling `countDown` wait for the count to reach zero before
 * proceeding, it simply prevents any fiber from proceeding past an `await`
 * until all fibers could pass.
 *
 * @tsplus type effect/core/concurrent/CountdownLatch
 */
export interface CountdownLatch extends CountdownLatchInternal {
}
/**
 * @tsplus type effect/core/concurrent/CountdownLatch.Ops
 */
export interface CountdownLatchOps {
    readonly $: CountdownLatchAspects;
}
export declare const CountdownLatch: CountdownLatchOps;
/**
 * @tsplus type effect/core/concurrent/CountdownLatch.Aspects
 */
export interface CountdownLatchAspects {
}
export declare class CountdownLatchInternal {
    readonly [CountdownLatchSym]: CountdownLatchSym;
    private _count;
    private _waiters;
    constructor(count: Ref<number>, waiters: Deferred<never, void>);
    /**
     * Returns the current count.
     */
    get count(): Effect<never, never, number>;
    /**
     * Decrements the count of the latch, releasing all waiting fibers if the
     * count reaches zero.
     */
    get countDown(): Effect<never, never, void>;
    /**
     * Causes the current fiber to wait until the latch has counted down to zero.
     */
    get await(): Effect<never, never, void>;
}
//# sourceMappingURL=definition.d.ts.map