effect 2.2.5 → 2.3.0

package/dist/dts/Layer.d.ts

@@ -1,5 +1,5 @@
 /**
- * A `Layer<RIn, E, ROut>` describes how to build one or more services in your
+ * A `Layer<ROut, E, RIn>` describes how to build one or more services in your
  * application. Services can be injected into effects via
  * `Effect.provideService`. Effects can require services via `Effect.service`.
  *
@@ -49,7 +49,7 @@ export type LayerTypeId = typeof LayerTypeId;
  * @since 2.0.0
  * @category models
  */
-export interface Layer<out RIn, out E, in ROut> extends Layer.Variance<RIn, E, ROut>, Pipeable {
+export interface Layer<in ROut, out E = never, out RIn = never> extends Layer.Variance<ROut, E, RIn>, Pipeable {
 }
 /**
  * @since 2.0.0
@@ -59,28 +59,28 @@ export declare namespace Layer {
      * @since 2.0.0
      * @category models
      */
-    interface Variance<out RIn, out E, in ROut> {
+    interface Variance<in ROut, out E, out RIn> {
         readonly [LayerTypeId]: {
-            readonly _RIn: Types.Covariant<RIn>;
-            readonly _E: Types.Covariant<E>;
             readonly _ROut: Types.Contravariant<ROut>;
+            readonly _E: Types.Covariant<E>;
+            readonly _RIn: Types.Covariant<RIn>;
         };
     }
     /**
      * @since 2.0.0
      * @category type-level
      */
-    type Context<T extends Layer<any, any, never>> = [T] extends [Layer<infer _R, infer _E, infer _A>] ? _R : never;
+    type Context<T extends Layer<never, any, any>> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>] ? _RIn : never;
     /**
      * @since 2.0.0
      * @category type-level
      */
-    type Error<T extends Layer<any, any, never>> = [T] extends [Layer<infer _R, infer _E, infer _A>] ? _E : never;
+    type Error<T extends Layer<never, any, any>> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>] ? _E : never;
     /**
      * @since 2.0.0
      * @category type-level
      */
-    type Success<T extends Layer<any, any, never>> = [T] extends [Layer<infer _R, infer _E, infer _A>] ? _A : never;
+    type Success<T extends Layer<never, any, any>> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>] ? _ROut : never;
 }
 /**
  * @since 2.0.0
@@ -113,14 +113,14 @@ export declare const isLayer: (u: unknown) => u is Layer<unknown, unknown, unkno
  * @since 2.0.0
  * @category getters
  */
