import type { Erase } from "@principia/prelude/Utils";
import type * as H from "../../Has";
import type { Cause } from "../Exit/Cause";
import type { Managed } from "../Managed/model";
import type { Finalizer } from "../Managed/ReleaseMap";
import * as XRM from "../XRefM";
import * as M from "./_internal/managed";
import * as T from "./_internal/task";
import type { Layer, MergeA, MergeE, MergeR } from "./model";
import { LayerManagedInstruction } from "./model";
export * from "./model";
export declare type RIO<R, A> = Layer<R, never, A>;
export declare const _build: <R, E, A>(
   layer: Layer<R, E, A>
) => Managed<unknown, never, (_: MemoMap) => Managed<R, E, A>>;
export declare const build: <R, E, A>(_: Layer<R, E, A>) => Managed<R, E, A>;
export declare const pure: <T>(has: H.Tag<T>) => (resource: T) => LayerManagedInstruction<unknown, never, H.Has<T>>;
export declare const prepare: <T>(
   has: H.Tag<T>
) => <R, E, A extends T>(
   acquire: T.Task<R, E, A>
) => {
   open: <R1, E1>(
      open: (_: A) => T.Task<R1, E1, any>
   ) => {
      release: <R2>(release: (_: A) => T.Task<R2, never, any>) => Layer<R & R2 & R1, E | E1, H.Has<T>>;
   };
   release: <R2_1>(release: (_: A) => T.Task<R2_1, never, any>) => Layer<R & R2_1, E, H.Has<T>>;
};
export declare const create: <T>(
   has: H.Tag<T>
) => {
   fromTask: <R, E>(resource: T.Task<R, E, T>) => LayerManagedInstruction<R, E, H.Has<T>>;
   fromManaged: <R_1, E_1>(resource: Managed<R_1, E_1, T>) => Layer<R_1, E_1, H.Has<T>>;
   pure: (resource: T) => LayerManagedInstruction<unknown, never, H.Has<T>>;
   prepare: <R_3, E_3, A extends T>(
      acquire: T.Task<R_3, E_3, A>
   ) => {
      open: <R1, E1>(
         open: (_: A) => T.Task<R1, E1, any>
      ) => {
         release: <R2>(release: (_: A) => T.Task<R2, never, any>) => Layer<R_3 & R2 & R1, E_3 | E1, H.Has<T>>;
      };
      release: <R2_2>(release: (_: A) => T.Task<R2_2, never, any>) => Layer<R_3 & R2_2, E_3, H.Has<T>>;
   };
};
export declare const fromTask: <T>(
   has: H.Tag<T>
) => <R, E>(resource: T.Task<R, E, T>) => LayerManagedInstruction<R, E, H.Has<T>>;
export declare const fromManaged: <T>(has: H.Tag<T>) => <R, E>(resource: Managed<R, E, T>) => Layer<R, E, H.Has<T>>;
export declare const fromRawManaged: <R, E, A>(resource: Managed<R, E, A>) => Layer<R, E, A>;
export declare const fromRawTask: <R, E, A>(resource: T.Task<R, E, A>) => Layer<R, E, A>;
export declare const fromRawFunction: <A, B>(f: (a: A) => B) => Layer<A, never, B>;
export declare const fromRawFunctionM: <A, R, E, B>(f: (a: A) => T.Task<R, E, B>) => Layer<R & A, E, B>;
export declare const both_: <R, E, A, R2, E2, A2>(
   left: Layer<R, E, A>,
   right: Layer<R2, E2, A2>
) => Layer<R & R2, E | E2, readonly [A, A2]>;
export declare const both: <R2, E2, A2>(
   right: Layer<R2, E2, A2>
) => <R, E, A>(left: Layer<R, E, A>) => Layer<R & R2, E2 | E, readonly [A, A2]>;
export declare const and_: <R, E, A, R2, E2, A2>(
   left: Layer<R, E, A>,
   right: Layer<R2, E2, A2>
) => Layer<R & R2, E | E2, A & A2>;
export declare const and: <R2, E2, A2>(
   right: Layer<R2, E2, A2>
) => <R, E, A>(left: Layer<R, E, A>) => Layer<R & R2, E2 | E, A & A2>;
export declare const fold_: <R, E, A, E1, B, R2, E2, C>(
   layer: Layer<R, E, A>,
   onFailure: Layer<readonly [R, Cause<E>], E1, B>,
   onSuccess: Layer<A & R2, E2, C>
) => Layer<R & R2, E1 | E2, B | C>;
export declare const andTo: {
   <R1, E1, A1>(right: Layer<R1, E1, A1>, noErase: "no-erase"): <R, E, A>(
      left: Layer<R & A1, E, A>
   ) => Layer<R & R1, E | E1, A & A1>;
   <R1, E1, A1>(right: Layer<R1, E1, A1>): <R, E, A>(left: Layer<R, E, A>) => Layer<Erase<R, A1> & R1, E | E1, A & A1>;
};
export declare const andTo_: {
   <R, E, A, R1, E1, A1>(left: Layer<R, E, A>, right: Layer<R1, E1, A1>, noErase: "no-erase"): Layer<
      R & R1,
      E | E1,
      A & A1
   >;
   <R, E, A, R1, E1, A1>(left: Layer<R, E, A>, right: Layer<R1, E1, A1>): Layer<Erase<R, A1> & R1, E | E1, A & A1>;
};
export declare const to: <R, E, A>(
   to: Layer<R, E, A>
) => <R2, E2, A2>(layer: Layer<R2, E2, A2>) => Layer<Erase<R, A2> & R2, E | E2, A>;
export declare const to_: <R, E, A, R2, E2, A2>(
   layer: Layer<R2, E2, A2>,
   to: Layer<R, E, A>
) => Layer<Erase<R, A2> & R2, E | E2, A>;
export declare const andSeq_: <R, E, A, R1, E1, A1>(
   layer: Layer<R, E, A>,
   that: Layer<R1, E1, A1>
) => Layer<R & R1, E | E1, A & A1>;
export declare const andSeq: <R1, E1, A1>(
   that: Layer<R1, E1, A1>
) => <R, E, A>(layer: Layer<R, E, A>) => Layer<R & R1, E1 | E, A & A1>;
export declare const all: <Ls extends Layer<any, any, any>[]>(
   ...ls: Ls & {
      0: Layer<any, any, any>;
   }
) => Layer<
   import("../../../../prelude/dist/Utils").UnionToIntersection<
      { [k in keyof Ls]: [Ls[k]] extends [Layer<infer X, any, any>] ? (unknown extends X ? never : X) : never }[number]
   >,
   MergeE<Ls>,
   import("../../../../prelude/dist/Utils").UnionToIntersection<
      {
         [k_1 in keyof Ls]: [Ls[k_1]] extends [Layer<any, any, infer X_1>]
            ? unknown extends X_1
               ? never
               : X_1
            : never;
      }[number]
   >
