@typed/fx 1.22.2 → 1.24.0

package/dist/dts/Fx.d.ts

@@ -24,12 +24,12 @@ import { TypeId } from "./TypeId.js";
  * Fx is a push-based reactive primitive built atop of Effect.
  * @since 1.20.0
  */
-export interface Fx<out R, out E, out A> extends Pipeable.Pipeable {
-    readonly [TypeId]: Fx.Variance<R, E, A>;
+export interface Fx<out A, out E = never, out R = never> extends Pipeable.Pipeable {
+    readonly [TypeId]: Fx.Variance<A, E, R>;
     /**
      * @since 1.20.0
      */
-    run<R2 = never>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown>;
+    run<R2 = never>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2>;
 }
 /**
  * @since 1.20.0
@@ -38,7 +38,7 @@ export declare namespace Fx {
     /**
      * @since 1.20.0
      */
-    interface Variance<R, E, A> {
+    interface Variance<A, E, R> {
         readonly _R: Types.Covariant<R>;
         readonly _E: Types.Covariant<E>;
         readonly _A: Types.Covariant<A>;
@@ -46,19 +46,19 @@ export declare namespace Fx {
     /**
      * @since 1.20.0
      */
-    type Context<T> = T extends Fx<infer R, infer _E, infer _A> ? R : never;
+    type Context<T> = T extends Fx<infer _A, infer _E, infer R> ? R : never;
     /**
      * @since 1.20.0
      */
-    type Error<T> = T extends Fx<infer _R, infer E, infer _A> ? E : never;
+    type Error<T> = T extends Fx<infer _A, infer E, infer _R> ? E : never;
     /**
      * @since 1.20.0
      */
-    type Success<T> = T extends Fx<infer _R, infer _E, infer A> ? A : never;
+    type Success<T> = T extends Fx<infer A, infer _E, infer _R> ? A : never;
     /**
      * @since 1.20.0
      */
-    type Unify<T> = T extends Fx<infer R, infer E, infer A> | infer _ ? Fx<R, E, A> : never;
+    type Unify<T> = T extends Fx<infer A, infer E, infer R> | infer _ ? Fx<A, E, R> : never;
 }
 /**
  * @since 1.20.0
@@ -79,7 +79,7 @@ export type Unify<T> = Fx.Unify<T>;
 /**
  * @since 1.20.0
  */
-export declare function isFx<R, E, A>(u: unknown): u is Fx<R, E, A>;
+export declare function isFx<A, E, R>(u: unknown): u is Fx<A, E, R>;
 /**
  * FlattenStrategy is a representation of how higher-order effect operators should flatten
  * nested Fx.
@@ -207,7 +207,7 @@ export declare const Ordered: (concurrency: number) => Ordered;
  * @since 1.20.0
  * @category models
  */
-export type ScopedFork = <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, never, Fiber.Fiber<E, A>>;
+export type ScopedFork = <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Fiber.Fiber<A, E>, never, R>;
 /**
  * Type-alias for Effect.forkIn(scope) which runs the Effect runtime
  * of an Fx in a Scope. Used in for higher-order operators.
@@ -215,650 +215,650 @@ export type ScopedFork = <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Eff
  * @since 1.20.0
  * @category models
  */
-export type FxFork = <R>(effect: Effect.Effect<R, never, void>) => Effect.Effect<R, never, void>;
+export type FxFork = <R>(effect: Effect.Effect<void, never, R>) => Effect.Effect<void, never, R>;
 /**
  * @since 1.20.0
  */
 export declare const make: {
-    <R, E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<R, never, unknown>): Fx<R, E, A>;
-    <E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<never, never, unknown>): Fx<never, E, A>;
-    <A>(run: (sink: Sink.Sink<never, never, A>) => Effect.Effect<never, never, unknown>): Fx<never, never, A>;
+    <A, E, R>(run: (sink: Sink.Sink<A, E>) => Effect.Effect<unknown, never, R>): Fx<A, E, R>;
+    <A, E>(run: (sink: Sink.Sink<A, E>) => Effect.Effect<unknown>): Fx<A, E>;
+    <A>(run: (sink: Sink.Sink<A>) => Effect.Effect<unknown>): Fx<A>;
 };
 /**
  * @since 1.20.0
  */
-export declare const succeed: <A>(value: A) => Fx<never, never, A>;
+export declare const succeed: <A>(value: A) => Fx<A>;
 /**
  * @since 1.20.0
  */
-export declare const sync: <A>(f: () => A) => Fx<never, never, A>;
+export declare const sync: <A>(f: () => A) => Fx<A>;
 /**
  * @since 1.20.0
  */
-export declare const fromArray: <const A extends ReadonlyArray<any>>(array: A) => Fx<never, never, A[number]>;
+export declare const fromArray: <const A extends ReadonlyArray<any>>(array: A) => Fx<A[number]>;
 /**
  * @since 1.20.0
  */
-export declare const fromIterable: <A>(iterable: Iterable<A>) => Fx<never, never, A>;
+export declare const fromIterable: <A>(iterable: Iterable<A>) => Fx<A>;
 /**
  * @since 1.20.0
  */
-export declare const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Fx<R, E, A>;
+export declare const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Fx<A, E, R>;
 /**
  * @since 1.20.0
  */
 export declare const fromScheduled: {
-    <R2, I, O>(schedule: Schedule.Schedule<R2, I, O>): <R, E>(input: Effect.Effect<R, E, I>) => Fx<R | R2, E, O>;
-    <R, E, I, R2, O>(input: Effect.Effect<R, E, I>, schedule: Schedule.Schedule<R2, I, O>): Fx<R | R2, E, O>;
+    <R2, I, O>(schedule: Schedule.Schedule<R2, I, O>): <E, R>(input: Effect.Effect<I, E, R>) => Fx<O, E, R | R2>;
+    <I, E, R, R2, O>(input: Effect.Effect<I, E, R>, schedule: Schedule.Schedule<R2, I, O>): Fx<O, E, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const schedule: {
-    <R2, O>(schedule: Schedule.Schedule<R2, unknown, O>): <R, E, A>(input: Effect.Effect<R, E, A>) => Fx<R | R2, E, A>;
-    <R, E, A, R2, O>(input: Effect.Effect<R, E, A>, schedule: Schedule.Schedule<R2, unknown, O>): Fx<R | R2, E, A>;
+    <R2, O>(schedule: Schedule.Schedule<R2, unknown, O>): <A, E, R>(input: Effect.Effect<A, E, R>) => Fx<A, E, R | R2>;
+    <A, E, R, R2, O>(input: Effect.Effect<A, E, R>, schedule: Schedule.Schedule<R2, unknown, O>): Fx<A, E, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const periodic: {
-    (period: Duration.DurationInput): <R, E, A>(iterator: Effect.Effect<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(iterator: Effect.Effect<R, E, A>, period: Duration.DurationInput): Fx<R, E, A>;
+    (period: Duration.DurationInput): <A, E, R>(iterator: Effect.Effect<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(iterator: Effect.Effect<A, E, R>, period: Duration.DurationInput): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
-export declare const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never>;
+export declare const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E>;
 /**
  * @since 1.20.0
  */
-export declare const fail: <E>(error: E) => Fx<never, E, never>;
+export declare const fail: <E>(error: E) => Fx<never, E>;
 /**
  * @since 1.20.0
  */
-export declare const die: (error: unknown) => Fx<never, never, never>;
+export declare const die: (error: unknown) => Fx<never>;
 /**
  * @since 1.20.0
  */
 export declare const map: {
-    <A, B>(f: (a: A) => B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>;
-    <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B>;
+    <A, B>(f: (a: A) => B): <E, R>(fx: Fx<A, E, R>) => Fx<B, E, R>;
+    <A, E, R, B>(fx: Fx<A, E, R>, f: (a: A) => B): Fx<B, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filter: {
-    <A, B extends A>(f: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>;
-    <A>(f: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A, B extends A>(fx: Fx<R, E, A>, f: Predicate.Refinement<A, B>): Fx<R, E, B>;
-    <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>;
+    <A, B extends A>(f: Predicate.Refinement<A, B>): <E, R>(fx: Fx<A, E, R>) => Fx<B, E, R>;
+    <A>(f: Predicate.Predicate<A>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R, B extends A>(fx: Fx<A, E, R>, f: Predicate.Refinement<A, B>): Fx<B, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterMap: {
-    <A, B>(f: (a: A) => Option.Option<B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>;
-    <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Option.Option<B>): Fx<R, E, B>;
+    <A, B>(f: (a: A) => Option.Option<B>): <E, R>(fx: Fx<A, E, R>) => Fx<B, E, R>;
+    <A, E, R, B>(fx: Fx<A, E, R>, f: (a: A) => Option.Option<B>): Fx<B, E, R>;
 };
 /**
  * @since 1.20.0
  */
-export declare const compact: <R, E, A>(fx: Fx<R, E, Option.Option<A>>) => Fx<R, E, A>;
+export declare const compact: <A, E, R>(fx: Fx<Option.Option<A>, E, R>) => Fx<A, E, R>;
 /**
  * @since 1.20.0
  */
 export declare const mapEffect: {
-    <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Fx<R | R2, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>): Fx<B, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterMapEffect: {
-    <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>): Fx<R | R2, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>): Fx<B, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterEffect: {
-    <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
+    <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const tapEffect: {
-    <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, unknown>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, unknown>): Fx<R | R2, E | E2, A>;
+    <A, E2, R2>(f: (a: A) => Effect.Effect<unknown, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<unknown, E2, R2>): Fx<A, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const tap: {
-    <A>(f: (a: A) => unknown): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, f: (a: A) => unknown): Fx<R, E, A>;
+    <A>(f: (a: A) => unknown): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, f: (a: A) => unknown): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const loop: {
-    <B, A, C>(seed: B, f: (acc: B, a: A) => readonly [C, B]): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, C>;
-    <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => readonly [C, B]): Fx<R, E, C>;
+    <B, A, C>(seed: B, f: (acc: B, a: A) => readonly [C, B]): <E, R>(fx: Fx<A, E, R>) => Fx<C, E, R>;
+    <A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => readonly [C, B]): Fx<C, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterMapLoop: {
-    <B, A, C>(seed: B, f: (acc: B, a: A) => readonly [Option.Option<C>, B]): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, C>;
-    <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => readonly [Option.Option<C>, B]): Fx<R, E, C>;
+    <B, A, C>(seed: B, f: (acc: B, a: A) => readonly [Option.Option<C>, B]): <E, R>(fx: Fx<A, E, R>) => Fx<C, E, R>;
+    <A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => readonly [Option.Option<C>, B]): Fx<C, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const loopEffect: {
-    <R2, E2, B, A, C>(seed: B, f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, C>;
-    <R, E, A, R2, E2, B, C>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [C, B]>): Fx<R | R2, E | E2, C>;
+    <B, E2, R2, A, C>(seed: B, f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<C, E | E2, R | R2>;
+    <A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E2, R2>): Fx<C, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterMapLoopEffect: {
-    <R2, E2, B, A, C>(seed: B, f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, C>;
-    <R, E, A, R2, E2, B, C>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>): Fx<R | R2, E | E2, C>;
+    <B, E2, R2, A, C>(seed: B, f: (acc: B, a: A) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<C, E | E2, R | R2>;
+    <A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>): Fx<C, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const observe: {
-    <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R | R2, E | E2, void>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Effect.Effect<R | R2, E | E2, void>;
+    <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Effect.Effect<void, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>): Effect.Effect<void, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
-export declare const drain: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, void>;
+export declare const drain: <A, E, R>(fx: Fx<A, E, R>) => Effect.Effect<void, E, R>;
 /**
  * @since 1.20.0
  */
 export declare const reduce: {
-    <A, B>(seed: B, f: (acc: B, a: A) => B): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, B>;
-    <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => B): Effect.Effect<R, E, B>;
+    <A, B>(seed: B, f: (acc: B, a: A) => B): <E, R>(fx: Fx<A, E, R>) => Effect.Effect<B, E, R>;
+    <A, E, R, B>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => B): Effect.Effect<B, E, R>;
 };
 /**
  * @since 1.20.0
  */
-export declare const toReadonlyArray: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>;
+export declare const toReadonlyArray: <A, E, R>(fx: Fx<A, E, R>) => Effect.Effect<ReadonlyArray<A>, E, R>;
 /**
  * @since 1.20.0
  */
 export declare const slice: {
-    (drop: number, take: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, drop: number, take: number): Fx<R, E, A>;
+    (drop: number, take: number): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, drop: number, take: number): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const take: {
-    (n: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A>;
+    (n: number): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const drop: {
-    (n: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A>;
+    (n: number): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
-export declare const skipRepeats: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+export declare const skipRepeats: <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
 /**
  * @since 1.20.0
  */
 export declare const skipRepeatsWith: {
-    <A>(eq: Equivalence.Equivalence<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, eq: Equivalence.Equivalence<A>): Fx<R, E, A>;
+    <A>(eq: Equivalence.Equivalence<A>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, eq: Equivalence.Equivalence<A>): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
-export declare const empty: Fx<never, never, never>;
+export declare const empty: Fx<never>;
 /**
  * @since 1.20.0
  */
-export declare const never: Fx<never, never, never>;
+export declare const never: Fx<never>;
 /**
  * @since 1.20.0
  */
 export declare const padWith: {
-    <B, C>(start: Iterable<B>, end: Iterable<C>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B | C>;
-    <R, E, A, B, C>(fx: Fx<R, E, A>, start: Iterable<B>, end: Iterable<C>): Fx<R, E, A | B | C>;
+    <B, C>(start: Iterable<B>, end: Iterable<C>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B | C, E, R>;
+    <A, E, R, B, C>(fx: Fx<A, E, R>, start: Iterable<B>, end: Iterable<C>): Fx<A | B | C, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const prependAll: {
-    <B>(start: Iterable<B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B>;
-    <R, E, A, B>(fx: Fx<R, E, A>, start: Iterable<B>): Fx<R, E, A | B>;
+    <B>(start: Iterable<B>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E, R>;
+    <A, E, R, B>(fx: Fx<A, E, R>, start: Iterable<B>): Fx<A | B, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const appendAll: {
-    <C>(end: Iterable<C>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | C>;
-    <R, E, A, C>(fx: Fx<R, E, A>, end: Iterable<C>): Fx<R, E, A | C>;
+    <C>(end: Iterable<C>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | C, E, R>;
+    <A, E, R, C>(fx: Fx<A, E, R>, end: Iterable<C>): Fx<A | C, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const prepend: {
-    <B>(start: B): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B>;
-    <R, E, A, B>(fx: Fx<R, E, A>, start: B): Fx<R, E, A | B>;
+    <B>(start: B): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E, R>;
+    <A, E, R, B>(fx: Fx<A, E, R>, start: B): Fx<A | B, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const append: {
-    <C>(end: C): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | C>;
-    <R, E, A, C>(fx: Fx<R, E, A>, end: C): Fx<R, E, A | C>;
+    <C>(end: C): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | C, E, R>;
+    <A, E, R, C>(fx: Fx<A, E, R>, end: C): Fx<A | C, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const scan: {
-    <B, A>(seed: B, f: (b: B, a: A) => B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>;
-    <R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (b: B, a: A) => B): Fx<R, E, B>;
+    <B, A>(seed: B, f: (b: B, a: A) => B): <E, R>(fx: Fx<A, E, R>) => Fx<B, E, R>;
+    <A, E, R, B>(fx: Fx<A, E, R>, seed: B, f: (b: B, a: A) => B): Fx<B, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const flatMapWithStrategy: {
-    <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, strategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, strategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Fx<B, E2, R2>, strategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, strategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const flatMap: {
-    <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<B, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const flatMapEffect: {
-    <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<B, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const switchMap: {
-    <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<B, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const switchMapEffect: {
-    <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<B, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const exhaustMap: {
-    <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<B, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const exhaustMapEffect: {
-    <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<B, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const exhaustMapLatest: {
-    <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<B, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const exhaustMapLatestEffect: {
-    <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<B, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const flatMapConcurrently: {
-    <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Fx<B, E2, R2>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<B, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const flatMapConcurrentlyEffect: {
-    <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Effect.Effect<B, E2, R2>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<B, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const concatMap: {
-    <A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, E>(fx: Fx<R, E, A>) => Fx<Scope.Scope | R | R2, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<Scope.Scope | R | R2, E | E2, B>;
+    <A, B, E2, R2>(f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, Scope.Scope | R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<B, E | E2, Scope.Scope | R | R2>;
 };
 /**
  * @since 1.20.0
  */
-export declare const fromFxEffect: <R, E, R2, E2, B>(effect: Effect.Effect<R, E, Fx<R2, E2, B>>) => Fx<R | R2, E | E2, B>;
+export declare const fromFxEffect: <B, E, R, E2, R2>(effect: Effect.Effect<Fx<B, E2, R2>, E, R>) => Fx<B, E | E2, R | R2>;
 /**
  * @since 1.20.0
  */
 export declare const continueWith: {
-    <R2, E2, B>(f: () => Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: () => Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>;
+    <B, E2, R2>(f: () => Fx<B, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: () => Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const orElseCause: {
-    <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>): Fx<R | R2, E2, A | B>;
+    <E, B, E2, R2>(f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>): Fx<A | B, E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const orElse: {
-    <E, R2, E2, B>(f: (error: E) => Fx<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (error: E) => Fx<R2, E2, B>): Fx<R | R2, E2, A | B>;
+    <E, B, E2, R2>(f: (error: E) => Fx<B, E2, R2>): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (error: E) => Fx<B, E2, R2>): Fx<A | B, E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
-export declare const suspend: <R, E, A>(f: () => Fx<R, E, A>) => Fx<R, E, A>;
+export declare const suspend: <A, E, R>(f: () => Fx<A, E, R>) => Fx<A, E, R>;
 /**
  * @since 1.20.0
  */
 export declare const mergeWithStrategy: {
-    (strategy: MergeStrategy): <FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
-    <const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX, stategy: MergeStrategy): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
+    (strategy: MergeStrategy): <FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
+    <const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX, stategy: MergeStrategy): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
 };
 /**
  * @since 1.20.0
  */
 export declare const merge: {
-    <R2, E2, B>(other: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, other: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>;
+    <B, E2, R2>(other: Fx<B, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, other: Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
-export declare const mergeAll: <FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
+export declare const mergeAll: <FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
 /**
  * @since 1.20.0
  */
-export declare const mergeOrdered: <FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
+export declare const mergeOrdered: <FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
 /**
  * @since 1.20.0
  */
-export declare const mergeOrderedConcurrently: <FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX, concurrency: number) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
+export declare const mergeOrderedConcurrently: <FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX, concurrency: number) => Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
 /**
  * @since 1.20.0
  */
-export declare const mergeSwitch: <FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
+export declare const mergeSwitch: <FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
 /**
  * @since 1.20.0
  */
 export declare const takeWhile: {
-    <A, B extends A>(f: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>;
-    <A>(f: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A, B extends A>(fx: Fx<R, E, A>, f: Predicate.Refinement<A, B>): Fx<R, E, B>;
-    <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>;
+    <A, B extends A>(f: Predicate.Refinement<A, B>): <E, R>(fx: Fx<A, E, R>) => Fx<B, E, R>;
+    <A>(f: Predicate.Predicate<A>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R, B extends A>(fx: Fx<A, E, R>, f: Predicate.Refinement<A, B>): Fx<B, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const takeUntil: {
-    <A, B extends A>(f: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, Exclude<A, B>>;
-    <A>(f: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A, B extends A>(fx: Fx<R, E, A>, f: Predicate.Refinement<A, B>): Fx<R, E, Exclude<A, B>>;
-    <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>;
+    <A, B extends A>(f: Predicate.Refinement<A, B>): <E, R>(fx: Fx<A, E, R>) => Fx<Exclude<A, B>, E, R>;
+    <A>(f: Predicate.Predicate<A>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R, B extends A>(fx: Fx<A, E, R>, f: Predicate.Refinement<A, B>): Fx<Exclude<A, B>, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const dropWhile: {
-    <A, B extends A>(f: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, Exclude<A, B>>;
-    <A>(f: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A, B extends A>(fx: Fx<R, E, A>, f: Predicate.Refinement<A, B>): Fx<R, E, Exclude<A, B>>;
-    <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>;
+    <A, B extends A>(f: Predicate.Refinement<A, B>): <E, R>(fx: Fx<A, E, R>) => Fx<Exclude<A, B>, E, R>;
+    <A>(f: Predicate.Predicate<A>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R, B extends A>(fx: Fx<A, E, R>, f: Predicate.Refinement<A, B>): Fx<Exclude<A, B>, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const dropUntil: {
-    <A, B extends A>(f: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A | B>;
-    <A>(f: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A, B extends A>(fx: Fx<R, E, A>, f: Predicate.Refinement<A, B>): Fx<R, E, A | B>;
-    <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>;
+    <A, B extends A>(f: Predicate.Refinement<A, B>): <E, R>(fx: Fx<A, E, R>) => Fx<A | B, E, R>;
+    <A>(f: Predicate.Predicate<A>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R, B extends A>(fx: Fx<A, E, R>, f: Predicate.Refinement<A, B>): Fx<A | B, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const dropAfter: {
-    <A, B extends A>(f: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, Exclude<A, B>>;
-    <A>(f: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A, B extends A>(fx: Fx<R, E, A>, f: Predicate.Refinement<A, B>): Fx<R, E, Exclude<A, B>>;
-    <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>;
+    <A, B extends A>(f: Predicate.Refinement<A, B>): <E, R>(fx: Fx<A, E, R>) => Fx<Exclude<A, B>, E, R>;
+    <A>(f: Predicate.Predicate<A>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R, B extends A>(fx: Fx<A, E, R>, f: Predicate.Refinement<A, B>): Fx<Exclude<A, B>, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const takeWhileEffect: {
-    <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
+    <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const takeUntiEffect: {
-    <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
+    <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const dropWhileEffect: {
-    <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
+    <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const dropUntilEffect: {
-    <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
+    <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const dropAfterEffect: {
-    <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
+    <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const during: {
-    <R2, E2, A, R3, E3, B>(window: Fx<R2, E2, Fx<R3, E3, B>>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, A>;
-    <R, E, A, R2, E2, R3, E3, B>(fx: Fx<R, E, A>, window: Fx<R2, E2, Fx<R3, E3, B>>): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, A>;
+    <E2, R2, A, R3, E3, B>(window: Fx<Fx<B, E3, R3>, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, E2, R2, R3, E3, B>(fx: Fx<A, E, R>, window: Fx<Fx<B, E3, R3>, E2, R2>): Fx<A, E | E2 | E3, R | R2 | R3 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const since: {
-    <R2, E2, B>(window: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, A>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, window: Fx<R2, E2, B>): Fx<R | R2 | Scope.Scope, E | E2, A>;
+    <B, E2, R2>(window: Fx<B, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, window: Fx<B, E2, R2>): Fx<A, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const until: {
-    <R2, E2, B>(window: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E | E2, A>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, window: Fx<R2, E2, B>): Fx<R | R2 | Scope.Scope, E | E2, A>;
+    <B, E2, R2>(window: Fx<B, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, window: Fx<B, E2, R2>): Fx<A, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const middleware: {
-    <R, R3, E, A>(effect: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R3, never, unknown>, sink?: ((sink: Sink.Sink<never, E, A>) => Sink.Sink<R, E, A>) | undefined): <E, A>(fx: Fx<R, E, A>) => Fx<R3, E, A>;
-    <R, E, A, R3>(fx: Fx<R, E, A>, effect: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R3, never, unknown>, sink?: ((sink: Sink.Sink<never, E, A>) => Sink.Sink<R, E, A>) | undefined): Fx<R3, E, A>;
+    <R, A, E, R3>(effect: (effect: Effect.Effect<unknown, never, R>) => Effect.Effect<unknown, never, R3>, sink?: ((sink: Sink.Sink<A, E>) => Sink.Sink<A, E, R>) | undefined): <A, E>(fx: Fx<A, E, R>) => Fx<A, E, R3>;
+    <A, E, R, R3>(fx: Fx<A, E, R>, effect: (effect: Effect.Effect<unknown, never, R>) => Effect.Effect<unknown, never, R3>, sink?: ((sink: Sink.Sink<A, E>) => Sink.Sink<A, E, R>) | undefined): Fx<A, E, R3>;
 };
 /**
  * @since 1.20.0
  */
 export declare const onExit: {
-    <R2>(f: (exit: Exit.Exit<never, unknown>) => Effect.Effect<R2, never, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2, E, A>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, f: (exit: Exit.Exit<never, unknown>) => Effect.Effect<R2, never, unknown>): Fx<R | R2, E, A>;
+    <R2>(f: (exit: Exit.Exit<unknown>) => Effect.Effect<unknown, never, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R2>;
+    <A, E, R, R2>(fx: Fx<A, E, R>, f: (exit: Exit.Exit<unknown>) => Effect.Effect<unknown, never, R2>): Fx<A, E, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const onInterrupt: {
-    <R2>(f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<R2, never, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2, E, A>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<R2, never, unknown>): Fx<R | R2, E, A>;
+    <R2>(f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<unknown, never, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R2>;
+    <A, E, R, R2>(fx: Fx<A, E, R>, f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<unknown, never, R2>): Fx<A, E, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const onError: {
-    <R2>(f: (cause: Cause.Cause<never>) => Effect.Effect<R2, never, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2, E, A>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<never>) => Effect.Effect<R2, never, unknown>): Fx<R | R2, E, A>;
+    <R2>(f: (cause: Cause.Cause<never>) => Effect.Effect<unknown, never, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R2>;
+    <A, E, R, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<never>) => Effect.Effect<unknown, never, R2>): Fx<A, E, R | R2>;
 };
 /**
  * @since 1.20.0
  */
-export declare const scoped: <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, Scope.Scope>, E, A>;
+export declare const scoped: <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Exclude<R, Scope.Scope>>;
 /**
  * @since 1.20.0
  */
 export declare const annotateLogs: {
-    (key: string | Record<string, unknown>, value?: unknown): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, key: string | Record<string, unknown>, value?: unknown): Fx<R, E, A>;
+    (key: string | Record<string, unknown>, value?: unknown): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, key: string | Record<string, unknown>, value?: unknown): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const annotateSpans: {
-    (key: string | Record<string, unknown>, value?: unknown): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, key: string | Record<string, unknown>, value?: unknown): Fx<R, E, A>;
+    (key: string | Record<string, unknown>, value?: unknown): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, key: string | Record<string, unknown>, value?: unknown): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
-export declare const interruptible: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+export declare const interruptible: <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
 /**
  * @since 1.20.0
  */
-export declare const uninterruptible: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+export declare const uninterruptible: <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
 /**
  * @since 1.20.0
  */
 export declare const locally: {
-    <A>(self: FiberRef.FiberRef<A>, value: A): <R, E, B>(fx: Fx<R, E, B>) => Fx<R, E, B>;
-    <R, E, B, A>(use: Fx<R, E, B>, self: FiberRef.FiberRef<A>, value: A): Fx<R, E, B>;
+    <A>(self: FiberRef.FiberRef<A>, value: A): <B, E, R>(fx: Fx<B, E, R>) => Fx<B, E, R>;
+    <B, E, R, A>(use: Fx<B, E, R>, self: FiberRef.FiberRef<A>, value: A): Fx<B, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const locallyWith: {
-    <A>(self: FiberRef.FiberRef<A>, f: (a: A) => A): <R, E, B>(fx: Fx<R, E, B>) => Fx<R, E, B>;
-    <R, E, B, A>(use: Fx<R, E, B>, self: FiberRef.FiberRef<A>, f: (a: A) => A): Fx<R, E, B>;
+    <A>(self: FiberRef.FiberRef<A>, f: (a: A) => A): <B, E, R>(fx: Fx<B, E, R>) => Fx<B, E, R>;
+    <B, E, R, A>(use: Fx<B, E, R>, self: FiberRef.FiberRef<A>, f: (a: A) => A): Fx<B, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const withTracerTiming: {
-    (enabled: boolean): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, enabled: boolean): Fx<R, E, A>;
+    (enabled: boolean): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, enabled: boolean): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const withConcurrency: {
-    (concurrency: number | "unbounded"): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, concurrency: number | "unbounded"): Fx<R, E, A>;
+    (concurrency: number | "unbounded"): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, concurrency: number | "unbounded"): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const withConfigProvider: {
-    (configProvider: ConfigProvider.ConfigProvider): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, configProvider: ConfigProvider.ConfigProvider): Fx<R, E, A>;
+    (configProvider: ConfigProvider.ConfigProvider): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, configProvider: ConfigProvider.ConfigProvider): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const withLogSpan: {
-    (span: string): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, span: string): Fx<R, E, A>;
+    (span: string): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, span: string): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const withMaxOpsBeforeYield: {
-    (maxOps: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, maxOps: number): Fx<R, E, A>;
+    (maxOps: number): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, maxOps: number): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const withParentSpan: {
-    (parentSpan: Tracer.ParentSpan): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, parentSpan: Tracer.ParentSpan): Fx<R, E, A>;
+    (parentSpan: Tracer.ParentSpan): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, parentSpan: Tracer.ParentSpan): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const withRequestBatching: {
-    (requestBatching: boolean): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, requestBatching: boolean): Fx<R, E, A>;
+    (requestBatching: boolean): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, requestBatching: boolean): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const withRequestCache: {
-    (cache: Request.Cache): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, cache: Request.Cache): Fx<R, E, A>;
+    (cache: Request.Cache): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, cache: Request.Cache): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const withRequestCaching: {
-    (requestCaching: boolean): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, requestCaching: boolean): Fx<R, E, A>;
+    (requestCaching: boolean): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, requestCaching: boolean): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const withTracer: {
-    (tracer: Tracer.Tracer): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, tracer: Tracer.Tracer): Fx<R, E, A>;
+    (tracer: Tracer.Tracer): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, tracer: Tracer.Tracer): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const acquireUseRelease: {
-    <A, R2, E2, B, R3, E3, C>(use: (a: A) => Fx<R2, E2, B>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, C>): <R, E>(acquire: Effect.Effect<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, B>;
-    <R, E, A, R2, E2, B, R3, E3, C>(acquire: Effect.Effect<R, E, A>, use: (a: A) => Fx<R2, E2, B>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, C>): Fx<R | R2 | R3, E | E2 | E3, B>;
+    <A, B, E2, R2, C, E3, R3>(use: (a: A) => Fx<B, E2, R2>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<C, E3, R3>): <E, R>(acquire: Effect.Effect<A, E, R>) => Fx<B, E | E2 | E3, R | R2 | R3>;
+    <A, E, R, B, E2, R2, C, E3, R3>(acquire: Effect.Effect<A, E, R>, use: (a: A) => Fx<B, E2, R2>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<C, E3, R3>): Fx<B, E | E2 | E3, R | R2 | R3>;
 };
 /**
  * @since 1.20.0
@@ -870,503 +870,503 @@ export declare const withSpan: {
         readonly parent?: Tracer.ParentSpan;
         readonly root?: boolean;
         readonly context?: Ctx.Context<never>;
-    }): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(self: Fx<R, E, A>, name: string, options?: {
+    }): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(self: Fx<A, E, R>, name: string, options?: {
         readonly attributes?: Record<string, unknown>;
         readonly links?: ReadonlyArray<Tracer.SpanLink>;
         readonly parent?: Tracer.ParentSpan;
         readonly root?: boolean;
         readonly context?: Ctx.Context<never>;
-    }): Fx<R, E, A>;
+    }): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const provideContext: {
-    <R2>(context: Ctx.Context<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, context: Ctx.Context<R2>): Fx<Exclude<R, R2>, E, A>;
+    <R2>(context: Ctx.Context<R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Exclude<R, R2>>;
+    <A, E, R, R2>(fx: Fx<A, E, R>, context: Ctx.Context<R2>): Fx<A, E, Exclude<R, R2>>;
 };
 /**
  * @since 1.20.0
  */
 export declare const provideLayer: {
-    <R2, E2, S>(layer: Layer.Layer<R2, E2, S>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, S>, E | E2, A>;
-    <R, E, A, R2, E2, S>(fx: Fx<R, E, A>, layer: Layer.Layer<R2, E2, S>): Fx<R2 | Exclude<R, S>, E | E2, A>;
+    <E2, R2, S>(layer: Layer.Layer<S, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R2 | Exclude<R, S>>;
+    <A, E, R, E2, R2, S>(fx: Fx<A, E, R>, layer: Layer.Layer<S, E2, R2>): Fx<A, E | E2, R2 | Exclude<R, S>>;
 };
 /**
  * @since 1.20.0
  */
 export declare const provideRuntime: {
-    <R2>(runtime: Runtime.Runtime<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, runtime: Runtime.Runtime<R2>): Fx<Exclude<R, R2>, E, A>;
+    <R2>(runtime: Runtime.Runtime<R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Exclude<R, R2>>;
+    <A, E, R, R2>(fx: Fx<A, E, R>, runtime: Runtime.Runtime<R2>): Fx<A, E, Exclude<R, R2>>;
 };
 /**
  * @since 1.20.0
  */
 export declare const provideService: {
-    <I, S>(service: Ctx.Tag<I, S>, instance: S): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, I>, E, A>;
-    <R, E, A, I, S>(fx: Fx<R, E, A>, service: Ctx.Tag<I, S>, instance: S): Fx<Exclude<R, I>, E, A>;
+    <I, S>(service: Ctx.Tag<I, S>, instance: S): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Exclude<R, I>>;
+    <A, E, R, I, S>(fx: Fx<A, E, R>, service: Ctx.Tag<I, S>, instance: S): Fx<A, E, Exclude<R, I>>;
 };
 /**
  * @since 1.20.0
  */
 export declare const provideServiceEffect: {
-    <I, S, R2, E2>(service: Ctx.Tag<I, S>, instance: Effect.Effect<R2, E2, S>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, I>, E | E2, A>;
-    <R, E, A, I, S, R2, E2>(fx: Fx<R, E, A>, service: Ctx.Tag<I, S>, instance: Effect.Effect<R2, E2, S>): Fx<R2 | Exclude<R, I>, E | E2, A>;
+    <I, S, E2, R2>(service: Ctx.Tag<I, S>, instance: Effect.Effect<S, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R2 | Exclude<R, I>>;
+    <A, E, R, I, S, E2, R2>(fx: Fx<A, E, R>, service: Ctx.Tag<I, S>, instance: Effect.Effect<S, E2, R2>): Fx<A, E | E2, R2 | Exclude<R, I>>;
 };
 /**
  * @since 1.20.0
  */
 export declare const provide: {
-    <R2>(context: Ctx.Context<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>;
-    <R2>(runtime: Runtime.Runtime<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>;
-    <R2, E2, S>(layer: Layer.Layer<R2, E2, S>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, S>, E | E2, A>;
-    <R2 = never, E2 = never, S = never>(provide: Layer.Layer<R2, E2, S> | Ctx.Context<S> | Runtime.Runtime<S>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, S>, E | E2, A>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, context: Ctx.Context<R2>): Fx<Exclude<R, R2>, E, A>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, runtime: Runtime.Runtime<R2>): Fx<Exclude<R, R2>, E, A>;
-    <R, E, A, R2, E2, S>(fx: Fx<R, E, A>, layer: Layer.Layer<R2, E2, S>): Fx<R2 | Exclude<R, S>, E | E2, A>;
-    <R, E, A, R2 = never, E2 = never, S = never>(fx: Fx<R, E, A>, provide: Layer.Layer<R2, E2, S> | Ctx.Context<S> | Runtime.Runtime<S>): Fx<R2 | Exclude<R, S>, E | E2, A>;
+    <R2>(context: Ctx.Context<R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Exclude<R, R2>>;
+    <R2>(runtime: Runtime.Runtime<R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Exclude<R, R2>>;
+    <S, E2, R2>(layer: Layer.Layer<S, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R2 | Exclude<R, S>>;
+    <S, E2 = never, R2 = never>(provide: Layer.Layer<S, E2, R2> | Ctx.Context<S> | Runtime.Runtime<S>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R2 | Exclude<R, S>>;
+    <A, E, R, R2>(fx: Fx<A, E, R>, context: Ctx.Context<R2>): Fx<A, E, Exclude<R, R2>>;
+    <A, E, R, R2>(fx: Fx<A, E, R>, runtime: Runtime.Runtime<R2>): Fx<A, E, Exclude<R, R2>>;
+    <A, E, R, S, E2, R2>(fx: Fx<A, E, R>, layer: Layer.Layer<S, E2, R2>): Fx<A, E | E2, R2 | Exclude<R, S>>;
+    <A, E, R, S, E2 = never, R2 = never>(fx: Fx<A, E, R>, provide: Layer.Layer<S, E2, R2> | Ctx.Context<S> | Runtime.Runtime<S>): Fx<A, E | E2, R2 | Exclude<R, S>>;
 };
 /**
  * @since 1.20.0
  */
 export declare const share: {
-    <R2, E2, A>(subject: Subject.Subject<R2, E2, A>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E, A>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, subject: Subject.Subject<R2, E, A>): Fx<R | R2 | Scope.Scope, E, A>;
+    <E2, R2, A>(subject: Subject.Subject<A, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R | R2 | Scope.Scope>;
+    <A, E, R, R2>(fx: Fx<A, E, R>, subject: Subject.Subject<A, E, R2>): Fx<A, E, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
-export declare const multicast: <R, E, A>(fx: Fx<R, E, A>) => Fx<Scope.Scope | R, E, A>;
+export declare const multicast: <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Scope.Scope | R>;
 /**
  * @since 1.20.0
  */
-export declare const hold: <R, E, A>(fx: Fx<R, E, A>) => Fx<Scope.Scope | R, E, A>;
+export declare const hold: <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Scope.Scope | R>;
 /**
  * @since 1.20.0
  */
 export declare const replay: {
-    (capacity: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<Scope.Scope | R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, capacity: number): Fx<Scope.Scope | R, E, A>;
+    (capacity: number): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Scope.Scope | R>;
+    <A, E, R>(fx: Fx<A, E, R>, capacity: number): Fx<A, E, Scope.Scope | R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const mapCause: {
-    <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>;
-    <R, E, A, E2>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Fx<R, E2, A>;
+    <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2, R>;
+    <A, E, R, E2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Fx<A, E2, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const mapError: {
-    <E, E2>(f: (e: E) => E2): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>;
-    <R, E, A, E2>(fx: Fx<R, E, A>, f: (e: E) => E2): Fx<R, E2, A>;
+    <E, E2>(f: (e: E) => E2): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2, R>;
+    <A, E, R, E2>(fx: Fx<A, E, R>, f: (e: E) => E2): Fx<A, E2, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const mapBoth: {
-    <E, E2, A, B>(f: (e: E) => E2, g: (a: A) => B): <R>(fx: Fx<R, E, A>) => Fx<R, E2, B>;
-    <R, E, A, B, C>(fx: Fx<R, E, A>, f: (e: E) => B, g: (a: A) => C): Fx<R, B, C>;
+    <E, E2, A, B>(f: (e: E) => E2, g: (a: A) => B): <R>(fx: Fx<A, E, R>) => Fx<B, E2, R>;
+    <A, E, R, B, C>(fx: Fx<A, E, R>, f: (e: E) => B, g: (a: A) => C): Fx<C, B, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterCause: {
-    <E>(f: (cause: Cause.Cause<E>) => boolean): <R, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => boolean): Fx<R, E, A>;
+    <E>(f: (cause: Cause.Cause<E>) => boolean): <R, A>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => boolean): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterError: {
-    <E>(f: (e: E) => boolean): <R, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, f: (e: E) => boolean): Fx<R, E, A>;
+    <E>(f: (e: E) => boolean): <R, A>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, f: (e: E) => boolean): Fx<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterMapCause: {
-    <E, E2>(f: (cause: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>;
-    <R, E, A, E2>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): Fx<R, E2, A>;
+    <E, E2>(f: (cause: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2, R>;
+    <A, E, R, E2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): Fx<A, E2, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterMapError: {
-    <E, E2>(f: (e: E) => Option.Option<E2>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>;
-    <R, E, A, E2>(fx: Fx<R, E, A>, f: (e: E) => Option.Option<E2>): Fx<R, E2, A>;
+    <E, E2>(f: (e: E) => Option.Option<E2>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2, R>;
+    <A, E, R, E2>(fx: Fx<A, E, R>, f: (e: E) => Option.Option<E2>): Fx<A, E2, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const mapCauseEffect: {
-    <R2, E2, E3>(f: (cause: Cause.Cause<E2>) => Effect.Effect<R2, E3, Cause.Cause<E3>>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | E3, A>;
-    <R, E, A, R2, E2, E3>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, Cause.Cause<E3>>): Fx<R | R2, E2 | E3, A>;
+    <E3, E2, R2>(f: (cause: Cause.Cause<E2>) => Effect.Effect<Cause.Cause<E3>, E3, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E2 | E3, R | R2>;
+    <A, E, R, E3, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Effect.Effect<Cause.Cause<E3>, E2, R2>): Fx<A, E2 | E3, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const mapErrorEffect: {
-    <R2, E2, E3>(f: (e: E2) => Effect.Effect<R2, E3, E3>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | E3, A>;
-    <R, E, A, R2, E2, E3>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, E3>): Fx<R | R2, E2 | E3, A>;
+    <E3, E2, R2>(f: (e: E2) => Effect.Effect<E3, E3, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E2 | E3, R | R2>;
+    <A, E, R, E3, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Effect.Effect<E3, E2, R2>): Fx<A, E2 | E3, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterCauseEffect: {
-    <E, R2, E2>(f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, boolean>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E2, A>;
+    <E, E2, R2>(f: (cause: Cause.Cause<E>) => Effect.Effect<boolean, E2, R2>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2, R | R2>;
+    <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Effect.Effect<boolean, E2, R2>): Fx<A, E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterErrorEffect: {
-    <E, R2, E2>(f: (e: E) => Effect.Effect<R2, E2, boolean>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E2, A>;
+    <E, E2, R2>(f: (e: E) => Effect.Effect<boolean, E2, R2>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2, R | R2>;
+    <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Effect.Effect<boolean, E2, R2>): Fx<A, E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterMapCauseEffect: {
-    <R2, E2, E3>(f: (cause: Cause.Cause<E2>) => Effect.Effect<R2, E2, Option.Option<Cause.Cause<E3>>>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | E3, A>;
-    <R, E, A, R2, E2, E3>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, Option.Option<Cause.Cause<E3>>>): Fx<R | R2, E2 | E3, A>;
+    <E3, E2, R2>(f: (cause: Cause.Cause<E2>) => Effect.Effect<Option.Option<Cause.Cause<E3>>, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E2 | E3, R | R2>;
+    <A, E, R, E3, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Effect.Effect<Option.Option<Cause.Cause<E3>>, E2, R2>): Fx<A, E2 | E3, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterMapErrorEffect: {
-    <E, R2, E2, E3>(f: (e: E) => Effect.Effect<R2, E2, Option.Option<E3>>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | E3, A>;
-    <R, E, A, R2, E2, E3>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, Option.Option<E3>>): Fx<R | R2, E2 | E3, A>;
+    <E, E3, E2, R2>(f: (e: E) => Effect.Effect<Option.Option<E3>, E2, R2>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2 | E3, R | R2>;
+    <A, E, R, E3, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Effect.Effect<Option.Option<E3>, E2, R2>): Fx<A, E2 | E3, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const loopCause: {
-    <B, E, C>(seed: B, f: (b: B, cause: Cause.Cause<E>) => readonly [Cause.Cause<C>, B]): <R, A>(fx: Fx<R, E, A>) => Fx<R, C, A>;
-    <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (b: B, cause: Cause.Cause<E>) => readonly [Cause.Cause<C>, B]): Fx<R, C, A>;
+    <B, E, C>(seed: B, f: (b: B, cause: Cause.Cause<E>) => readonly [Cause.Cause<C>, B]): <R, A>(fx: Fx<A, E, R>) => Fx<A, C, R>;
+    <A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, cause: Cause.Cause<E>) => readonly [Cause.Cause<C>, B]): Fx<A, C, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const loopError: {
-    <B, E, C>(seed: B, f: (b: B, e: E) => readonly [C, B]): <R, A>(fx: Fx<R, E, A>) => Fx<R, C, A>;
-    <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (b: B, e: E) => readonly [C, B]): Fx<R, C, A>;
+    <B, E, C>(seed: B, f: (b: B, e: E) => readonly [C, B]): <R, A>(fx: Fx<A, E, R>) => Fx<A, C, R>;
+    <A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, e: E) => readonly [C, B]): Fx<A, C, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const loopCauseEffect: {
-    <B, E, R2, E2, C>(seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Cause.Cause<C>, B]>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | C, A>;
-    <R, E, A, R2, E2, B, C>(fx: Fx<R, E, A>, seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Cause.Cause<C>, B]>): Fx<R | R2, E2 | C, A>;
+    <B, E, E2, R2, C>(seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<readonly [Cause.Cause<C>, B], E2, R2>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2 | C, R | R2>;
+    <A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<readonly [Cause.Cause<C>, B], E2, R2>): Fx<A, E2 | C, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const loopErrorEffect: {
-    <B, E, R2, E2, C>(seed: B, f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [C, B]>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | C, A>;
-    <R, E, A, R2, E2, B, C>(fx: Fx<R, E, A>, seed: B, f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [C, B]>): Fx<R | R2, E2 | C, A>;
+    <B, E, E2, R2, C>(seed: B, f: (b: B, e: E) => Effect.Effect<readonly [C, B], E2, R2>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2 | C, R | R2>;
+    <A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, e: E) => Effect.Effect<readonly [C, B], E2, R2>): Fx<A, E2 | C, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterMapLoopCause: {
-    <B, E, R2, E2, C>(seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Option.Option<Cause.Cause<C>>, B]>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | C, A>;
-    <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (b: B, cause: Cause.Cause<E>) => readonly [Option.Option<Cause.Cause<C>>, B]): Fx<R, C, A>;
+    <B, E, E2, R2, C>(seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<readonly [Option.Option<Cause.Cause<C>>, B], E2, R2>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2 | C, R | R2>;
+    <A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, cause: Cause.Cause<E>) => readonly [Option.Option<Cause.Cause<C>>, B]): Fx<A, C, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterMapLoopError: {
-    <B, E, R2, E2, C>(seed: B, f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | C, A>;
-    <R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (b: B, e: E) => readonly [Option.Option<C>, B]): Fx<R, C, A>;
+    <B, E, E2, R2, C>(seed: B, f: (b: B, e: E) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2 | C, R | R2>;
+    <A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, e: E) => readonly [Option.Option<C>, B]): Fx<A, C, R>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterMapLoopCauseEffect: {
-    <B, E, R2, E2, C>(seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Option.Option<Cause.Cause<C>>, B]>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | C, A>;
-    <R, E, A, R2, E2, B, C>(fx: Fx<R, E, A>, seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<R2, E2, readonly [Option.Option<Cause.Cause<C>>, B]>): Fx<R | R2, E2 | C, A>;
+    <B, E, E2, R2, C>(seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<readonly [Option.Option<Cause.Cause<C>>, B], E2, R2>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2 | C, R | R2>;
+    <A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<readonly [Option.Option<Cause.Cause<C>>, B], E2, R2>): Fx<A, E2 | C, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const filterMapLoopErrorEffect: {
-    <B, E, R2, E2, C>(seed: B, f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | C, A>;
-    <R, E, A, R2, E2, B, C>(fx: Fx<R, E, A>, seed: B, f: (b: B, e: E) => Effect.Effect<R2, E2, readonly [Option.Option<C>, B]>): Fx<R | R2, E2 | C, A>;
+    <B, E, E2, R2, C>(seed: B, f: (b: B, e: E) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2 | C, R | R2>;
+    <A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, e: E) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>): Fx<A, E2 | C, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const flatMapCauseWithStrategy: {
-    <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, flattenStrategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, flattenStrategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E2, A | B>;
+    <E, B, E2, R2>(f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, flattenStrategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, flattenStrategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const flatMapErrorWithStrategy: {
-    <E, R2, E2, B>(f: (e: E) => Fx<R2, E2, B>, flattenStrategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>, flattenStrategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E2, A | B>;
+    <E, B, E2, R2>(f: (e: E) => Fx<B, E2, R2>, flattenStrategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Fx<B, E2, R2>, flattenStrategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const switchMapCause: {
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E2, A | B>;
-    <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<A | B, E2, R | R2 | Scope.Scope>;
+    <E, B, E2, R2>(f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const switchMapError: {
-    <E, R2, E2, B>(f: (e: E) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E2, A | B>;
+    <E, B, E2, R2>(f: (e: E) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<A | B, E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const flatMapCause: {
-    <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E2, A | B>;
+    <E, B, E2, R2>(f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<A | B, E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const flatMapError: {
-    <E, R2, E2, B>(f: (e: E) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E2, A | B>;
+    <E, B, E2, R2>(f: (e: E) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<A | B, E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const flatMapCauseConcurrently: {
-    <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, concurrency: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, concurrency: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E2, A | B>;
+    <E, B, E2, R2>(f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, concurrency: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, concurrency: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<A | B, E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const flatMapErrorConcurrently: {
-    <E, R2, E2, B>(f: (e: E) => Fx<R2, E2, B>, concurrency: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>, concurrency: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E2, A | B>;
+    <E, B, E2, R2>(f: (e: E) => Fx<B, E2, R2>, concurrency: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Fx<B, E2, R2>, concurrency: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<A | B, E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const exhaustMapCause: {
-    <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E2, A | B>;
+    <E, B, E2, R2>(f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<A | B, E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const exhaustMapError: {
-    <E, R2, E2, B>(f: (e: E) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E2, A | B>;
+    <E, B, E2, R2>(f: (e: E) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<A | B, E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const exhaustMapLatestCause: {
-    <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E2, A | B>;
+    <E, B, E2, R2>(f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<A | B, E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const exhaustMapLatestError: {
-    <E, R2, E2, B>(f: (e: E) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2 | Scope.Scope, E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E2, A | B>;
+    <E, B, E2, R2>(f: (e: E) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<A | B, E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
-export type MatchCauseOptions<E, A, R2, E2, B, R3, E3, C> = {
-    readonly onFailure: (cause: Cause.Cause<E>) => Fx<R2, E2, B>;
-    readonly onSuccess: (a: A) => Fx<R3, E3, C>;
+export type MatchCauseOptions<E, A, B, E2, R2, C, E3, R3> = {
+    readonly onFailure: (cause: Cause.Cause<E>) => Fx<B, E2, R2>;
+    readonly onSuccess: (a: A) => Fx<C, E3, R3>;
     readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined;
 };
 /**
  * @since 1.20.0
  */
-export type MatchErrorOptions<E, A, R2, E2, B, R3, E3, C> = {
-    readonly onFailure: (e: E) => Fx<R2, E2, B>;
-    readonly onSuccess: (a: A) => Fx<R3, E3, C>;
+export type MatchErrorOptions<E, A, B, E2, R2, C, E3, R3> = {
+    readonly onFailure: (e: E) => Fx<B, E2, R2>;
+    readonly onSuccess: (a: A) => Fx<C, E3, R3>;
     readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined;
 };
 /**
  * @since 1.20.0
  */
 export declare const matchCauseWithStrategy: {
-    <E, A, R2, E2, B, R3, E3, C>(opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, flattenStrategy: FlattenStrategy, opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
+    <E, A, B, E2, R2, C, E3, R3>(opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, flattenStrategy: FlattenStrategy, opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const matchErrorWithStrategy: {
-    <E, A, R2, E2, B, R3, E3, C>({ executionStrategy, onFailure, onSuccess }: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, flattenStrategy: FlattenStrategy, { executionStrategy, onFailure, onSuccess }: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>;
+    <E, A, B, E2, R2, C, E3, R3>({ executionStrategy, onFailure, onSuccess }: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, flattenStrategy: FlattenStrategy, { executionStrategy, onFailure, onSuccess }: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
 };
 /**
  * @since 1.20.0
  */
 export declare const matchCause: {
-    <E, A, R2, E2, B, R3, E3, C>(opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>;
+    <E, A, B, E2, R2, C, E3, R3>(opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
 };
 /**
  * @since 1.20.0
  */
 export declare const matchError: {
-    <E, A, R2, E2, B, R3, E3, C>(opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, opts: core.MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
+    <E, A, B, E2, R2, C, E3, R3>(opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: core.MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const matchCauseConcurrently: {
-    <E, A, R2, E2, B, R3, E3, C>(concurrency: number, opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, concurrency: number, opts: core.MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
+    <E, A, B, E2, R2, C, E3, R3>(concurrency: number, opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, concurrency: number, opts: core.MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const matchErrorConcurrently: {
-    <E, A, R2, E2, B, R3, E3, C>(concurrency: number, opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, concurrency: number, opts: core.MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>;
+    <E, A, B, E2, R2, C, E3, R3>(concurrency: number, opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, concurrency: number, opts: core.MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
 };
 /**
  * @since 1.20.0
  */
 export declare const switchMatchCause: {
-    <E, A, R2, E2, B, R3, E3, C>(opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>;
+    <E, A, B, E2, R2, C, E3, R3>(opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
 };
 /**
  * @since 1.20.0
  */
 export declare const switchMatchError: {
-    <E, A, R2, E2, B, R3, E3, C>(opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, opts: core.MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
+    <E, A, B, E2, R2, C, E3, R3>(opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: core.MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const exhaustMatchCause: {
-    <E, A, R2, E2, B, R3, E3, C>(opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>;
+    <E, A, B, E2, R2, C, E3, R3>(opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
 };
 /**
  * @since 1.20.0
  */
 export declare const exhaustMatchError: {
-    <E, A, R2, E2, B, R3, E3, C>(opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, opts: core.MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
+    <E, A, B, E2, R2, C, E3, R3>(opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: core.MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const exhaustMatchLatestCause: {
-    <E, A, R2, E2, B, R3, E3, C>(opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>;
+    <E, A, B, E2, R2, C, E3, R3>(opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
 };
 /**
  * @since 1.20.0
  */
 export declare const exhaustMatchLatestError: {
-    <E, A, R2, E2, B, R3, E3, C>(opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, opts: core.MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): Fx<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
+    <E, A, B, E2, R2, C, E3, R3>(opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: core.MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
-export declare const exit: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Exit.Exit<E, A>>;
+export declare const exit: <A, E, R>(fx: Fx<A, E, R>) => Fx<Exit.Exit<A, E>, never, R>;
 /**
  * @since 1.20.0
  */
-export declare const either: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Either.Either<E, A>>;
+export declare const either: <A, E, R>(fx: Fx<A, E, R>) => Fx<Either.Either<E, A>, never, R>;
 /**
  * @since 1.20.0
  */
-export declare const tuple: <const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, {
+export declare const tuple: <const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<{
     readonly [K in keyof FX]: Fx.Success<FX[K]>;
-}>;
+}, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
 /**
  * @since 1.20.0
  */
-export declare const struct: <const FX extends Readonly<Record<string, Fx<any, any, any>>>>(fx: FX) => Fx<Fx.Context<FX[string]>, Fx.Error<FX[string]>, {
+export declare const struct: <const FX extends Readonly<Record<string, Fx<any, any, any>>>>(fx: FX) => Fx<{
     readonly [K in keyof FX]: Fx.Success<FX[K]>;
-}>;
+}, Fx.Error<FX[string]>, Fx.Context<FX[string]>>;
 /**
  * @since 1.20.0
  */
 export declare const all: {
-    <const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, {
+    <const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<{
         readonly [K in keyof FX]: Fx.Success<FX[K]>;
-    }>;
-    <const FX extends Readonly<Record<string, Fx<any, any, any>>>>(fx: FX): Fx<Fx.Context<FX[string]>, Fx.Error<FX[string]>, {
+    }, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
+    <const FX extends Readonly<Record<string, Fx<any, any, any>>>>(fx: FX): Fx<{
         readonly [K in keyof FX]: Fx.Success<FX[K]>;
-    }>;
+    }, Fx.Error<FX[string]>, Fx.Context<FX[string]>>;
 };
 /**
  * @since 1.20.0
  */
 export declare const toEnqueue: {
-    <R2 = never, A = never>(queue: Ctx.Enqueue<R2, A> | Queue.Enqueue<A>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R | R2, E, void>;
-    <R, E, A, R2 = never>(fx: Fx<R, E, A>, queue: Ctx.Enqueue<R2, A> | Queue.Enqueue<A>): Effect.Effect<R | R2, E, void>;
+    <R2 = never, A = never>(queue: Ctx.Enqueue<R2, A> | Queue.Enqueue<A>): <E, R>(fx: Fx<A, E, R>) => Effect.Effect<void, E, R | R2>;
+    <A, E, R, R2 = never>(fx: Fx<A, E, R>, queue: Ctx.Enqueue<R2, A> | Queue.Enqueue<A>): Effect.Effect<void, E, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const debounce: {
-    (delay: Duration.DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | Scope.Scope, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A>;
+    (delay: Duration.DurationInput): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R | Scope.Scope>;
+    <A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const throttle: {
-    (delay: Duration.DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | Scope.Scope, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A>;
+    (delay: Duration.DurationInput): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R | Scope.Scope>;
+    <A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const throttleLatest: {
-    (delay: Duration.DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | Scope.Scope, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A>;
+    (delay: Duration.DurationInput): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R | Scope.Scope>;
+    <A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
-export interface KeyedOptions<A, B, R2, E2, C> {
+export interface KeyedOptions<A, B, C, E2, R2> {
     readonly getKey: (a: A) => B;
-    readonly onValue: (ref: RefSubject<never, never, A>, key: B) => Fx<R2, E2, C>;
+    readonly onValue: (ref: RefSubject<A>, key: B) => Fx<C, E2, R2>;
     readonly debounce?: Duration.DurationInput;
 }
 /**
  * @since 1.20.0
  */
 export declare const keyed: {
-    <A, B extends PropertyKey, R2, E2, C>(options: KeyedOptions<A, B, R2, E2, C>): <R, E>(fx: Fx<R, E, ReadonlyArray<A>>) => Fx<R | R2, E | E2, ReadonlyArray<C>>;
-    <R, E, A, B extends PropertyKey, R2, E2, C>(fx: Fx<R, E, ReadonlyArray<A>>, options: KeyedOptions<A, B, R2, E2, C>): Fx<R | R2, E | E2, ReadonlyArray<C>>;
+    <A, B extends PropertyKey, E2, R2, C>(options: KeyedOptions<A, B, C, E2, R2>): <E, R>(fx: Fx<ReadonlyArray<A>, E, R>) => Fx<ReadonlyArray<C>, E | E2, R | R2>;
+    <A, E, R, B extends PropertyKey, E2, R2, C>(fx: Fx<ReadonlyArray<A>, E, R>, options: KeyedOptions<A, B, C, E2, R2>): Fx<ReadonlyArray<C>, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
-export interface WithKeyOptions<A, B, R2, E2, C> {
+export interface WithKeyOptions<A, B, C, E2, R2> {
     readonly getKey: (a: A) => B;
-    readonly onValue: (ref: RefSubject<never, never, A>, key: B) => Fx<R2, E2, C>;
+    readonly onValue: (ref: RefSubject<A>, key: B) => Fx<C, E2, R2>;
 }
 /**
  * @since 1.20.0
  */
 export declare const withKey: {
-    <A, B extends PropertyKey, R2, E2, C>(options: WithKeyOptions<A, B, R2, E2, C>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, C>;
-    <R, E, A, B extends PropertyKey, R2, E2, C>(fx: Fx<R, E, A>, options: WithKeyOptions<A, B, R2, E2, C>): Fx<R | R2, E | E2, C>;
+    <A, B extends PropertyKey, E2, R2, C>(options: WithKeyOptions<A, B, C, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<C, E | E2, R | R2>;
+    <A, E, R, B extends PropertyKey, E2, R2, C>(fx: Fx<A, E, R>, options: WithKeyOptions<A, B, C, E2, R2>): Fx<C, E | E2, R | R2>;
 };
 /**
  * Match over a tagged union of values into a set of persistent workflows
@@ -1379,10 +1379,10 @@ export declare const withKey: {
 export declare const matchTags: {
     <A extends {
         readonly _tag: string;
-    }, Matchers extends DefaultMatchersFrom<A>>(matchers: Matchers): <R, E>(fx: Fx<R, E, A>) => Fx<R | Fx.Context<ReturnType<Matchers[keyof Matchers]>>, E | Fx.Error<ReturnType<Matchers[keyof Matchers]>>, Fx.Success<ReturnType<Matchers[keyof Matchers]>>>;
-    <R, E, A extends {
+    }, Matchers extends DefaultMatchersFrom<A>>(matchers: Matchers): <E, R>(fx: Fx<A, E, R>) => Fx<Fx.Success<ReturnType<Matchers[keyof Matchers]>>, E | Fx.Error<ReturnType<Matchers[keyof Matchers]>>, R | Fx.Context<ReturnType<Matchers[keyof Matchers]>>>;
+    <A extends {
         readonly _tag: string;
-    }, Matchers extends DefaultMatchersFrom<A>>(fx: Fx<R, E, A>, matchers: Matchers): Fx<R | Fx.Context<ReturnType<Matchers[keyof Matchers]>>, E | Fx.Error<ReturnType<Matchers[keyof Matchers]>>, Fx.Success<ReturnType<Matchers[keyof Matchers]>>>;
+    }, E, R, Matchers extends DefaultMatchersFrom<A>>(fx: Fx<A, E, R>, matchers: Matchers): Fx<Fx.Success<ReturnType<Matchers[keyof Matchers]>>, E | Fx.Error<ReturnType<Matchers[keyof Matchers]>>, R | Fx.Context<ReturnType<Matchers[keyof Matchers]>>>;
 };
 /**
  * @since 1.20.0
@@ -1390,7 +1390,7 @@ export declare const matchTags: {
 export type DefaultMatchersFrom<A extends {
     readonly _tag: string;
 }> = {
-    readonly [Tag in A["_tag"]]: (value: RefSubject<never, never, Extract<A, {
+    readonly [Tag in A["_tag"]]: (value: RefSubject<Extract<A, {
         readonly _tag: Tag;
     }>>) => Fx<any, any, any>;
 };
@@ -1398,140 +1398,140 @@ export type DefaultMatchersFrom<A extends {
  * @since 1.20.0
  */
 export declare const matchOption: {
-    <A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(onNone: () => Fx<R2, E2, B>, onSome: (a: RefSubject<never, never, A>) => Fx<R3, E3, C>): <R, E>(fx: Fx<R, E, Option.Option<A>>) => Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, Option.Option<A>>, onNone: () => Fx<R2, E2, B>, onSome: (a: RefSubject<never, never, A>) => Fx<R3, E3, C>): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C>;
+    <A, B = never, E2 = never, R2 = never, C = never, E3 = never, R3 = never>(onNone: () => Fx<B, E2, R2>, onSome: (a: RefSubject<A>) => Fx<C, E3, R3>): <E, R>(fx: Fx<Option.Option<A>, E, R>) => Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <A, E, R, B = never, E2 = never, R2 = never, C = never, E3 = never, R3 = never>(fx: Fx<Option.Option<A>, E, R>, onNone: () => Fx<B, E2, R2>, onSome: (a: RefSubject<A>) => Fx<C, E3, R3>): Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const getOrElse: {
-    <A, R2 = never, E2 = never, B = never>(orElse: () => Fx<R2, E2, B>): <R, E>(fx: Fx<R, E, Option.Option<A>>) => Fx<R | R2 | Scope.Scope, E | E2, A | B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, Option.Option<A>>, orElse: () => Fx<R2, E2, B>): Fx<R | R2 | Scope.Scope, E | E2, A | B>;
+    <A, B = never, E2 = never, R2 = never>(orElse: () => Fx<B, E2, R2>): <E, R>(fx: Fx<Option.Option<A>, E, R>) => Fx<A | B, E | E2, R | R2 | Scope.Scope>;
+    <A, E, R, B = never, E2 = never, R2 = never>(fx: Fx<Option.Option<A>, E, R>, orElse: () => Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const matchEither: {
-    <E1, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(onLeft: (e: RefSubject<never, never, E1>) => Fx<R2, E2, B>, onRight: (a: RefSubject<never, never, A>) => Fx<R3, E3, C>): <R, E>(fx: Fx<R, E, Either.Either<E1, A>>) => Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C>;
-    <R, E, E1, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, Either.Either<E1, A>>, onLeft: (e: RefSubject<never, never, E1>) => Fx<R2, E2, B>, onRight: (a: RefSubject<never, never, A>) => Fx<R3, E3, C>): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C>;
+    <E1, A, B = never, E2 = never, R2 = never, C = never, E3 = never, R3 = never>(onLeft: (e: RefSubject<E1>) => Fx<B, E2, R2>, onRight: (a: RefSubject<A>) => Fx<C, E3, R3>): <E, R>(fx: Fx<Either.Either<E1, A>, E, R>) => Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <R, E, E1, A, B = never, E2 = never, R2 = never, C = never, E3 = never, R3 = never>(fx: Fx<Either.Either<E1, A>, E, R>, onLeft: (e: RefSubject<E1>) => Fx<B, E2, R2>, onRight: (a: RefSubject<A>) => Fx<C, E3, R3>): Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const at: {
-    (duration: Duration.DurationInput): <A>(value: A) => Fx<never, never, A>;
-    <A>(value: A, duration: Duration.DurationInput): Fx<never, never, A>;
+    (duration: Duration.DurationInput): <A>(value: A) => Fx<A>;
+    <A>(value: A, duration: Duration.DurationInput): Fx<A>;
 };
 /**
  * @since 1.20.0
  */
-export declare function drainLayer<FXS extends ReadonlyArray<Fx<any, never, any>>>(...fxs: FXS): Layer.Layer<Exclude<Fx.Context<FXS[number]>, Scope.Scope>, never, never>;
+export declare function drainLayer<FXS extends ReadonlyArray<Fx<any, never, any>>>(...fxs: FXS): Layer.Layer<never, never, Exclude<Fx.Context<FXS[number]>, Scope.Scope>>;
 /**
  * @since 1.20.0
  */
-export declare const fork: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<E, void>>;
+export declare const fork: <A, E, R>(fx: Fx<A, E, R>) => Effect.Effect<Fiber.RuntimeFiber<void, E>, never, R>;
 /**
  * @since 1.20.0
  */
-export declare const forkScoped: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Fiber.RuntimeFiber<E, void>>;
+export declare const forkScoped: <A, E, R>(fx: Fx<A, E, R>) => Effect.Effect<Fiber.RuntimeFiber<void, E>, never, Scope.Scope | R>;
 /**
  * @since 1.20.0
  */
-export declare const forkDaemon: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<E, void>>;
+export declare const forkDaemon: <A, E, R>(fx: Fx<A, E, R>) => Effect.Effect<Fiber.RuntimeFiber<void, E>, never, R>;
 /**
  * @since 1.20.0
  */
 export declare const forkIn: {
-    (scope: Scope.Scope): <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<E, void>>;
-    <R, E, A>(fx: Fx<R, E, A>, scope: Scope.Scope): Effect.Effect<R, never, Fiber.RuntimeFiber<E, void>>;
+    (scope: Scope.Scope): <A, E, R>(fx: Fx<A, E, R>) => Effect.Effect<Fiber.RuntimeFiber<void, E>, never, R>;
+    <A, E, R>(fx: Fx<A, E, R>, scope: Scope.Scope): Effect.Effect<Fiber.RuntimeFiber<void, E>, never, R>;
 };
 /**
  * @since 1.20.0
  */
-export declare const fromAsyncIterable: <A>(iterable: AsyncIterable<A>) => Fx<never, never, A>;
+export declare const fromAsyncIterable: <A>(iterable: AsyncIterable<A>) => Fx<A>;
 /**
  * @since 1.20.0
  */
 export declare const partitionMap: {
-    <A, B, C>(f: (a: A) => Either.Either<B, C>): <R, E>(fx: Fx<R, E, A>) => readonly [Fx<Scope.Scope | R, E, B>, Fx<Scope.Scope | R, E, C>];
-    <R, E, A, B, C>(fx: Fx<R, E, A>, f: (a: A) => Either.Either<B, C>): readonly [Fx<Scope.Scope | R, E, B>, Fx<Scope.Scope | R, E, C>];
+    <A, B, C>(f: (a: A) => Either.Either<B, C>): <E, R>(fx: Fx<A, E, R>) => readonly [Fx<B, E, Scope.Scope | R>, Fx<C, E, Scope.Scope | R>];
+    <A, E, R, B, C>(fx: Fx<A, E, R>, f: (a: A) => Either.Either<B, C>): readonly [Fx<B, E, Scope.Scope | R>, Fx<C, E, Scope.Scope | R>];
 };
 /**
  * @since 1.20.0
  */
-export declare const gen: <Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(f: (_: Effect.Adapter) => Generator<Y, FX, any>) => Fx<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Effect.Effect.Error<Y["value"]> | Fx.Error<FX>, Fx.Success<FX>>;
+export declare const gen: <Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(f: (_: Effect.Adapter) => Generator<Y, FX, any>) => Fx<Fx.Success<FX>, Effect.Effect.Error<Y["value"]> | Fx.Error<FX>, Effect.Effect.Context<Y["value"]> | Fx.Context<FX>>;
 /**
  * @since 1.20.0
  */
-export declare const genScoped: <Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(f: (_: Effect.Adapter) => Generator<Y, FX, any>) => Fx<Exclude<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Scope.Scope>, Effect.Effect.Error<Y["value"]> | Fx.Error<FX>, Fx.Success<FX>>;
+export declare const genScoped: <Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(f: (_: Effect.Adapter) => Generator<Y, FX, any>) => Fx<Fx.Success<FX>, Effect.Effect.Error<Y["value"]> | Fx.Error<FX>, Exclude<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Scope.Scope>>;
 /**
  * @since 1.20.0
  */
 export declare const findFirst: {
-    <A, B extends A>(refinement: Predicate.Refinement<A, B>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, B>;
-    <A>(predicate: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, A>;
-    <R, E, A, B extends A>(fx: Fx<R, E, A>, refinement: Predicate.Refinement<A, B>): Effect.Effect<R, E, B>;
-    <R, E, A>(fx: Fx<R, E, A>, predicate: Predicate.Predicate<A>): Effect.Effect<R, E, A>;
+    <A, B extends A>(refinement: Predicate.Refinement<A, B>): <E, R>(fx: Fx<A, E, R>) => Effect.Effect<B, E, R>;
+    <A>(predicate: Predicate.Predicate<A>): <E, R>(fx: Fx<A, E, R>) => Effect.Effect<A, E, R>;
+    <A, E, R, B extends A>(fx: Fx<A, E, R>, refinement: Predicate.Refinement<A, B>): Effect.Effect<B, E, R>;
+    <A, E, R>(fx: Fx<A, E, R>, predicate: Predicate.Predicate<A>): Effect.Effect<A, E, R>;
 };
 /**
  * @since 1.20.0
  */
-export declare const first: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, A>;
+export declare const first: <A, E, R>(fx: Fx<A, E, R>) => Effect.Effect<A, E, R>;
 /**
  * @since 1.20.0
  */
 export declare const mergeFirst: {
-    <R2, E2, B>(that: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, that: Fx<R2, E2, B>): Fx<R | R2, E | E2, A>;
+    <B, E2, R2>(that: Fx<B, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, that: Fx<B, E2, R2>): Fx<A, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const mergeRace: {
-    <R2, E2, B>(that: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, that: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>;
+    <B, E2, R2>(that: Fx<B, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, that: Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
-export declare const raceAll: <const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
+export declare const raceAll: <const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
 /**
  * @since 1.20.0
  */
 export declare const race: {
-    <R2, E2, B>(that: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, that: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>;
+    <B, E2, R2>(that: Fx<B, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, that: Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const snapshot: {
-    <R, E, B, A, C>(sampled: Fx<R, E, B>, g: (a: A, b: B) => C): <R2, E2>(fx: Fx<R2, E2, A>) => Fx<R | R2, E | E2, C>;
-    <R, E, A, R2, E2, B, C>(fx: Fx<R, E, A>, sampled: Fx<R2, E2, B>, f: (a: A, b: B) => C): Fx<R | R2, E | E2, C>;
+    <B, E, R, A, C>(sampled: Fx<B, E, R>, g: (a: A, b: B) => C): <E2, R2>(fx: Fx<A, E2, R2>) => Fx<C, E | E2, R | R2>;
+    <A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, sampled: Fx<B, E2, R2>, f: (a: A, b: B) => C): Fx<C, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const sample: {
-    <R, E, B>(sampled: Fx<R, E, B>): <R2, E2, A>(fx: Fx<R2, E2, A>) => Fx<R | R2, E | E2, B>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, sampled: Fx<R2, E2, B>): Fx<R | R2, E | E2, B>;
+    <B, E, R>(sampled: Fx<B, E, R>): <E2, R2, A>(fx: Fx<A, E2, R2>) => Fx<B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, sampled: Fx<B, E2, R2>): Fx<B, E | E2, R | R2>;
 };
 /**
  * @since 1.20.0
  */
 export declare const snapshotEffect: {
-    <R2, E2, B, A, R3, E3, C>(sampled: Fx<R2, E2, B>, g: (a: A, b: B) => Effect.Effect<R3, E3, C>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, sampled: Fx<R2, E2, B>, f: (a: A, b: B) => Effect.Effect<R3, E3, C>): Fx<R | R2 | R3, E | E2 | E3, C>;
+    <B, E2, R2, A, C, E3, R3>(sampled: Fx<B, E2, R2>, g: (a: A, b: B) => Effect.Effect<C, E3, R3>): <E, R>(fx: Fx<A, E, R>) => Fx<C, E | E2 | E3, R | R2 | R3>;
+    <A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, sampled: Fx<B, E2, R2>, f: (a: A, b: B) => Effect.Effect<C, E3, R3>): Fx<C, E | E2 | E3, R | R2 | R3>;
 };
 declare const if_: {
-    <R2, E2, B, R3, E3, C>(options: {
-        readonly onTrue: Fx<R2, E2, B>;
-        readonly onFalse: Fx<R3, E3, C>;
-    }): <R, E>(bool: Fx<R, E, boolean>) => Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C>;
-    <R, E, R2, E2, B, R3, E3, C>(bool: Fx<R, E, boolean>, options: {
-        readonly onTrue: Fx<R2, E2, B>;
-        readonly onFalse: Fx<R3, E3, C>;
-    }): Fx<R | R2 | R3 | Scope.Scope, E | E2 | E3, B | C>;
+    <B, E2, R2, C, E3, R3>(options: {
+        readonly onTrue: Fx<B, E2, R2>;
+        readonly onFalse: Fx<C, E3, R3>;
+    }): <E, R>(bool: Fx<boolean, E, R>) => Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope.Scope>;
+    <B, E, R, E2, R2, C, E3, R3>(bool: Fx<boolean, E, R>, options: {
+        readonly onTrue: Fx<B, E2, R2>;
+        readonly onFalse: Fx<C, E3, R3>;
+    }): Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope.Scope>;
 };
 export { 
 /**
@@ -1545,66 +1545,66 @@ export declare const when: {
     <B, C>(options: {
         readonly onTrue: B;
         readonly onFalse: C;
-    }): <R, E>(bool: Fx<R, E, boolean>) => Fx<R | Scope.Scope, E, B | C>;
-    <R, E, B, C>(bool: Fx<R, E, boolean>, options: {
+    }): <E, R>(bool: Fx<boolean, E, R>) => Fx<B | C, E, R | Scope.Scope>;
+    <B, E, R, C>(bool: Fx<boolean, E, R>, options: {
         readonly onTrue: B;
         readonly onFalse: C;
-    }): Fx<R | Scope.Scope, E, B | C>;
+    }): Fx<B | C, E, R | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
-export declare const withEmitter: <E, A, R = never, E2 = never>(f: (emitter: Emitter.Emitter<E, A>) => Effect.Effect<R, E2, unknown>) => Fx<Scope.Scope | R, E | E2, A>;
+export declare const withEmitter: <A, E = never, E2 = never, R = never>(f: (emitter: Emitter.Emitter<A, E>) => Effect.Effect<unknown, E2, R>) => Fx<A, E | E2, Scope.Scope | R>;
 /**
  * Create an Fx which will wait a specified duration of time where no
  * events have occurred before emitting a value.
  * @since 1.18.0
  */
 export declare const delay: {
-    (delay: DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | Scope.Scope, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, delay: DurationInput): Fx<R | Scope.Scope, E, A>;
+    (delay: DurationInput): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R | Scope.Scope>;
+    <A, E, R>(fx: Fx<A, E, R>, delay: DurationInput): Fx<A, E, R | Scope.Scope>;
 };
 /**
  * @since 1.20.0
  */
 export declare const ensuring: {
-    <R2>(finalizer: Effect.Effect<R2, never, unknown>): <R, E, A>(self: Fx<R, E, A>) => Fx<R | R2, E, A>;
-    <R, E, A, R2>(self: Fx<R, E, A>, finalizer: Effect.Effect<R2, never, unknown>): Fx<R | R2, E, A>;
+    <R2>(finalizer: Effect.Effect<unknown, never, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E, R | R2>;
+    <A, E, R, R2>(self: Fx<A, E, R>, finalizer: Effect.Effect<unknown, never, R2>): Fx<A, E, R | R2>;
 };
 /**
  * @since 1.20.0
  */
-export declare const flip: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, A, E>;
+export declare const flip: <A, E, R>(fx: Fx<A, E, R>) => Fx<E, A, R>;
 /**
  * @since 1.20.0
  */
-export declare const fromNullable: <A>(value: void | A | null | undefined) => Fx<never, never, NonNullable<A>>;
+export declare const fromNullable: <A>(value: void | A | null | undefined) => Fx<NonNullable<A>, never, never>;
 /**
  * @since 1.20.0
  */
-export declare function fromDequeue<A>(dequeue: Queue.Dequeue<A>): Fx<never, never, A>;
-export declare function fromDequeue<I, A>(dequeue: Ctx.Dequeue<I, A>): Fx<I, never, A>;
+export declare function fromDequeue<A>(dequeue: Queue.Dequeue<A>): Fx<A>;
+export declare function fromDequeue<I, A>(dequeue: Ctx.Dequeue<I, A>): Fx<A, never, I>;
 /**
  * @since 1.20.0
  */
-export declare function fromPubSub<A>(pubSub: PubSub.PubSub<A>): Fx<Scope.Scope, never, A>;
-export declare function fromPubSub<I, A>(pubSub: Ctx.PubSub<I, A>): Fx<I | Scope.Scope, never, A>;
+export declare function fromPubSub<A>(pubSub: PubSub.PubSub<A>): Fx<A, never, Scope.Scope>;
+export declare function fromPubSub<I, A>(pubSub: Ctx.PubSub<I, A>): Fx<A, never, I | Scope.Scope>;
 /**
  * @since 1.20.0
  */
-export declare abstract class FxEffectBase<R, E, A, R2, E2, B> extends protos.FxEffectBase<R, E, A, R2, E2, B> {
+export declare abstract class FxEffectBase<A, E, R, B, E2, R2> extends protos.FxEffectBase<A, E, R, B, E2, R2> {
     private _fx;
     /**
      * @since 1.20.0
      */
-    run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<R | R3, never, void>;
+    run<R3>(sink: Sink.Sink<A, E, R3>): Effect.Effect<void, never, R | R3>;
     /**
      * @since 1.20.0
      */
-    abstract toFx(): Fx<R, E, A>;
+    abstract toFx(): Fx<A, E, R>;
     /**
      * @since 1.20.0
      */
-    abstract toEffect(): Effect.Effect<R2, E2, B>;
+    abstract toEffect(): Effect.Effect<B, E2, R2>;
 }
 //# sourceMappingURL=Fx.d.ts.map