-export declare const isFresh: <R, E, A>(self: Layer<R, E, A>) => boolean;
+export declare const isFresh: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => boolean;
 /**
  * Builds a layer into a scoped value.
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare const build: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Effect.Effect<Scope.Scope | RIn, E, Context.Context<ROut>>;
+export declare const build: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Context.Context<ROut>, E, Scope.Scope | RIn>;
 /**
  * Builds a layer into an `Effect` value. Any resources associated with this
  * layer will be released when the specified scope is closed unless their scope
@@ -132,8 +132,8 @@ export declare const build: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Effect.
  * @category destructors
  */
 export declare const buildWithScope: {
-    (scope: Scope.Scope): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Effect.Effect<RIn, E, Context.Context<ROut>>;
-    <RIn, E, ROut>(self: Layer<RIn, E, ROut>, scope: Scope.Scope): Effect.Effect<RIn, E, Context.Context<ROut>>;
+    (scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Context.Context<ROut>, E, RIn>;
+    <RIn, E, ROut>(self: Layer<ROut, E, RIn>, scope: Scope.Scope): Effect.Effect<Context.Context<ROut>, E, RIn>;
 };
 /**
  * Recovers from all errors.
@@ -142,8 +142,8 @@ export declare const buildWithScope: {
  * @category error handling
  */
 export declare const catchAll: {
-    <E, R2, E2, A2>(onError: (error: E) => Layer<R2, E2, A2>): <R, A>(self: Layer<R, E, A>) => Layer<R2 | R, E2, A & A2>;
-    <R, E, A, R2, E2, A2>(self: Layer<R, E, A>, onError: (error: E) => Layer<R2, E2, A2>): Layer<R | R2, E2, A & A2>;
+    <E, RIn2, E2, ROut2>(onError: (error: E) => Layer<ROut2, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut & ROut2, E2, RIn2 | RIn>;
+    <RIn, E, ROut, RIn2, E2, ROut2>(self: Layer<ROut, E, RIn>, onError: (error: E) => Layer<ROut2, E2, RIn2>): Layer<ROut & ROut2, E2, RIn | RIn2>;
 };
 /**
  * Recovers from all errors.
@@ -152,8 +152,8 @@ export declare const catchAll: {
  * @category error handling
  */
 export declare const catchAllCause: {
-    <E, R2, E2, A2>(onError: (cause: Cause.Cause<E>) => Layer<R2, E2, A2>): <R, A>(self: Layer<R, E, A>) => Layer<R2 | R, E2, A & A2>;
-    <R, E, A, R2, E2, A2>(self: Layer<R, E, A>, onError: (cause: Cause.Cause<E>) => Layer<R2, E2, A2>): Layer<R | R2, E2, A & A2>;
+    <E, RIn2, E2, ROut2>(onError: (cause: Cause.Cause<E>) => Layer<ROut2, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut & ROut2, E2, RIn2 | RIn>;
+    <RIn, E, ROut, RIn2, E2, ROut22>(self: Layer<ROut, E, RIn>, onError: (cause: Cause.Cause<E>) => Layer<ROut22, E2, RIn2>): Layer<ROut & ROut22, E2, RIn | RIn2>;
 };
 /**
  * Constructs a `Layer` that passes along the specified context as an
@@ -169,14 +169,14 @@ export declare const context: <R>() => Layer<R, never, R>;
  * @since 2.0.0
  * @category constructors
  */
-export declare const die: (defect: unknown) => Layer<never, never, unknown>;
+export declare const die: (defect: unknown) => Layer<unknown>;
 /**
  * Constructs a layer that dies with the specified defect.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const dieSync: (evaluate: LazyArg<unknown>) => Layer<never, never, unknown>;
+export declare const dieSync: (evaluate: LazyArg<unknown>) => Layer<unknown>;
 /**
  * Replaces the layer's output with `void` and includes the layer only for its
  * side-effects.
@@ -184,7 +184,7 @@ export declare const dieSync: (evaluate: LazyArg<unknown>) => Layer<never, never
  * @since 2.0.0
  * @category mapping
  */
-export declare const discard: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn, E, never>;
+export declare const discard: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Layer<never, E, RIn>;
 /**
  * Constructs a layer from the specified effect.
  *
@@ -192,8 +192,8 @@ export declare const discard: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer
  * @category constructors
  */
 export declare const effect: {
-    <T extends Context.Tag<any, any>>(tag: T): <R, E>(effect: Effect.Effect<R, E, Context.Tag.Service<T>>) => Layer<R, E, Context.Tag.Identifier<T>>;
-    <T extends Context.Tag<any, any>, R, E>(tag: T, effect: Effect.Effect<R, E, Context.Tag.Service<T>>): Layer<R, E, Context.Tag.Identifier<T>>;
+    <T extends Context.Tag<any, any>>(tag: T): <E, R>(effect: Effect.Effect<Context.Tag.Service<T>, E, R>) => Layer<Context.Tag.Identifier<T>, E, R>;
+    <T extends Context.Tag<any, any>, E, R>(tag: T, effect: Effect.Effect<Context.Tag.Service<T>, E, R>): Layer<Context.Tag.Identifier<T>, E, R>;
 };
 /**
  * Constructs a layer from the specified effect discarding it's output.
@@ -201,7 +201,7 @@ export declare const effect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const effectDiscard: <R, E, _>(effect: Effect.Effect<R, E, _>) => Layer<R, E, never>;
+export declare const effectDiscard: <_, E, R>(effect: Effect.Effect<_, E, R>) => Layer<never, E, R>;
 /**
  * Constructs a layer from the specified effect, which must return one or more
  * services.
@@ -209,14 +209,14 @@ export declare const effectDiscard: <R, E, _>(effect: Effect.Effect<R, E, _>) =>
  * @since 2.0.0
  * @category constructors
  */
-export declare const effectContext: <R, E, A>(effect: Effect.Effect<R, E, Context.Context<A>>) => Layer<R, E, A>;
+export declare const effectContext: <A, E, R>(effect: Effect.Effect<Context.Context<A>, E, R>) => Layer<A, E, R>;
 /**
  * A Layer that constructs an empty Context.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const empty: Layer<never, never, never>;
+export declare const empty: Layer<never>;
 /**
  * Extends the scope of this layer, returning a new layer that when provided
  * to an effect will not immediately release its associated resources when
@@ -226,35 +226,35 @@ export declare const empty: Layer<never, never, never>;
  * @since 2.0.0
  * @category utils
  */
-export declare const extendScope: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<Scope.Scope | RIn, E, ROut>;
+export declare const extendScope: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, Scope.Scope | RIn>;
 /**
  * Constructs a layer that fails with the specified error.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fail: <E>(error: E) => Layer<never, E, unknown>;
+export declare const fail: <E>(error: E) => Layer<unknown, E>;
 /**
  * Constructs a layer that fails with the specified error.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const failSync: <E>(evaluate: LazyArg<E>) => Layer<never, E, unknown>;
+export declare const failSync: <E>(evaluate: LazyArg<E>) => Layer<unknown, E>;
 /**
  * Constructs a layer that fails with the specified cause.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const failCause: <E>(cause: Cause.Cause<E>) => Layer<never, E, unknown>;
+export declare const failCause: <E>(cause: Cause.Cause<E>) => Layer<unknown, E>;
 /**
  * Constructs a layer that fails with the specified cause.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Layer<never, E, unknown>;
+export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Layer<unknown, E>;
 /**
  * Constructs a layer dynamically based on the output of this layer.
  *
@@ -262,8 +262,8 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => La
  * @category sequencing
  */
 export declare const flatMap: {
-    <A, R2, E2, A2>(f: (context: Context.Context<A>) => Layer<R2, E2, A2>): <R, E>(self: Layer<R, E, A>) => Layer<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Layer<R, E, A>, f: (context: Context.Context<A>) => Layer<R2, E2, A2>): Layer<R | R2, E | E2, A2>;
+    <A, R2, E2, A2>(f: (context: Context.Context<A>) => Layer<A2, E2, R2>): <R, E>(self: Layer<A, E, R>) => Layer<A2, E2 | E, R2 | R>;
+    <R, E, A, R2, E2, A2>(self: Layer<A, E, R>, f: (context: Context.Context<A>) => Layer<A2, E2, R2>): Layer<A2, E | E2, R | R2>;
 };
 /**
  * Flattens layers nested in the context of an effect.
@@ -272,8 +272,8 @@ export declare const flatMap: {
  * @category sequencing
  */
 export declare const flatten: {
-    <R2, E2, A, I>(tag: Context.Tag<I, Layer<R2, E2, A>>): <R, E>(self: Layer<R, E, I>) => Layer<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2, I>(self: Layer<R, E, I>, tag: Context.Tag<I, Layer<R2, E2, A>>): Layer<R | R2, E | E2, A>;
+    <R2, E2, A, I>(tag: Context.Tag<I, Layer<A, E2, R2>>): <R, E>(self: Layer<I, E, R>) => Layer<A, E2 | E, R2 | R>;
+    <R, E, A, R2, E2, I>(self: Layer<I, E, R>, tag: Context.Tag<I, Layer<A, E2, R2>>): Layer<A, E | E2, R | R2>;
 };
 /**
  * Creates a fresh version of this layer that will not be shared.
@@ -281,8 +281,8 @@ export declare const flatten: {
  * @since 2.0.0
  * @category utils
  */
-export declare const fresh: <R, E, A>(self: Layer<R, E, A>) => Layer<R, E, A>;
-declare const fromFunction: <A extends Context.Tag<any, any>, B extends Context.Tag<any, any>>(tagA: A, tagB: B, f: (a: Context.Tag.Service<A>) => Context.Tag.Service<B>) => Layer<Context.Tag.Identifier<A>, never, Context.Tag.Identifier<B>>;
+export declare const fresh: <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>;
+declare const fromFunction: <A extends Context.Tag<any, any>, B extends Context.Tag<any, any>>(tagA: A, tagB: B, f: (a: Context.Tag.Service<A>) => Context.Tag.Service<B>) => Layer<Context.Tag.Identifier<B>, never, Context.Tag.Identifier<A>>;
 export { 
 /**
  * Constructs a layer from the context using the specified function.
@@ -298,7 +298,7 @@ fromFunction as function };
  * @since 2.0.0
  * @category conversions
  */
-export declare const launch: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Effect.Effect<RIn, E, never>;
+export declare const launch: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<never, E, RIn>;
 /**
  * Returns a new layer whose output is mapped by the specified function.
  *
@@ -306,8 +306,8 @@ export declare const launch: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Effect
  * @category mapping
  */
 export declare const map: {
-    <A, B>(f: (context: Context.Context<A>) => Context.Context<B>): <R, E>(self: Layer<R, E, A>) => Layer<R, E, B>;
-    <R, E, A, B>(self: Layer<R, E, A>, f: (context: Context.Context<A>) => Context.Context<B>): Layer<R, E, B>;
+    <A, B>(f: (context: Context.Context<A>) => Context.Context<B>): <R, E>(self: Layer<A, E, R>) => Layer<B, E, R>;
+    <R, E, A, B>(self: Layer<A, E, R>, f: (context: Context.Context<A>) => Context.Context<B>): Layer<B, E, R>;
 };
 /**
  * Returns a layer with its error channel mapped using the specified function.
@@ -316,8 +316,8 @@ export declare const map: {
  * @category mapping
  */
 export declare const mapError: {
-    <E, E2>(f: (error: E) => E2): <R, A>(self: Layer<R, E, A>) => Layer<R, E2, A>;
-    <R, E, A, E2>(self: Layer<R, E, A>, f: (error: E) => E2): Layer<R, E2, A>;
+    <E, E2>(f: (error: E) => E2): <R, A>(self: Layer<A, E, R>) => Layer<A, E2, R>;
+    <R, E, A, E2>(self: Layer<A, E, R>, f: (error: E) => E2): Layer<A, E2, R>;
 };
 /**
  * Feeds the error or output services of this layer into the input of either
@@ -329,13 +329,13 @@ export declare const mapError: {
  */
 export declare const match: {
     <E, R2, E2, A2, A, R3, E3, A3>(options: {
-        readonly onFailure: (error: E) => Layer<R2, E2, A2>;
-        readonly onSuccess: (context: Context.Context<A>) => Layer<R3, E3, A3>;
-    }): <R>(self: Layer<R, E, A>) => Layer<R2 | R3 | R, E2 | E3, A2 & A3>;
-    <R, E, A, R2, E2, A2, R3, E3, A3>(self: Layer<R, E, A>, options: {
-        readonly onFailure: (error: E) => Layer<R2, E2, A2>;
-        readonly onSuccess: (context: Context.Context<A>) => Layer<R3, E3, A3>;
-    }): Layer<R | R2 | R3, E2 | E3, A2 & A3>;
+        readonly onFailure: (error: E) => Layer<A2, E2, R2>;
+        readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>;
+    }): <R>(self: Layer<A, E, R>) => Layer<A2 & A3, E2 | E3, R2 | R3 | R>;
+    <R, E, A, R2, E2, A2, R3, E3, A3>(self: Layer<A, E, R>, options: {
+        readonly onFailure: (error: E) => Layer<A2, E2, R2>;
+        readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>;
+    }): Layer<A2 & A3, E2 | E3, R | R2 | R3>;
 };
 /**
  * Feeds the error or output services of this layer into the input of either
@@ -347,13 +347,13 @@ export declare const match: {
  */
 export declare const matchCause: {
     <E, A, R2, E2, A2, R3, E3, A3>(options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => Layer<R2, E2, A2>;
-        readonly onSuccess: (context: Context.Context<A>) => Layer<R3, E3, A3>;
-    }): <R>(self: Layer<R, E, A>) => Layer<R2 | R3 | R, E2 | E3, A2 & A3>;
-    <R, E, A, R2, E2, A2, R3, E3, A3>(self: Layer<R, E, A>, options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => Layer<R2, E2, A2>;
-        readonly onSuccess: (context: Context.Context<A>) => Layer<R3, E3, A3>;
-    }): Layer<R | R2 | R3, E2 | E3, A2 & A3>;
+        readonly onFailure: (cause: Cause.Cause<E>) => Layer<A2, E2, R2>;
+        readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>;
+    }): <R>(self: Layer<A, E, R>) => Layer<A2 & A3, E2 | E3, R2 | R3 | R>;
+    <R, E, A, R2, E2, A2, R3, E3, A3>(self: Layer<A, E, R>, options: {
+        readonly onFailure: (cause: Cause.Cause<E>) => Layer<A2, E2, R2>;
+        readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>;
+    }): Layer<A2 & A3, E2 | E3, R | R2 | R3>;
 };
 /**
  * Returns a scoped effect that, if evaluated, will return the lazily computed
@@ -362,7 +362,7 @@ export declare const matchCause: {
  * @since 2.0.0
  * @category utils
  */
