import type { Exit } from "../Exit";
import * as T from "./_internal/task";
import { Managed } from "./model";
import type { Finalizer } from "./ReleaseMap";
/**
 * Lift a pure value into a task
 */
export declare const succeed: <A>(a: A) => Managed<unknown, never, A>;
/**
 * Lifts a `Task<R, E, A>` into `Managed<R, E, A>` with no release action. The
 * effect will be performed interruptibly.
 */
export declare const fromTask: <R, E, A>(effect: T.Task<R, E, A>) => Managed<R, E, A>;
/**
 * Imports a synchronous side-effect into a pure value
 */
export declare const total: <A>(effect: () => A) => Managed<unknown, never, A>;
/**
 * Returns a task that models failure with the specified error. The moral equivalent of throw for pure code.
 */
export declare const fail: <E>(e: E) => Managed<unknown, E, never>;
/**
 * Creates a task that executes a finalizer stored in a `Ref`.
 * The `Ref` is yielded as the result of the effect, allowing for
 * control flows that require mutating finalizers.
 */
export declare const finalizerRef: (
   initial: Finalizer
) => Managed<unknown, never, import("../XRef/model").Ref<Finalizer>>;
/**
 * Lifts a `Task<S, R, E, A>` into `Managed<S, R, E, A>` with a release action.
 * The acquire and release actions will be performed uninterruptibly.
 */
export declare const make: <R1, A>(
   release: (a: A) => T.Task<R1, never, unknown>
) => <R, E>(acquire: T.Task<R, E, A>) => Managed<R & R1, E, A>;
/**
 * Lifts a `Task<S, R, E, A>` into `Managed<S, R, E, A>` with a release action.
 * The acquire and release actions will be performed uninterruptibly.
 */
export declare const make_: <R, E, A, R1>(
   acquire: T.Task<R, E, A>,
   release: (a: A) => T.Task<R1, never, unknown>
) => Managed<R & R1, E, A>;
/**
 * Lifts a `Task<S, R, E, A>` into `Managed<S, R, E, A>` with a release action
 * that handles `Exit`. The acquire and release actions will be performed uninterruptibly.
 */
export declare const makeExit: <R1, A>(
   release: (a: A, exit: Exit<any, any>) => T.Task<R1, never, unknown>
) => <R, E>(acquire: T.Task<R, E, A>) => Managed<R & R1, E, A>;
/**
 * Lifts a `Task<S, R, E, A>` into `Managed<S, R, E, A>` with a release action
 * that handles `Exit`. The acquire and release actions will be performed uninterruptibly.
 */
export declare const makeExit_: <R, E, A, R1>(
   acquire: T.Task<R, E, A>,
   release: (a: A, exit: Exit<any, any>) => T.Task<R1, never, unknown>
) => Managed<R & R1, E, A>;
/**
 * Creates a `Managed` from a `Reservation` produced by a task. Evaluating
 * the effect that produces the reservation will be performed *uninterruptibly*,
 * while the acquisition step of the reservation will be performed *interruptibly*.
 * The release step will be performed uninterruptibly as usual.
 *
 * This two-phase acquisition allows for resource acquisition flows that can be
 * safely interrupted and released.
 */
export declare const makeReserve: <R, E, R2, E2, A>(
   reservation: T.Task<R, E, Reservation<R2, E2, A>>
) => Managed<R & R2, E | E2, A>;
/**
 * A `Reservation<R, E, A>` encapsulates resource acquisition and disposal
 * without specifying when or how that resource might be used.
 */
export declare class Reservation<R, E, A> {
   readonly acquire: T.Task<R, E, A>;
   readonly release: (exit: Exit<any, any>) => T.Task<R, never, any>;
   static of: <R_1, E_1, A_1, R2>(
      acquire: T.Task<R_1, E_1, A_1>,
      release: (exit: Exit<any, any>) => T.Task<R2, never, any>
   ) => Reservation<R_1 & R2, E_1, A_1>;
   private constructor();
}
/**
 * Make a new reservation
 */
export declare const makeReservation_: <R, E, A, R2>(
   acquire: T.Task<R, E, A>,
   release: (exit: Exit<any, any>) => T.Task<R2, never, any>
) => Reservation<R & R2, E, A>;
/**
 * Make a new reservation
 */
export declare const makeReservation: <R2>(
   release: (exit: Exit<any, any>) => T.Task<R2, never, any>
) => <R, E, A>(acquire: T.Task<R, E, A>) => Reservation<R & R2, E, A>;
/**
 * Lifts a pure `Reservation<S, R, E, A>` into `Managed<S, R, E, A>`. The acquisition step
 * is performed interruptibly.
 */
export declare const reserve: <R, E, A>(reservation: Reservation<R, E, A>) => Managed<R, E, A>;
//# sourceMappingURL=constructors.d.ts.map