import type { Erase, UnionToIntersection } from "@principia/prelude/Utils";
import type { Has, Tag } from "../../Has";
import * as Sy from "./_internal";
import type { SyncMemoMap } from "./model";
import { SyncLayer, SyncLayerInstructionTag } from "./model";
export declare const getMemoOrElseCreate: <R, E, A>(layer: SyncLayer<R, E, A>) => (m: SyncMemoMap) => Sy.Sync<R, E, A>;
export declare class FromSyncInstruction<R, E, A> extends SyncLayer<R, E, A> {
   readonly sync: Sy.Sync<R, E, A>;
   readonly _tag = SyncLayerInstructionTag.FromSync;
   constructor(sync: Sy.Sync<R, E, A>);
   scope(): Sy.IO<(_: SyncMemoMap) => Sy.Sync<R, E, A>>;
}
export declare class FreshInstruction<R, E, A> extends SyncLayer<R, E, A> {
   readonly layer: SyncLayer<R, E, A>;
   readonly _tag = SyncLayerInstructionTag.Fresh;
   constructor(layer: SyncLayer<R, E, A>);
   scope(): Sy.IO<(_: SyncMemoMap) => Sy.Sync<R, E, A>>;
}
export declare class SuspendInstruction<R, E, A> extends SyncLayer<R, E, A> {
   readonly factory: () => SyncLayer<R, E, A>;
   readonly _tag = SyncLayerInstructionTag.Suspend;
   constructor(factory: () => SyncLayer<R, E, A>);
   scope(): Sy.IO<(_: SyncMemoMap) => Sy.Sync<R, E, A>>;
}
export declare class BothInstruction<R, E, A, R1, E1, A1> extends SyncLayer<R & R1, E | E1, A & A1> {
   readonly left: SyncLayer<R, E, A>;
   readonly right: SyncLayer<R1, E1, A1>;
   readonly _tag = SyncLayerInstructionTag.Both;
   constructor(left: SyncLayer<R, E, A>, right: SyncLayer<R1, E1, A1>);
   scopeBoth(
      self: BothInstruction<R, E, A, R1, E1, A1>
   ): Sy.Sync<unknown, never, (memo: SyncMemoMap) => Sy.Sync<R & R1, E | E1, A & A1>>;
   scope(): Sy.IO<(_: SyncMemoMap) => Sy.Sync<R & R1, E | E1, A & A1>>;
}
export declare class UsingInstruction<R, E, A, R1, E1, A1> extends SyncLayer<R & Erase<R1, A>, E | E1, A & A1> {
   readonly left: SyncLayer<R, E, A>;
   readonly right: SyncLayer<R1, E1, A1>;
   readonly _tag = SyncLayerInstructionTag.Using;
   constructor(left: SyncLayer<R, E, A>, right: SyncLayer<R1, E1, A1>);
   scope(): Sy.Sync<unknown, never, (_: SyncMemoMap) => Sy.Sync<R & Erase<R1, A>, E | E1, A & A1>>;
}
export declare class FromInstruction<R, E, A, R1, E1, A1> extends SyncLayer<R & Erase<R1, A>, E | E1, A1> {
   readonly left: SyncLayer<R, E, A>;
   readonly right: SyncLayer<R1, E1, A1>;
   readonly _tag = SyncLayerInstructionTag.From;
   constructor(left: SyncLayer<R, E, A>, right: SyncLayer<R1, E1, A1>);
   scope(): Sy.IO<(_: SyncMemoMap) => Sy.Sync<R & Erase<R1, A>, E | E1, A1>>;
}
export declare type MergeR<Ls extends ReadonlyArray<SyncLayer<any, any, any>>> = UnionToIntersection<
   {
      [k in keyof Ls]: [Ls[k]] extends [SyncLayer<infer X, any, any>] ? (unknown extends X ? never : X) : never;
   }[number]