-export declare const memoize: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Effect.Effect<Scope.Scope, never, Layer<RIn, E, ROut>>;
+export declare const memoize: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Layer<ROut, E, RIn>, never, Scope.Scope>;
 /**
  * Merges this layer with the specified layer concurrently, producing a new layer with combined input and output types.
  *
@@ -370,8 +370,8 @@ export declare const memoize: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Effec
  * @category zipping
  */
 export declare const merge: {
-    <RIn2, E2, ROut2>(that: Layer<RIn2, E2, ROut2>): <RIn, E1, ROut>(self: Layer<RIn, E1, ROut>) => Layer<RIn2 | RIn, E2 | E1, ROut2 | ROut>;
-    <RIn, E1, ROut, RIn2, E2, ROut2>(self: Layer<RIn, E1, ROut>, that: Layer<RIn2, E2, ROut2>): Layer<RIn | RIn2, E1 | E2, ROut | ROut2>;
+    <RIn2, E2, ROut2>(that: Layer<ROut2, E2, RIn2>): <RIn, E1, ROut>(self: Layer<ROut, E1, RIn>) => Layer<ROut2 | ROut, E2 | E1, RIn2 | RIn>;
+    <RIn, E1, ROut, RIn2, E2, ROut2>(self: Layer<ROut, E1, RIn>, that: Layer<ROut2, E2, RIn2>): Layer<ROut | ROut2, E1 | E2, RIn | RIn2>;
 };
 /**
  * Combines all the provided layers concurrently, creating a new layer with merged input, error, and output types.
@@ -379,12 +379,12 @@ export declare const merge: {
  * @since 2.0.0
  * @category zipping
  */