>;
export declare const allPar: <Ls extends Layer<any, any, any>[]>(
   ...ls: Ls & {
      0: Layer<any, any, any>;
   }
) => Layer<
   import("../../../../prelude/dist/Utils").UnionToIntersection<
      { [k in keyof Ls]: [Ls[k]] extends [Layer<infer X, any, any>] ? (unknown extends X ? never : X) : never }[number]
   >,
   MergeE<Ls>,
   import("../../../../prelude/dist/Utils").UnionToIntersection<
      {
         [k_1 in keyof Ls]: [Ls[k_1]] extends [Layer<any, any, infer X_1>]
            ? unknown extends X_1
               ? never
               : X_1
            : never;
      }[number]
   >
>;
/**
 * A `MemoMap` memoizes dependencies.
 */
export declare class MemoMap {
   readonly ref: XRM.RefM<ReadonlyMap<PropertyKey, readonly [T.EIO<any, any>, Finalizer]>>;
   constructor(ref: XRM.RefM<ReadonlyMap<PropertyKey, readonly [T.EIO<any, any>, Finalizer]>>);
   /**
    * Checks the memo map to see if a dependency exists. If it is, immediately
    * returns it. Otherwise, obtains the dependency, stores it in the memo map,
    * and adds a finalizer to the outer `Managed`.
    */
   getOrElseMemoize: <R, E, A>(layer: Layer<R, E, A>) => Managed<R, E, A>;
}
export declare const HasMemoMap: H.Tag<MemoMap>;
export declare type HasMemoMap = H.HasTag<typeof HasMemoMap>;
export declare function makeMemoMap(): T.Task<unknown, never, MemoMap>;
//# sourceMappingURL=core.d.ts.map