/**
 * Transactional deferred values for coordinating Effect transactions.
 *
 * A `TxDeferred<A, E>` is a write-once cell whose completion is a
 * `Result<A, E>` stored in transactional state. Readers can wait for the value
 * from inside a transaction: while the cell is empty the transaction retries,
 * and when another transaction completes the deferred the waiting transaction
 * can resume with either the success value or the typed failure.
 *
 * @stability stable
 * @since 4.0.0
 */
import * as Effect from "./Effect.ts";
import type { Inspectable } from "./Inspectable.ts";
import type { Option } from "./Option.ts";
import type { Pipeable } from "./Pipeable.ts";
import type { Result } from "./Result.ts";
import * as TxRef from "./TxRef.ts";
declare const TypeId = "~effect/TxDeferred";
/**
 * A transactional deferred is a write-once cell readable within transactions.
 * Readers block (retry the transaction) until a value is committed, and writers
 * succeed only on the first call; subsequent writes return `false`.
 *
 * **When to use**
 *
 * Use to coordinate transaction-local readers and one-time completion with a
 * success or failure result.
 *
 * **Example** (Completing a transactional deferred)
 *
 * ```ts import.meta.vitest
 * import { Effect, TxDeferred } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const deferred = yield* TxDeferred.make<number>()
 *
 *   // Complete the deferred
 *   const first = yield* TxDeferred.succeed(deferred, 42)
 *
 *   // Second write is a no-op
 *   const second = yield* TxDeferred.succeed(deferred, 99)
 *
 *   // Read the value
 *   const value = yield* TxDeferred.await(deferred)
 *   return [first, second, value]
 * })
 *
 * await Effect.runPromise(program) // => [true, false, 42]
 * ```
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface TxDeferred<in out A, in out E = never> extends Inspectable, Pipeable {
    readonly [TypeId]: typeof TypeId;
    readonly ref: TxRef.TxRef<Option<Result<A, E>>>;
}
/**
 * Creates a new empty `TxDeferred`.
 *
 * **When to use**
 *
 * Use to create a transactional deferred that can be completed exactly once.
 *
 * **Example** (Creating a transactional deferred)
 *
 * ```ts import.meta.vitest
 * import { Effect, Option, TxDeferred } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const deferred = yield* TxDeferred.make<string, Error>()
 *   return yield* TxDeferred.poll(deferred)
 * })
 *
 * await Effect.runPromise(program) // => Option.none()
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 2.0.0
 */
export declare const make: <A, E = never>() => Effect.Effect<TxDeferred<A, E>>;
/**
 * Reads the deferred value. Retries the transaction if the deferred has not
 * been completed yet.
 *
 * **Example** (Awaiting a deferred value)
 *
 * ```ts import.meta.vitest
 * import { Effect, TxDeferred } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const deferred = yield* TxDeferred.make<number>()
 *   yield* TxDeferred.succeed(deferred, 42)
 *   return yield* TxDeferred.await(deferred)
 * })
 *
 * await Effect.runPromise(program) // => 42
 * ```
 *
 * @category getters
 * @since 4.0.0
 */
declare const await_: <A, E>(self: TxDeferred<A, E>) => Effect.Effect<A, E>;
export { 
/**
 * Reads the deferred value. Retries the transaction if the deferred has not
 * been completed yet.
 *
 * **When to use**
 *
 * Use to read the success value of a `TxDeferred` while retrying until the
 * deferred is completed.
 *
 * @see {@link poll} for inspecting the current completion state without retrying the transaction
 *
 * @stability stable
 * @category getters
 * @since 4.0.0
 */
await_ as await };
/**
 * Reads the current state of the deferred without retrying. Returns `None` if
 * not yet completed.
 *
 * **When to use**
 *
 * Use to inspect a `TxDeferred` without retrying when it is not completed yet.
 *
 * **Example** (Polling a deferred)
 *
 * ```ts import.meta.vitest
 * import { Effect, Option, Result, TxDeferred } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const deferred = yield* TxDeferred.make<number>()
 *   const before = yield* TxDeferred.poll(deferred)
 *
 *   yield* TxDeferred.succeed(deferred, 42)
 *   const after = yield* TxDeferred.poll(deferred)
 *   return [before, after]
 * })
 *
 * await Effect.runPromise(program) // => [Option.none(), Option.some(Result.succeed(42))]
 * ```
 *
 * @stability stable
 * @category getters
 * @since 2.0.0
 */