-export declare const mergeAll: <Layers extends [Layer<any, any, never>, ...Array<Layer<any, any, never>>]>(...layers: Layers) => Layer<{
-    [k in keyof Layers]: Layer.Context<Layers[k]>;
+export declare const mergeAll: <Layers extends [Layer<never, any, any>, ...Array<Layer<never, any, any>>]>(...layers: Layers) => Layer<{
+    [k in keyof Layers]: Layer.Success<Layers[k]>;
 }[number], {
     [k in keyof Layers]: Layer.Error<Layers[k]>;
 }[number], {
-    [k in keyof Layers]: Layer.Success<Layers[k]>;
+    [k in keyof Layers]: Layer.Context<Layers[k]>;
 }[number]>;
 /**
  * Translates effect failure into death of the fiber, making all failures
@@ -393,7 +393,7 @@ export declare const mergeAll: <Layers extends [Layer<any, any, never>, ...Array
  * @since 2.0.0
  * @category error handling
  */
-export declare const orDie: <R, E, A>(self: Layer<R, E, A>) => Layer<R, never, A>;
+export declare const orDie: <A, E, R>(self: Layer<A, E, R>) => Layer<A, never, R>;
 /**
  * Executes this layer and returns its output, if it succeeds, but otherwise
  * executes the specified layer.
@@ -402,8 +402,8 @@ export declare const orDie: <R, E, A>(self: Layer<R, E, A>) => Layer<R, never, A
  * @category error handling
  */
 export declare const orElse: {
-    <R2, E2, A2>(that: LazyArg<Layer<R2, E2, A2>>): <R, E, A>(self: Layer<R, E, A>) => Layer<R2 | R, E2 | E, A & A2>;
-    <R, E, A, R2, E2, A2>(self: Layer<R, E, A>, that: LazyArg<Layer<R2, E2, A2>>): Layer<R | R2, E | E2, A & A2>;
+    <R2, E2, A2>(that: LazyArg<Layer<A2, E2, R2>>): <A, E, R>(self: Layer<A, E, R>) => Layer<A & A2, E2 | E, R2 | R>;
+    <R, E, A, R2, E2, A2>(self: Layer<A, E, R>, that: LazyArg<Layer<A2, E2, R2>>): Layer<A & A2, E | E2, R | R2>;
 };
 /**
  * Returns a new layer that produces the outputs of this layer but also
@@ -412,7 +412,7 @@ export declare const orElse: {
  * @since 2.0.0
  * @category utils
  */
-export declare const passthrough: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn, E, RIn | ROut>;
+export declare const passthrough: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Layer<RIn | ROut, E, RIn>;
 /**
  * Projects out part of one of the services output by this layer using the
  * specified function.
@@ -421,43 +421,43 @@ export declare const passthrough: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => L
  * @category utils
  */
 export declare const project: {
-    <A extends Context.Tag<any, any>, B extends Context.Tag<any, any>>(tagA: A, tagB: B, f: (a: Context.Tag.Service<A>) => Context.Tag.Service<B>): <RIn, E>(self: Layer<RIn, E, Context.Tag.Identifier<A>>) => Layer<RIn, E, Context.Tag.Identifier<B>>;
-    <RIn, E, A extends Context.Tag<any, any>, B extends Context.Tag<any, any>>(self: Layer<RIn, E, Context.Tag.Identifier<A>>, tagA: A, tagB: B, f: (a: Context.Tag.Service<A>) => Context.Tag.Service<B>): Layer<RIn, E, Context.Tag.Identifier<B>>;
+    <A extends Context.Tag<any, any>, B extends Context.Tag<any, any>>(tagA: A, tagB: B, f: (a: Context.Tag.Service<A>) => Context.Tag.Service<B>): <RIn, E>(self: Layer<Context.Tag.Identifier<A>, E, RIn>) => Layer<Context.Tag.Identifier<B>, E, RIn>;
+    <RIn, E, A extends Context.Tag<any, any>, B extends Context.Tag<any, any>>(self: Layer<Context.Tag.Identifier<A>, E, RIn>, tagA: A, tagB: B, f: (a: Context.Tag.Service<A>) => Context.Tag.Service<B>): Layer<Context.Tag.Identifier<B>, E, RIn>;
 };
 /**
  * @since 2.0.0
  * @category utils
  */
 export declare const locallyEffect: {
-    <RIn, E, ROut, RIn2, E2, ROut2>(f: (_: Effect.Effect<RIn, E, Context.Context<ROut>>) => Effect.Effect<RIn2, E2, Context.Context<ROut2>>): (self: Layer<RIn, E, ROut>) => Layer<RIn2, E2, ROut2>;
-    <RIn, E, ROut, RIn2, E2, ROut2>(self: Layer<RIn, E, ROut>, f: (_: Effect.Effect<RIn, E, Context.Context<ROut>>) => Effect.Effect<RIn2, E2, Context.Context<ROut2>>): Layer<RIn2, E2, ROut2>;
+    <RIn, E, ROut, RIn2, E2, ROut2>(f: (_: Effect.Effect<RIn, E, Context.Context<ROut>>) => Effect.Effect<RIn2, E2, Context.Context<ROut2>>): (self: Layer<ROut, E, RIn>) => Layer<ROut2, E2, RIn2>;
+    <RIn, E, ROut, RIn2, E2, ROut2>(self: Layer<ROut, E, RIn>, f: (_: Effect.Effect<RIn, E, Context.Context<ROut>>) => Effect.Effect<RIn2, E2, Context.Context<ROut2>>): Layer<ROut2, E2, RIn2>;
 };
 /**
  * @since 2.0.0
  * @category utils
  */
 export declare const locally: {
-    <X>(ref: FiberRef<X>, value: X): <R, E, A>(self: Layer<R, E, A>) => Layer<R, E, A>;
-    <R, E, A, X>(self: Layer<R, E, A>, ref: FiberRef<X>, value: X): Layer<R, E, A>;
+    <X>(ref: FiberRef<X>, value: X): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>;
+    <R, E, A, X>(self: Layer<A, E, R>, ref: FiberRef<X>, value: X): Layer<A, E, R>;
 };
 /**
  * @since 2.0.0
  * @category utils
  */
 export declare const locallyWith: {
-    <X>(ref: FiberRef<X>, value: (_: X) => X): <R, E, A>(self: Layer<R, E, A>) => Layer<R, E, A>;
-    <R, E, A, X>(self: Layer<R, E, A>, ref: FiberRef<X>, value: (_: X) => X): Layer<R, E, A>;
+    <X>(ref: FiberRef<X>, value: (_: X) => X): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>;
+    <R, E, A, X>(self: Layer<A, E, R>, ref: FiberRef<X>, value: (_: X) => X): Layer<A, E, R>;
 };
 /**
  * @since 2.0.0
  * @category utils
  */
-export declare const locallyScoped: <A>(self: FiberRef<A>, value: A) => Layer<never, never, never>;
+export declare const locallyScoped: <A>(self: FiberRef<A>, value: A) => Layer<never>;
 /**
  * @since 2.0.0
  * @category utils
  */
-export declare const fiberRefLocallyScopedWith: <A>(self: FiberRef<A>, value: (_: A) => A) => Layer<never, never, never>;
+export declare const fiberRefLocallyScopedWith: <A>(self: FiberRef<A>, value: (_: A) => A) => Layer<never>;
 /**
  * Retries constructing this layer according to the specified schedule.
  *
@@ -465,8 +465,8 @@ export declare const fiberRefLocallyScopedWith: <A>(self: FiberRef<A>, value: (_
  * @category retrying
  */
 export declare const retry: {
-    <RIn2, E, X>(schedule: Schedule.Schedule<RIn2, E, X>): <RIn, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn2 | RIn, E, ROut>;
-    <RIn, E, ROut, RIn2, X>(self: Layer<RIn, E, ROut>, schedule: Schedule.Schedule<RIn2, E, X>): Layer<RIn | RIn2, E, ROut>;
+    <RIn2, E, X>(schedule: Schedule.Schedule<RIn2, E, X>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, RIn2 | RIn>;
+    <RIn, E, ROut, RIn2, X>(self: Layer<ROut, E, RIn>, schedule: Schedule.Schedule<RIn2, E, X>): Layer<ROut, E, RIn | RIn2>;
 };
 /**
  * A layer that constructs a scope and closes it when the workflow the layer
@@ -477,7 +477,7 @@ export declare const retry: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const scope: Layer<never, never, Scope.CloseableScope>;
+export declare const scope: Layer<Scope.CloseableScope>;
 /**
  * Constructs a layer from the specified scoped effect.
  *
@@ -485,8 +485,8 @@ export declare const scope: Layer<never, never, Scope.CloseableScope>;
  * @category constructors
  */
 export declare const scoped: {
-    <T extends Context.Tag<any, any>>(tag: T): <R, E>(effect: Effect.Effect<R, E, Context.Tag.Service<T>>) => Layer<Exclude<R, Scope.Scope>, E, Context.Tag.Identifier<T>>;
-    <T extends Context.Tag<any, any>, R, E>(tag: T, effect: Effect.Effect<R, E, Context.Tag.Service<T>>): Layer<Exclude<R, Scope.Scope>, E, Context.Tag.Identifier<T>>;
+    <T extends Context.Tag<any, any>>(tag: T): <R, E>(effect: Effect.Effect<Context.Tag.Service<T>, E, R>) => Layer<Context.Tag.Identifier<T>, E, Exclude<R, Scope.Scope>>;
+    <T extends Context.Tag<any, any>, R, E>(tag: T, effect: Effect.Effect<Context.Tag.Service<T>, E, R>): Layer<Context.Tag.Identifier<T>, E, Exclude<R, Scope.Scope>>;
 };
 /**
  * Constructs a layer from the specified scoped effect.
@@ -494,7 +494,7 @@ export declare const scoped: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const scopedDiscard: <R, E, T>(effect: Effect.Effect<R, E, T>) => Layer<Exclude<R, Scope.Scope>, E, never>;
+export declare const scopedDiscard: <_, E, R>(effect: Effect.Effect<_, E, R>) => Layer<never, E, Exclude<R, Scope.Scope>>;
 /**
  * Constructs a layer from the specified scoped effect, which must return one
  * or more services.
@@ -502,7 +502,7 @@ export declare const scopedDiscard: <R, E, T>(effect: Effect.Effect<R, E, T>) =>
  * @since 2.0.0
  * @category constructors
  */
-export declare const scopedContext: <R, E, A>(effect: Effect.Effect<R, E, Context.Context<A>>) => Layer<Exclude<R, Scope.Scope>, E, A>;
+export declare const scopedContext: <A, E, R>(effect: Effect.Effect<Context.Context<A>, E, R>) => Layer<A, E, Exclude<R, Scope.Scope>>;
 /**
  * Constructs a layer that accesses and returns the specified service from the
  * context.
@@ -518,8 +518,8 @@ export declare const service: <T extends Context.Tag<any, any>>(tag: T) => Layer
  * @category constructors
  */
 export declare const succeed: {
-    <T extends Context.Tag<any, any>>(tag: T): (resource: Context.Tag.Service<T>) => Layer<never, never, Context.Tag.Identifier<T>>;
-    <T extends Context.Tag<any, any>>(tag: T, resource: Context.Tag.Service<T>): Layer<never, never, Context.Tag.Identifier<T>>;
+    <T extends Context.Tag<any, any>>(tag: T): (resource: Context.Tag.Service<T>) => Layer<Context.Tag.Identifier<T>>;
+    <T extends Context.Tag<any, any>>(tag: T, resource: Context.Tag.Service<T>): Layer<Context.Tag.Identifier<T>>;
 };
 /**
  * Constructs a layer from the specified value, which must return one or more
@@ -528,7 +528,7 @@ export declare const succeed: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const succeedContext: <A>(context: Context.Context<A>) => Layer<never, never, A>;
+export declare const succeedContext: <A>(context: Context.Context<A>) => Layer<A>;
 /**
  * Lazily constructs a layer. This is useful to avoid infinite recursion when
  * creating layers that refer to themselves.
@@ -536,7 +536,7 @@ export declare const succeedContext: <A>(context: Context.Context<A>) => Layer<n
  * @since 2.0.0
  * @category constructors
  */
-export declare const suspend: <RIn, E, ROut>(evaluate: LazyArg<Layer<RIn, E, ROut>>) => Layer<RIn, E, ROut>;
+export declare const suspend: <RIn, E, ROut>(evaluate: LazyArg<Layer<ROut, E, RIn>>) => Layer<ROut, E, RIn>;
 /**
  * Lazily constructs a layer from the specified value.
  *
@@ -544,8 +544,8 @@ export declare const suspend: <RIn, E, ROut>(evaluate: LazyArg<Layer<RIn, E, ROu
  * @category constructors
  */
 export declare const sync: {
-    <T extends Context.Tag<any, any>>(tag: T): (evaluate: LazyArg<Context.Tag.Service<T>>) => Layer<never, never, Context.Tag.Identifier<T>>;
-    <T extends Context.Tag<any, any>>(tag: T, evaluate: LazyArg<Context.Tag.Service<T>>): Layer<never, never, Context.Tag.Identifier<T>>;
+    <T extends Context.Tag<any, any>>(tag: T): (evaluate: LazyArg<Context.Tag.Service<T>>) => Layer<Context.Tag.Identifier<T>>;
+    <T extends Context.Tag<any, any>>(tag: T, evaluate: LazyArg<Context.Tag.Service<T>>): Layer<Context.Tag.Identifier<T>>;
 };
 /**
  * Lazily constructs a layer from the specified value, which must return one or more
@@ -554,7 +554,7 @@ export declare const sync: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const syncContext: <A>(evaluate: LazyArg<Context.Context<A>>) => Layer<never, never, A>;
+export declare const syncContext: <A>(evaluate: LazyArg<Context.Context<A>>) => Layer<A>;
 /**
  * Performs the specified effect if this layer succeeds.
  *
@@ -562,8 +562,8 @@ export declare const syncContext: <A>(evaluate: LazyArg<Context.Context<A>>) =>
  * @category sequencing
  */
 export declare const tap: {
-    <ROut, XR extends ROut, RIn2, E2, X>(f: (context: Context.Context<XR>) => Effect.Effect<RIn2, E2, X>): <RIn, E>(self: Layer<RIn, E, ROut>) => Layer<RIn2 | RIn, E2 | E, ROut>;
-    <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(self: Layer<RIn, E, ROut>, f: (context: Context.Context<XR>) => Effect.Effect<RIn2, E2, X>): Layer<RIn | RIn2, E | E2, ROut>;
+    <ROut, XR extends ROut, RIn2, E2, X>(f: (context: Context.Context<XR>) => Effect.Effect<X, E2, RIn2>): <RIn, E>(self: Layer<ROut, E, RIn>) => Layer<ROut, E2 | E, RIn2 | RIn>;
+    <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(self: Layer<ROut, E, RIn>, f: (context: Context.Context<XR>) => Effect.Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | RIn2>;
 };
 /**
  * Performs the specified effect if this layer fails.
@@ -572,8 +572,8 @@ export declare const tap: {
  * @category sequencing
  */
 export declare const tapError: {
-    <E, XE extends E, RIn2, E2, X>(f: (e: XE) => Effect.Effect<RIn2, E2, X>): <RIn, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn2 | RIn, E | E2, ROut>;
-    <RIn, E, XE extends E, ROut, RIn2, E2, X>(self: Layer<RIn, E, ROut>, f: (e: XE) => Effect.Effect<RIn2, E2, X>): Layer<RIn | RIn2, E | E2, ROut>;
+    <E, XE extends E, RIn2, E2, X>(f: (e: XE) => Effect.Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn2 | RIn>;
+    <RIn, E, XE extends E, ROut, RIn2, E2, X>(self: Layer<ROut, E, RIn>, f: (e: XE) => Effect.Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | RIn2>;
 };
 /**
  * Performs the specified effect if this layer fails.
@@ -582,8 +582,8 @@ export declare const tapError: {
  * @category sequencing
  */
 export declare const tapErrorCause: {
-    <E, XE extends E, RIn2, E2, X>(f: (cause: Cause.Cause<XE>) => Effect.Effect<RIn2, E2, X>): <RIn, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn2 | RIn, E | E2, ROut>;
-    <RIn, E, XE extends E, ROut, RIn2, E2, X>(self: Layer<RIn, E, ROut>, f: (cause: Cause.Cause<XE>) => Effect.Effect<RIn2, E2, X>): Layer<RIn | RIn2, E | E2, ROut>;
+    <E, XE extends E, RIn2, E2, X>(f: (cause: Cause.Cause<XE>) => Effect.Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn2 | RIn>;
+    <RIn, E, XE extends E, ROut, RIn2, E2, X>(self: Layer<ROut, E, RIn>, f: (cause: Cause.Cause<XE>) => Effect.Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | RIn2>;
 };
 /**
  * Converts a layer that requires no services into a scoped runtime, which can
@@ -592,7 +592,7 @@ export declare const tapErrorCause: {
  * @since 2.0.0
  * @category conversions
  */
-export declare const toRuntime: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Effect.Effect<Scope.Scope | RIn, E, Runtime.Runtime<ROut>>;
+export declare const toRuntime: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Runtime.Runtime<ROut>, E, Scope.Scope | RIn>;
 /**
  * Feeds the output services of this builder into the input of the specified
  * builder, resulting in a new builder with the inputs of this builder as
@@ -602,8 +602,8 @@ export declare const toRuntime: <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Eff
  * @category utils
  */
 export declare const provide: {
-    <RIn, E, ROut>(self: Layer<RIn, E, ROut>): <RIn2, E2, ROut2>(that: Layer<RIn2, E2, ROut2>) => Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut2>;
-    <RIn2, E2, ROut2, RIn, E, ROut>(that: Layer<RIn2, E2, ROut2>, self: Layer<RIn, E, ROut>): Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut2>;
+    <RIn, E, ROut>(self: Layer<ROut, E, RIn>): <RIn2, E2, ROut2>(that: Layer<ROut2, E2, RIn2>) => Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>;
+    <RIn2, E2, ROut2, RIn, E, ROut>(that: Layer<ROut2, E2, RIn2>, self: Layer<ROut, E, RIn>): Layer<ROut2, E2 | E, RIn | Exclude<RIn2, ROut>>;
 };
 /**
  * Feeds the output services of this layer into the input of the specified
@@ -614,8 +614,8 @@ export declare const provide: {
  * @category utils
  */
 export declare const provideMerge: {
-    <RIn, E, ROut>(self: Layer<RIn, E, ROut>): <RIn2, E2, ROut2>(that: Layer<RIn2, E2, ROut2>) => Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut | ROut2>;
-    <RIn2, E2, ROut2, RIn, E, ROut>(that: Layer<RIn2, E2, ROut2>, self: Layer<RIn, E, ROut>): Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut2 | ROut>;
+    <RIn, E, ROut>(self: Layer<ROut, E, RIn>): <RIn2, E2, ROut2>(that: Layer<ROut2, E2, RIn2>) => Layer<ROut | ROut2, E | E2, RIn | Exclude<RIn2, ROut>>;
+    <RIn2, E2, ROut2, RIn, E, ROut>(that: Layer<ROut2, E2, RIn2>, self: Layer<ROut, E, RIn>): Layer<ROut2 | ROut, E2 | E, RIn | Exclude<RIn2, ROut>>;
 };
 /**
  * Combines this layer with the specified layer concurrently, creating a new layer with merged input types and
@@ -625,61 +625,61 @@ export declare const provideMerge: {
  * @category zipping
  */
 export declare const zipWith: {
-    <R2, E2, B, A, C>(that: Layer<R2, E2, B>, f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>): <R, E>(self: Layer<R, E, A>) => Layer<R2 | R, E2 | E, C>;
-    <R, E, R2, E2, B, A, C>(self: Layer<R, E, A>, that: Layer<R2, E2, B>, f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>): Layer<R | R2, E | E2, C>;
+    <R2, E2, B, A, C>(that: Layer<B, E2, R2>, f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>): <R, E>(self: Layer<A, E, R>) => Layer<C, E2 | E, R2 | R>;
+    <R, E, R2, E2, B, A, C>(self: Layer<A, E, R>, that: Layer<B, E2, R2>, f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>): Layer<C, E | E2, R | R2>;
 };
 /**
  * @since 2.0.0
  * @category utils
  */
-export declare const unwrapEffect: <R, E, R1, E1, A>(self: Effect.Effect<R, E, Layer<R1, E1, A>>) => Layer<R | R1, E | E1, A>;
+export declare const unwrapEffect: <R, E, R1, E1, A>(self: Effect.Effect<Layer<A, E1, R1>, E, R>) => Layer<A, E | E1, R | R1>;
 /**
  * @since 2.0.0
  * @category utils
  */
-export declare const unwrapScoped: <R, E, R1, E1, A>(self: Effect.Effect<R, E, Layer<R1, E1, A>>) => Layer<R1 | Exclude<R, Scope.Scope>, E | E1, A>;
+export declare const unwrapScoped: <R, E, R1, E1, A>(self: Effect.Effect<Layer<A, E1, R1>, E, R>) => Layer<A, E | E1, R1 | Exclude<R, Scope.Scope>>;
 /**
  * @since 2.0.0
  * @category clock
  */
-export declare const setClock: <A extends Clock.Clock>(clock: A) => Layer<never, never, never>;
+export declare const setClock: <A extends Clock.Clock>(clock: A) => Layer<never>;
 /**
  * Sets the current `ConfigProvider`.
  *
  * @since 2.0.0
  * @category config
  */
-export declare const setConfigProvider: (configProvider: ConfigProvider) => Layer<never, never, never>;
+export declare const setConfigProvider: (configProvider: ConfigProvider) => Layer<never>;
 /**
  * Adds the provided span to the span stack.
  *
  * @since 2.0.0
  * @category tracing
  */
-export declare const parentSpan: (span: Tracer.ParentSpan) => Layer<never, never, Tracer.ParentSpan>;
+export declare const parentSpan: (span: Tracer.ParentSpan) => Layer<Tracer.ParentSpan>;
 /**
  * @since 2.0.0
  * @category requests & batching
  */
-export declare const setRequestBatching: (requestBatching: boolean) => Layer<never, never, never>;
+export declare const setRequestBatching: (requestBatching: boolean) => Layer<never>;
 /**
  * @since 2.0.0
  * @category requests & batching
  */
-export declare const setRequestCaching: (requestCaching: boolean) => Layer<never, never, never>;
+export declare const setRequestCaching: (requestCaching: boolean) => Layer<never>;
 /**
  * @since 2.0.0
  * @category requests & batching
  */
 export declare const setRequestCache: {
-    <R, E>(cache: Effect.Effect<R, E, Request.Cache>): Layer<Exclude<R, Scope.Scope>, E, never>;
-    (cache: Request.Cache): Layer<never, never, never>;
+    <E, R>(cache: Effect.Effect<Request.Cache, E, R>): Layer<never, E, Exclude<R, Scope.Scope>>;
+    (cache: Request.Cache): Layer<never>;
 };
 /**
  * @since 2.0.0
  * @category scheduler
  */
-export declare const setScheduler: (scheduler: Scheduler.Scheduler) => Layer<never, never, never>;
+export declare const setScheduler: (scheduler: Scheduler.Scheduler) => Layer<never>;
 /**
  * Create and add a span to the current span stack.
  *
@@ -694,25 +694,25 @@ export declare const span: (name: string, options?: {
     readonly parent?: Tracer.ParentSpan | undefined;
     readonly root?: boolean | undefined;
     readonly context?: Context.Context<never> | undefined;
-    readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>) | undefined;
-}) => Layer<never, never, Tracer.ParentSpan>;
+    readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>) | undefined;
+}) => Layer<Tracer.ParentSpan>;
 /**
  * Create a Layer that sets the current Tracer
  *
  * @since 2.0.0
  * @category tracing
  */
-export declare const setTracer: (tracer: Tracer.Tracer) => Layer<never, never, never>;
+export declare const setTracer: (tracer: Tracer.Tracer) => Layer<never>;
 /**
  * @since 2.0.0
  * @category tracing
  */
-export declare const setTracerTiming: (enabled: boolean) => Layer<never, never, never>;
+export declare const setTracerTiming: (enabled: boolean) => Layer<never>;
 /**
  * @since 2.0.0
  * @category logging
  */
-export declare const setUnhandledErrorLogLevel: (level: Option.Option<LogLevel>) => Layer<never, never, never>;
+export declare const setUnhandledErrorLogLevel: (level: Option.Option<LogLevel>) => Layer<never>;
 /**
  * @since 2.0.0
  * @category tracing
@@ -724,24 +724,24 @@ export declare const withSpan: {
         readonly parent?: Tracer.ParentSpan | undefined;
         readonly root?: boolean | undefined;
         readonly context?: Context.Context<never> | undefined;
-        readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>) | undefined;
-    }): <R, E, A>(self: Layer<R, E, A>) => Layer<Exclude<R, Tracer.ParentSpan>, E, A>;
-    <R, E, A>(self: Layer<R, E, A>, name: string, options?: {
+        readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>) | undefined;
+    }): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, Exclude<R, Tracer.ParentSpan>>;
+    <A, E, R>(self: Layer<A, E, R>, name: string, options?: {
         readonly attributes?: Record<string, unknown> | undefined;
         readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
         readonly parent?: Tracer.ParentSpan | undefined;
         readonly root?: boolean | undefined;
         readonly context?: Context.Context<never> | undefined;
-        readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>) | undefined;
-    }): Layer<Exclude<R, Tracer.ParentSpan>, E, A>;
+        readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>) | undefined;
+    }): Layer<A, E, Exclude<R, Tracer.ParentSpan>>;
 };
 /**
  * @since 2.0.0
  * @category tracing
  */
 export declare const withParentSpan: {
-    (span: Tracer.ParentSpan): <R, E, A>(self: Layer<R, E, A>) => Layer<Exclude<R, Tracer.ParentSpan>, E, A>;
-    <R, E, A>(self: Layer<R, E, A>, span: Tracer.ParentSpan): Layer<Exclude<R, Tracer.ParentSpan>, E, A>;
+    (span: Tracer.ParentSpan): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, Exclude<R, Tracer.ParentSpan>>;
+    <A, E, R>(self: Layer<A, E, R>, span: Tracer.ParentSpan): Layer<A, E, Exclude<R, Tracer.ParentSpan>>;
 };
 /**
  * Constructs a `MemoMap` that can be used to build additional layers.
@@ -749,7 +749,7 @@ export declare const withParentSpan: {
  * @since 2.0.0
  * @category memo map
  */
-export declare const makeMemoMap: Effect.Effect<never, never, MemoMap>;
+export declare const makeMemoMap: Effect.Effect<MemoMap>;
 /**
  * Builds a layer into an `Effect` value, using the specified `MemoMap` to memoize
  * the layer construction.
@@ -758,7 +758,7 @@ export declare const makeMemoMap: Effect.Effect<never, never, MemoMap>;
  * @category memo map
  */
 export declare const buildWithMemoMap: {
-    (memoMap: MemoMap, scope: Scope.Scope): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Effect.Effect<RIn, E, Context.Context<ROut>>;
-    <RIn, E, ROut>(self: Layer<RIn, E, ROut>, memoMap: MemoMap, scope: Scope.Scope): Effect.Effect<RIn, E, Context.Context<ROut>>;
+    (memoMap: MemoMap, scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Context.Context<ROut>, E, RIn>;
+    <RIn, E, ROut>(self: Layer<ROut, E, RIn>, memoMap: MemoMap, scope: Scope.Scope): Effect.Effect<Context.Context<ROut>, E, RIn>;
 };
 //# sourceMappingURL=Layer.d.ts.map