>;
export declare type MergeE<Ls extends ReadonlyArray<SyncLayer<any, any, any>>> = {
   [k in keyof Ls]: [Ls[k]] extends [SyncLayer<any, infer X, any>] ? X : never;
}[number];
export declare type MergeA<Ls extends ReadonlyArray<SyncLayer<any, any, any>>> = UnionToIntersection<
   {
      [k in keyof Ls]: [Ls[k]] extends [SyncLayer<any, any, infer X>] ? (unknown extends X ? never : X) : never;
   }[number]
>;
export declare class AllInstruction<Layers extends ReadonlyArray<SyncLayer<any, any, any>>> extends SyncLayer<
   MergeR<Layers>,
   MergeE<Layers>,
   MergeA<Layers>
> {
   readonly layers: Layers & {
      0: SyncLayer<any, any, any>;
   };
   readonly _tag = SyncLayerInstructionTag.All;
   constructor(
      layers: Layers & {
         0: SyncLayer<any, any, any>;
      }
   );
   scope(): Sy.IO<(_: SyncMemoMap) => Sy.Sync<MergeR<Layers>, MergeE<Layers>, MergeA<Layers>>>;
}
export declare const fromRawSync: <R, E, A>(sync: Sy.Sync<R, E, A>) => SyncLayer<R, E, A>;
export declare const fresh: <R, E, A>(layer: SyncLayer<R, E, A>) => FreshInstruction<R, E, A>;
export declare const suspend: <R, E, A>(layer: () => SyncLayer<R, E, A>) => SuspendInstruction<R, E, A>;
export declare const fromSync: <T>(tag: Tag<T>) => <R, E>(_: Sy.Sync<R, E, T>) => SyncLayer<R, E, Has<T>>;
export declare const fromFunction: <T>(tag: Tag<T>) => <R>(f: (_: R) => T) => SyncLayer<R, never, Has<T>>;
export declare const fromValue: <T>(tag: Tag<T>) => (_: T) => SyncLayer<unknown, never, Has<T>>;
export declare const and: <R2, E2, A2>(
   left: SyncLayer<R2, E2, A2>
) => <R, E, A>(right: SyncLayer<R, E, A>) => SyncLayer<R & R2, E2 | E, A & A2>;
export declare const andTo: <R2, E2, A2>(
   left: SyncLayer<R2, E2, A2>
) => <R, E, A>(right: SyncLayer<R, E, A>) => SyncLayer<R & Erase<R2, A>, E2 | E, A & A2>;
export declare const to: <R2, E2, A2>(
   left: SyncLayer<R2, E2, A2>
) => <R, E, A>(right: SyncLayer<R, E, A>) => SyncLayer<R & Erase<R2, A>, E2 | E, A2>;
export declare const using: <R2, E2, A2>(
   left: SyncLayer<R2, E2, A2>
) => <R, E, A>(right: SyncLayer<R, E, A>) => SyncLayer<Erase<R, A2> & R2, E2 | E, A & A2>;
export declare const from: <R2, E2, A2>(
   left: SyncLayer<R2, E2, A2>
) => <R, E, A>(right: SyncLayer<R, E, A>) => SyncLayer<Erase<R, A2> & R2, E2 | E, A>;
export declare const giveLayer: <R, E, A>(
   layer: SyncLayer<R, E, A>
) => <R2, E2, A2>(_: Sy.Sync<R2 & A, E2, A2>) => Sy.Sync<R & R2, E | E2, A2>;
export declare const all: <Ls extends readonly SyncLayer<any, any, any>[]>(
   ...ls: Ls & {
      0: SyncLayer<any, any, any>;
   }
) => SyncLayer<
   UnionToIntersection<
      {
         [k in keyof Ls]: [Ls[k]] extends [SyncLayer<infer X, any, any>] ? (unknown extends X ? never : X) : never;
      }[number]
   >,
   MergeE<Ls>,
   UnionToIntersection<
      {
         [k_1 in keyof Ls]: [Ls[k_1]] extends [SyncLayer<any, any, infer X_1>]
            ? unknown extends X_1
               ? never
               : X_1
            : never;
      }[number]
   >
>;
//# sourceMappingURL=core.d.ts.map