export declare const poll: <A, E>(self: TxDeferred<A, E>) => Effect.Effect<Option<Result<A, E>>>;
/**
 * Completes the deferred with a `Result`. Returns `true` if this was the first
 * completion, `false` if already completed.
 *
 * **When to use**
 *
 * Use to complete a `TxDeferred` with an already computed `Result`.
 *
 * **Example** (Completing with a result)
 *
 * ```ts import.meta.vitest
 * import { Effect, Result, TxDeferred } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const deferred = yield* TxDeferred.make<number, string>()
 *   const first = yield* TxDeferred.done(deferred, Result.succeed(42))
 *   const second = yield* TxDeferred.done(deferred, Result.succeed(99))
 *   return [first, second]
 * })
 *
 * await Effect.runPromise(program) // => [true, false]
 * ```
 *
 * @stability stable
 * @category mutations
 * @since 2.0.0
 */
export declare const done: {
    /**
     * Completes the deferred with a `Result`. Returns `true` if this was the first
     * completion, `false` if already completed.
     *
     * **When to use**
     *
     * Use to complete a `TxDeferred` with an already computed `Result`.
     *
     * **Example** (Completing with a result)
     *
     * ```ts import.meta.vitest
     * import { Effect, Result, TxDeferred } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const deferred = yield* TxDeferred.make<number, string>()
     *   const first = yield* TxDeferred.done(deferred, Result.succeed(42))
     *   const second = yield* TxDeferred.done(deferred, Result.succeed(99))
     *   return [first, second]
     * })
     *
     * await Effect.runPromise(program) // => [true, false]
     * ```
     *
     * @stability stable
     * @category mutations
     * @since 2.0.0
     */
    <A, E>(result: Result<A, E>): (self: TxDeferred<A, E>) => Effect.Effect<boolean>;
    /**
     * Completes the deferred with a `Result`. Returns `true` if this was the first
     * completion, `false` if already completed.
     *
     * **When to use**
     *
     * Use to complete a `TxDeferred` with an already computed `Result`.
     *
     * **Example** (Completing with a result)
     *
     * ```ts import.meta.vitest
     * import { Effect, Result, TxDeferred } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const deferred = yield* TxDeferred.make<number, string>()
     *   const first = yield* TxDeferred.done(deferred, Result.succeed(42))
     *   const second = yield* TxDeferred.done(deferred, Result.succeed(99))
     *   return [first, second]
     * })
     *
     * await Effect.runPromise(program) // => [true, false]
     * ```
     *
     * @stability stable
     * @category mutations
     * @since 2.0.0
     */
    <A, E>(self: TxDeferred<A, E>, result: Result<A, E>): Effect.Effect<boolean>;
};
/**
 * Completes the deferred with a success value. Returns `true` if this was the
 * first completion, `false` if already completed.
 *
 * **When to use**
 *
 * Use to complete a `TxDeferred` with a successful value.
 *
 * **Example** (Completing with a success value)
 *
 * ```ts import.meta.vitest
 * import { Effect, TxDeferred } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const deferred = yield* TxDeferred.make<number>()
 *   const first = yield* TxDeferred.succeed(deferred, 42)
 *   const second = yield* TxDeferred.succeed(deferred, 99)
 *   return [first, second]
 * })
 *
 * await Effect.runPromise(program) // => [true, false]
 * ```
 *
 * @stability stable
 * @category mutations
 * @since 2.0.0
 */
