import { Effect } from "@effect/core/io/Effect/definition";
import { Env } from "@tsplus/stdlib/service/Env";
import { Scope } from "@effect/core/io/Scope/definition";
import { Cause } from "@effect/core/io/Cause/definition";
export declare const LayerTypeId: unique symbol;
export type LayerTypeId = typeof LayerTypeId;
export declare const _RIn: unique symbol;
export type _RIn = typeof _RIn;
export declare const _E: unique symbol;
export type _E = typeof _E;
export declare const _ROut: unique symbol;
export type _ROut = typeof _ROut;
/**
 * A `Layer<RIn, E, ROut>` describes how to build one or more services in your
 * application. Services can be injected into effects via `Effect.provide`.
 * Effects can require services via `Effect.service`.
 *
 * Layer can be thought of as recipes for producing bundles of services, given
 * their dependencies (other services).
 *
 * Construction of services can be effectful and utilize resources that must be
 * acquired and safely released when the services are done being utilized.
 *
 * By default layers are shared, meaning that if the same layer is used twice
 * the layer will only be allocated a single time.
 *
 * Because of their excellent composition properties, layers are the idiomatic
 * way in Effect-TS to create services that depend on other services.
 *
 * @tsplus type effect/core/io/Layer
 */
export interface Layer<RIn, E, ROut> {
    readonly [_RIn]: () => RIn;
    readonly [_E]: () => E;
    readonly [_ROut]: (_: ROut) => void;
    readonly [LayerTypeId]: LayerTypeId;
}
/**
 * @tsplus type effect/core/io/Layer.Ops
 */
export interface LayerOps {
    $: LayerAspects;
}
export declare const Layer: LayerOps;
/**
 * @tsplus unify effect/core/io/Layer
 */
export declare function unifyLayer<X extends Layer<any, any, any>>(self: X): Layer<[
    X
] extends [{
    [_RIn]: () => infer RIn;
}] ? RIn : never, [
    X
] extends [{
    [_E]: () => infer E;
}] ? E : never, [
    X
] extends [{
    [_ROut]: (_: infer ROut) => void;
}] ? ROut : never>;
/**
 * @tsplus type effect/core/io/Layer.Aspects
 */
export interface LayerAspects {
}
export declare abstract class LayerAbstract<RIn, E, ROut> implements Layer<RIn, E, ROut> {
    readonly [_RIn]: () => RIn;
    readonly [_E]: () => E;
    readonly [_ROut]: () => ROut;
    readonly [LayerTypeId]: LayerTypeId;
}
export type Instruction = ILayerApply<any, any, any> | ILayerExtendScope<any, any, any> | ILayerFold<any, any, any, any, any, any, any, any, any> | ILayerFresh<any, any, any> | ILayerScoped<any, any, any> | ILayerSuspend<any, any, any> | ILayerTo<any, any, any, any, any> | ILayerZipWithPar<any, any, any, any, any, any, any>;
export declare class ILayerApply<RIn, E, ROut> implements Layer<RIn, E, ROut> {
    readonly self: Effect<RIn, E, Env<ROut>>;
    readonly _tag = "LayerApply";
    readonly [_RIn]: () => RIn;
    readonly [_E]: () => E;
    readonly [_ROut]: () => ROut;
    readonly [LayerTypeId]: LayerTypeId;
    constructor(self: Effect<RIn, E, Env<ROut>>);
}
export declare class ILayerExtendScope<RIn, E, ROut> implements Layer<RIn | Scope, E, ROut> {
    readonly self: Layer<RIn, E, ROut>;
    readonly _tag = "LayerExtendScope";
    readonly [_RIn]: () => RIn | Scope;
    readonly [_E]: () => E;
    readonly [_ROut]: () => ROut;
    readonly [LayerTypeId]: LayerTypeId;
    constructor(self: Layer<RIn, E, ROut>);
}
export declare class ILayerFold<RIn, E, ROut, RIn2, E2, ROut2, RIn3, E3, ROut3> implements Layer<RIn | RIn2 | RIn3, E2 | E3, ROut2 | ROut3> {
    readonly self: Layer<RIn, E, ROut>;
    readonly failure: (cause: Cause<E>) => Layer<RIn2, E2, ROut2>;
    readonly success: (r: Env<ROut>) => Layer<RIn3, E3, ROut3>;
    readonly _tag = "LayerFold";
    readonly [_RIn]: () => RIn | RIn2 | RIn3;
    readonly [_E]: () => E2 | E3;
    readonly [_ROut]: () => ROut2 | ROut3;
    readonly [LayerTypeId]: LayerTypeId;
    constructor(self: Layer<RIn, E, ROut>, failure: (cause: Cause<E>) => Layer<RIn2, E2, ROut2>, success: (r: Env<ROut>) => Layer<RIn3, E3, ROut3>);
}
export declare class ILayerFresh<RIn, E, ROut> implements Layer<RIn, E, ROut> {
    readonly self: Layer<RIn, E, ROut>;
    readonly _tag = "LayerFresh";
    readonly [_RIn]: () => RIn;
    readonly [_E]: () => E;
    readonly [_ROut]: () => ROut;
    readonly [LayerTypeId]: LayerTypeId;
    constructor(self: Layer<RIn, E, ROut>);
}
export declare class ILayerScoped<RIn, E, ROut> extends LayerAbstract<Exclude<RIn, Scope>, E, ROut> {
    readonly self: Effect<RIn, E, Env<ROut>>;
    readonly _tag = "LayerScoped";
    constructor(self: Effect<RIn, E, Env<ROut>>);
}
export declare class ILayerSuspend<RIn, E, ROut> implements Layer<RIn, E, ROut> {
    readonly self: () => Layer<RIn, E, ROut>;
    readonly _tag = "LayerSuspend";
    readonly [_RIn]: () => RIn;
    readonly [_E]: () => E;
    readonly [_ROut]: () => ROut;
    readonly [LayerTypeId]: LayerTypeId;
    constructor(self: () => Layer<RIn, E, ROut>);
}
export declare class ILayerTo<RIn, E, ROut, E1, ROut1> implements Layer<RIn, E | E1, ROut1> {
    readonly self: Layer<RIn, E, ROut>;
    readonly that: Layer<ROut, E1, ROut1>;
    readonly _tag = "LayerTo";
    readonly [_RIn]: () => RIn;
    readonly [_E]: () => E | E1;
    readonly [_ROut]: () => ROut1;
    readonly [LayerTypeId]: LayerTypeId;
    constructor(self: Layer<RIn, E, ROut>, that: Layer<ROut, E1, ROut1>);
}
export declare class ILayerZipWithPar<RIn, E, ROut, RIn1, E1, ROut2, ROut3> implements Layer<RIn | RIn1, E | E1, ROut3> {
    readonly self: Layer<RIn, E, ROut>;
    readonly that: Layer<RIn1, E1, ROut2>;
    readonly f: (s: Env<ROut>, t: Env<ROut2>) => Env<ROut3>;
    readonly _tag = "LayerZipWithPar";
    readonly [_RIn]: () => RIn | RIn1;
    readonly [_E]: () => E | E1;
    readonly [_ROut]: () => ROut3;
    readonly [LayerTypeId]: LayerTypeId;
    constructor(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut2>, f: (s: Env<ROut>, t: Env<ROut2>) => Env<ROut3>);
}
/**
 * @tsplus macro identity
 */
export declare function instruction<R, E, A>(self: Layer<R, E, A>): Instruction;
//# sourceMappingURL=definition.d.ts.map