import type { UnionToIntersection } from "@principia/prelude/Utils";
import { AtomicReference } from "../../support";
import type { Cause } from "../Exit/Cause";
import type { Managed } from "../Managed/model";
import type { DefaultEnv } from "../Task";
export declare const URI = "Layer";
export declare type URI = typeof URI;
export declare abstract class Layer<R, E, A> {
   readonly hash: AtomicReference<string | number | symbol>;
   readonly _R: (_: R) => void;
   readonly _E: () => E;
   readonly _Out: () => A;
   setKey(hash: symbol): this;
   ["_I"](): LayerInstruction;
}
declare module "@principia/prelude/HKT" {
   interface URItoKind<FC, TC, N extends string, K, Q, W, X, I, S, R, E, A> {
      readonly [URI]: Layer<R, E, A>;
   }
}
export declare enum LayerInstructionTag {
   Fold = "LayerFold",
   Map = "LayerMap",
   Chain = "LayerChain",
   Fresh = "LayerRefresh",
   Managed = "LayerManaged",
   Suspend = "LayerSuspend",
   MapBothPar = "LayerMapBothPar",
   AllPar = "LayerAllPar",
   AllSeq = "LayerAllSeq",
   MapBothSeq = "LayerMapBothSeq"
}
/**
 * Type level bound to make sure a layer is complete
 */
export declare const main: <E, A>(layer: Layer<DefaultEnv, E, A>) => Layer<DefaultEnv, E, A>;
export declare type LayerInstruction =
   | LayerFoldInstruction<any, any, any, any, any, any, any, any>
   | LayerMapInstruction<any, any, any, any>
   | LayerChainInstruction<any, any, any, any, any, any>
   | LayerChainInstruction<any, any, any, any, any, any>
   | LayerFreshInstruction<any, any, any>
   | LayerManagedInstruction<any, any, any>
   | LayerSuspendInstruction<any, any, any>
   | LayerMapBothParInstruction<any, any, any, any, any, any, any>
   | LayerMapBothSeqInstruction<any, any, any, any, any, any, any>
   | LayerAllParInstruction<Layer<any, any, any>[]>
   | LayerAllSeqInstruction<Layer<any, any, any>[]>;
export declare class LayerFoldInstruction<RIn, E, ROut, E1, ROut1, R, E2, ROut2> extends Layer<
   RIn & R,
   E1 | E2,
   ROut1 | ROut2
> {
   readonly layer: Layer<RIn, E, ROut>;
   readonly onFailure: Layer<readonly [RIn, Cause<E>], E1, ROut1>;
   readonly onSuccess: Layer<ROut & R, E2, ROut2>;
   readonly _tag = LayerInstructionTag.Fold;
   constructor(
      layer: Layer<RIn, E, ROut>,
      onFailure: Layer<readonly [RIn, Cause<E>], E1, ROut1>,
      onSuccess: Layer<ROut & R, E2, ROut2>
   );
}
export declare class LayerMapInstruction<R, E, A, B> extends Layer<R, E, B> {
   readonly layer: Layer<R, E, A>;
   readonly f: (a: A) => B;
   readonly _tag = LayerInstructionTag.Map;
   constructor(layer: Layer<R, E, A>, f: (a: A) => B);
}
export declare class LayerChainInstruction<R, E, A, R1, E1, B> extends Layer<R & R1, E | E1, B> {
   readonly layer: Layer<R, E, A>;
   readonly f: (a: A) => Layer<R1, E1, B>;
   readonly _tag = LayerInstructionTag.Chain;
   constructor(layer: Layer<R, E, A>, f: (a: A) => Layer<R1, E1, B>);
}
export declare class LayerFreshInstruction<R, E, A> extends Layer<R, E, A> {
   readonly layer: Layer<R, E, A>;
   readonly _tag = LayerInstructionTag.Fresh;
   constructor(layer: Layer<R, E, A>);
}
export declare class LayerManagedInstruction<R, E, A> extends Layer<R, E, A> {
   readonly managed: Managed<R, E, A>;
   readonly _tag = LayerInstructionTag.Managed;
   constructor(managed: Managed<R, E, A>);
}
export declare class LayerSuspendInstruction<R, E, A> extends Layer<R, E, A> {
   readonly factory: () => Layer<R, E, A>;
   readonly _tag = LayerInstructionTag.Suspend;
   constructor(factory: () => Layer<R, E, A>);
}
export declare type MergeR<Ls extends Layer<any, any, any>[]> = UnionToIntersection<
   {
      [k in keyof Ls]: [Ls[k]] extends [Layer<infer X, any, any>] ? (unknown extends X ? never : X) : never;
   }[number]
>;
export declare type MergeE<Ls extends Layer<any, any, any>[]> = {
   [k in keyof Ls]: [Ls[k]] extends [Layer<any, infer X, any>] ? X : never;
}[number];
export declare type MergeA<Ls extends Layer<any, any, any>[]> = UnionToIntersection<
   {
      [k in keyof Ls]: [Ls[k]] extends [Layer<any, any, infer X>] ? (unknown extends X ? never : X) : never;
   }[number]
>;
export declare class LayerMapBothParInstruction<R, E, A, R1, E1, B, C> extends Layer<R & R1, E | E1, C> {
   readonly layer: Layer<R, E, A>;
   readonly that: Layer<R1, E1, B>;
   readonly f: (a: A, b: B) => C;
   readonly _tag = LayerInstructionTag.MapBothPar;
   constructor(layer: Layer<R, E, A>, that: Layer<R1, E1, B>, f: (a: A, b: B) => C);
}
export declare class LayerAllParInstruction<Ls extends Layer<any, any, any>[]> extends Layer<
   MergeR<Ls>,
   MergeE<Ls>,
   MergeA<Ls>
> {
   readonly layers: Ls & {
      0: Layer<any, any, any>;
   };
   readonly _tag = LayerInstructionTag.AllPar;
   constructor(
      layers: Ls & {
         0: Layer<any, any, any>;
      }
   );
}
export declare class LayerMapBothSeqInstruction<R, E, A, R1, E1, B, C> extends Layer<R & R1, E | E1, C> {
   readonly layer: Layer<R, E, A>;
   readonly that: Layer<R1, E1, B>;
   readonly f: (a: A, b: B) => C;
   readonly _tag = LayerInstructionTag.MapBothSeq;
   constructor(layer: Layer<R, E, A>, that: Layer<R1, E1, B>, f: (a: A, b: B) => C);
}
export declare class LayerAllSeqInstruction<Ls extends Layer<any, any, any>[]> extends Layer<
   MergeR<Ls>,
   MergeE<Ls>,
   MergeA<Ls>
> {
   readonly layers: Ls & {
      0: Layer<any, any, any>;
   };
   readonly _tag = LayerInstructionTag.AllSeq;
   constructor(
      layers: Ls & {
         0: Layer<any, any, any>;
      }
   );
}
//# sourceMappingURL=model.d.ts.map