export declare const succeed: {
    /**
     * Completes the deferred with a success value. Returns `true` if this was the
     * first completion, `false` if already completed.
     *
     * **When to use**
     *
     * Use to complete a `TxDeferred` with a successful value.
     *
     * **Example** (Completing with a success value)
     *
     * ```ts import.meta.vitest
     * import { Effect, TxDeferred } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const deferred = yield* TxDeferred.make<number>()
     *   const first = yield* TxDeferred.succeed(deferred, 42)
     *   const second = yield* TxDeferred.succeed(deferred, 99)
     *   return [first, second]
     * })
     *
     * await Effect.runPromise(program) // => [true, false]
     * ```
     *
     * @stability stable
     * @category mutations
     * @since 2.0.0
     */
    <A>(value: A): <E>(self: TxDeferred<A, E>) => Effect.Effect<boolean>;
    /**
     * Completes the deferred with a success value. Returns `true` if this was the
     * first completion, `false` if already completed.
     *
     * **When to use**
     *
     * Use to complete a `TxDeferred` with a successful value.
     *
     * **Example** (Completing with a success value)
     *
     * ```ts import.meta.vitest
     * import { Effect, TxDeferred } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const deferred = yield* TxDeferred.make<number>()
     *   const first = yield* TxDeferred.succeed(deferred, 42)
     *   const second = yield* TxDeferred.succeed(deferred, 99)
     *   return [first, second]
     * })
     *
     * await Effect.runPromise(program) // => [true, false]
     * ```
     *
     * @stability stable
     * @category mutations
     * @since 2.0.0
     */
    <A, E>(self: TxDeferred<A, E>, value: A): Effect.Effect<boolean>;
};
/**
 * Completes the deferred with a failure. Returns `true` if this was the first
 * completion, `false` if already completed.
 *
 * **When to use**
 *
 * Use to complete a `TxDeferred` with a typed failure value.
 *
 * **Example** (Completing with a failure)
 *
 * ```ts import.meta.vitest
 * import { Cause, Effect, Exit, Option, TxDeferred } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const deferred = yield* TxDeferred.make<number, string>()
 *   const first = yield* TxDeferred.fail(deferred, "boom")
 *   const second = yield* TxDeferred.fail(deferred, "boom2")
 *   const exit = yield* Effect.exit(TxDeferred.await(deferred))
 *   return [first, second, exit, Exit.getCause(exit)]
 * })
 *
 * await Effect.runPromise(program) // => [true, false, Exit.fail("boom"), Option.some(Cause.fail("boom"))]
 * ```
 *
 * @stability stable
 * @category mutations
 * @since 2.0.0
 */
export declare const fail: {
    /**
     * Completes the deferred with a failure. Returns `true` if this was the first
     * completion, `false` if already completed.
     *
     * **When to use**
     *
     * Use to complete a `TxDeferred` with a typed failure value.
     *
     * **Example** (Completing with a failure)
     *
     * ```ts import.meta.vitest
     * import { Cause, Effect, Exit, Option, TxDeferred } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const deferred = yield* TxDeferred.make<number, string>()
     *   const first = yield* TxDeferred.fail(deferred, "boom")
     *   const second = yield* TxDeferred.fail(deferred, "boom2")
     *   const exit = yield* Effect.exit(TxDeferred.await(deferred))
     *   return [first, second, exit, Exit.getCause(exit)]
     * })
     *
     * await Effect.runPromise(program) // => [true, false, Exit.fail("boom"), Option.some(Cause.fail("boom"))]
     * ```
     *
     * @stability stable
     * @category mutations
     * @since 2.0.0
     */
    <E>(error: E): <A>(self: TxDeferred<A, E>) => Effect.Effect<boolean>;
    /**
     * Completes the deferred with a failure. Returns `true` if this was the first
     * completion, `false` if already completed.
     *
     * **When to use**
     *
     * Use to complete a `TxDeferred` with a typed failure value.
     *
     * **Example** (Completing with a failure)
     *
     * ```ts import.meta.vitest
     * import { Cause, Effect, Exit, Option, TxDeferred } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const deferred = yield* TxDeferred.make<number, string>()
     *   const first = yield* TxDeferred.fail(deferred, "boom")
     *   const second = yield* TxDeferred.fail(deferred, "boom2")
     *   const exit = yield* Effect.exit(TxDeferred.await(deferred))
     *   return [first, second, exit, Exit.getCause(exit)]
     * })
     *
     * await Effect.runPromise(program) // => [true, false, Exit.fail("boom"), Option.some(Cause.fail("boom"))]
     * ```
     *
     * @stability stable
     * @category mutations
     * @since 2.0.0
     */
    <A, E>(self: TxDeferred<A, E>, error: E): Effect.Effect<boolean>;
};
/**
 * Determines if the provided value is a `TxDeferred`.
 *
 * **When to use**
 *
 * Use to narrow an unknown value before treating it as a transactional deferred.
 *
 * **Example** (Checking transactional deferreds)
 *
 * ```ts import.meta.vitest
 * import { Effect, TxDeferred } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const deferred = yield* TxDeferred.make<number>()
 *   return [TxDeferred.isTxDeferred(deferred), TxDeferred.isTxDeferred("not a deferred")]
 * })
 *
 * await Effect.runPromise(program) // => [true, false]
 * ```
 *
 * @stability stable
 * @category guards
 * @since 4.0.0
 */
export declare const isTxDeferred: (u: unknown) => u is TxDeferred<unknown, unknown>;
//# sourceMappingURL=TxDeferred.d.ts.map