@typed/fx 1.22.2 → 1.23.0

package/dist/dts/Fx.d.ts

@@ -29,7 +29,7 @@ export interface Fx<out R, out E, out A> extends Pipeable.Pipeable {
     /**
      * @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<R2, E, A>): Effect.Effect<unknown, never, R | R2>;
 }
 /**
  * @since 1.20.0
@@ -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 = <R, E, A>(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,14 +215,14 @@ 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>;
+    <R, E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<unknown, never, R>): Fx<R, E, A>;
+    <E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<unknown>): Fx<never, E, A>;
+    <A>(run: (sink: Sink.Sink<never, never, A>) => Effect.Effect<unknown>): Fx<never, never, A>;
 };
 /**
  * @since 1.20.0
@@ -243,27 +243,27 @@ export declare const fromIterable: <A>(iterable: Iterable<A>) => Fx<never, never
 /**
  * @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: <R, E, A>(effect: Effect.Effect<A, E, R>) => Fx<R, E, A>;
 /**
  * @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>): <R, E>(input: Effect.Effect<I, E, R>) => Fx<R | R2, E, O>;
+    <R, E, I, R2, O>(input: Effect.Effect<I, E, R>, schedule: Schedule.Schedule<R2, I, O>): Fx<R | R2, E, O>;
 };
 /**
  * @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>): <R, E, A>(input: Effect.Effect<A, E, R>) => Fx<R | R2, E, A>;
+    <R, E, A, R2, O>(input: Effect.Effect<A, E, R>, schedule: Schedule.Schedule<R2, unknown, O>): Fx<R | R2, E, A>;
 };
 /**
  * @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): <R, E, A>(iterator: Effect.Effect<A, E, R>) => Fx<R, E, A>;
+    <R, E, A>(iterator: Effect.Effect<A, E, R>, period: Duration.DurationInput): Fx<R, E, A>;
 };
 /**
  * @since 1.20.0
@@ -308,29 +308,29 @@ export declare const compact: <R, E, A>(fx: Fx<R, E, Option.Option<A>>) => Fx<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, R2, E2, B>(f: (a: A) => Effect.Effect<B, E2, R2>): <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<B, E2, R2>): Fx<R | R2, E | E2, B>;
 };
 /**
  * @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, R2, E2, B>(f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>): <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<Option.Option<B>, E2, R2>): Fx<R | R2, E | E2, B>;
 };
 /**
  * @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, R2, E2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <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<boolean, E2, R2>): Fx<R | R2, E | E2, A>;
 };
 /**
  * @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, R2, E2>(f: (a: A) => Effect.Effect<unknown, E2, R2>): <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<unknown, E2, R2>): Fx<R | R2, E | E2, A>;
 };
 /**
  * @since 1.20.0
@@ -357,38 +357,38 @@ export declare const filterMapLoop: {
  * @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>;
+    <R2, E2, B, A, C>(seed: B, f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E2, R2>): <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<readonly [C, B], E2, R2>): Fx<R | R2, E | E2, C>;
 };
 /**
  * @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>;
+    <R2, E2, B, A, C>(seed: B, f: (acc: B, a: A) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>): <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<readonly [Option.Option<C>, B], E2, R2>): Fx<R | R2, E | E2, C>;
 };
 /**
  * @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, R2, E2, B>(f: (a: A) => Effect.Effect<B, E2, R2>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<void, E | E2, R | R2>;
+    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, 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: <R, E, A>(fx: Fx<R, E, A>) => 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): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<B, E, R>;
+    <R, E, A, B>(fx: Fx<R, E, A>, 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: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>;
 /**
  * @since 1.20.0
  */
@@ -489,8 +489,8 @@ export declare const flatMap: {
  * @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, R2, E2, B>(f: (a: A) => Effect.Effect<B, E2, R2>, 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<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
 };
 /**
  * @since 1.20.0
@@ -503,8 +503,8 @@ export declare const switchMap: {
  * @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, R2, E2, B>(f: (a: A) => Effect.Effect<B, E2, R2>, 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<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
 };
 /**
  * @since 1.20.0
@@ -517,8 +517,8 @@ export declare const exhaustMap: {
  * @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, R2, E2, B>(f: (a: A) => Effect.Effect<B, E2, R2>, 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<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
 };
 /**
  * @since 1.20.0
@@ -531,8 +531,8 @@ export declare const exhaustMapLatest: {
  * @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, R2, E2, B>(f: (a: A) => Effect.Effect<B, E2, R2>, 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<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
 };
 /**
  * @since 1.20.0
@@ -545,8 +545,8 @@ export declare const flatMapConcurrently: {
  * @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, R2, E2, B>(f: (a: A) => Effect.Effect<B, E2, R2>, 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<B, E2, R2>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined): Fx<R | R2 | Scope.Scope, E | E2, B>;
 };
 /**
  * @since 1.20.0
@@ -558,7 +558,7 @@ export declare const concatMap: {
 /**
  * @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: <R, E, R2, E2, B>(effect: Effect.Effect<Fx<R2, E2, B>, E, R>) => Fx<R | R2, E | E2, B>;
 /**
  * @since 1.20.0
  */
@@ -663,36 +663,36 @@ export declare const dropAfter: {
  * @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, R2, E2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <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<boolean, E2, R2>): Fx<R | R2, E | E2, A>;
 };
 /**
  * @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, R2, E2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <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<boolean, E2, R2>): Fx<R | R2, E | E2, A>;
 };
 /**
  * @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, R2, E2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <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<boolean, E2, R2>): Fx<R | R2, E | E2, A>;
 };
 /**
  * @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, R2, E2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <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<boolean, E2, R2>): Fx<R | R2, E | E2, A>;
 };
 /**
  * @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, R2, E2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <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<boolean, E2, R2>): Fx<R | R2, E | E2, A>;
 };
 /**
  * @since 1.20.0
@@ -719,29 +719,29 @@ export declare const until: {
  * @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, R3, E, A>(effect: (effect: Effect.Effect<unknown, never, R>) => Effect.Effect<unknown, never, R3>, 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<unknown, never, R>) => Effect.Effect<unknown, never, R3>, sink?: ((sink: Sink.Sink<never, E, A>) => Sink.Sink<R, E, A>) | undefined): Fx<R3, E, A>;
 };
 /**
  * @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>): <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<unknown>) => Effect.Effect<unknown, never, R2>): Fx<R | R2, E, A>;
 };
 /**
  * @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>): <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<unknown, never, R2>): Fx<R | R2, E, A>;
 };
 /**
  * @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>): <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<unknown, never, R2>): Fx<R | R2, E, A>;
 };
 /**
  * @since 1.20.0
@@ -857,8 +857,8 @@ export declare const withTracer: {
  * @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, R2, E2, B, R3, E3, C>(use: (a: A) => Fx<R2, E2, B>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<C, E3, R3>): <R, E>(acquire: Effect.Effect<A, E, R>) => Fx<R | R2 | R3, E | E2 | E3, B>;
+    <R, E, A, R2, E2, B, R3, E3, C>(acquire: Effect.Effect<A, E, R>, use: (a: A) => Fx<R2, E2, B>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<C, E3, R3>): Fx<R | R2 | R3, E | E2 | E3, B>;
 };
 /**
  * @since 1.20.0
@@ -890,8 +890,8 @@ export declare const provideContext: {
  * @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>;
+    <R2, E2, S>(layer: Layer.Layer<S, E2, R2>): <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<S, E2, R2>): Fx<R2 | Exclude<R, S>, E | E2, A>;
 };
 /**
  * @since 1.20.0
@@ -911,8 +911,8 @@ export declare const provideService: {
  * @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, R2, E2>(service: Ctx.Tag<I, S>, instance: Effect.Effect<S, E2, R2>): <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<S, E2, R2>): Fx<R2 | Exclude<R, I>, E | E2, A>;
 };
 /**
  * @since 1.20.0
@@ -920,12 +920,12 @@ export declare const provideServiceEffect: {
 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>;
+    <R2, E2, S>(layer: Layer.Layer<S, E2, R2>): <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<S, E2, R2> | 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>;
+    <R, E, A, R2, E2, S>(fx: Fx<R, E, A>, layer: Layer.Layer<S, E2, R2>): 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<S, E2, R2> | Ctx.Context<S> | Runtime.Runtime<S>): Fx<R2 | Exclude<R, S>, E | E2, A>;
 };
 /**
  * @since 1.20.0
@@ -1002,43 +1002,43 @@ export declare const filterMapError: {
  * @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>;
+    <R2, E2, E3>(f: (cause: Cause.Cause<E2>) => Effect.Effect<Cause.Cause<E3>, E3, R2>): <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<Cause.Cause<E3>, E2, R2>): Fx<R | R2, E2 | E3, A>;
 };
 /**
  * @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>;
+    <R2, E2, E3>(f: (e: E2) => Effect.Effect<E3, E3, R2>): <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<E3, E2, R2>): Fx<R | R2, E2 | E3, A>;
 };
 /**
  * @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, R2, E2>(f: (cause: Cause.Cause<E>) => Effect.Effect<boolean, E2, R2>): <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<boolean, E2, R2>): Fx<R | R2, E2, A>;
 };
 /**
  * @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, R2, E2>(f: (e: E) => Effect.Effect<boolean, E2, R2>): <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<boolean, E2, R2>): Fx<R | R2, E2, A>;
 };
 /**
  * @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>;
+    <R2, E2, E3>(f: (cause: Cause.Cause<E2>) => Effect.Effect<Option.Option<Cause.Cause<E3>>, E2, R2>): <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<Option.Option<Cause.Cause<E3>>, E2, R2>): Fx<R | R2, E2 | E3, A>;
 };
 /**
  * @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, R2, E2, E3>(f: (e: E) => Effect.Effect<Option.Option<E3>, E2, R2>): <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<Option.Option<E3>, E2, R2>): Fx<R | R2, E2 | E3, A>;
 };
 /**
  * @since 1.20.0
@@ -1058,43 +1058,43 @@ export declare const loopError: {
  * @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, R2, E2, C>(seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<readonly [Cause.Cause<C>, B], E2, R2>): <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<readonly [Cause.Cause<C>, B], E2, R2>): Fx<R | R2, E2 | C, A>;
 };
 /**
  * @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, R2, E2, C>(seed: B, f: (b: B, e: E) => Effect.Effect<readonly [C, B], E2, R2>): <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<readonly [C, B], E2, R2>): Fx<R | R2, E2 | C, A>;
 };
 /**
  * @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>;
+    <B, E, R2, E2, 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<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>;
 };
 /**
  * @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>;
+    <B, E, R2, E2, C>(seed: B, f: (b: B, e: E) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>): <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>;
 };
 /**
  * @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, R2, E2, 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<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<readonly [Option.Option<Cause.Cause<C>>, B], E2, R2>): Fx<R | R2, E2 | C, A>;
 };
 /**
  * @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, R2, E2, C>(seed: B, f: (b: B, e: E) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>): <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<readonly [Option.Option<C>, B], E2, R2>): Fx<R | R2, E2 | C, A>;
 };
 /**
  * @since 1.20.0
@@ -1283,7 +1283,7 @@ export declare const exhaustMatchLatestError: {
 /**
  * @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: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Exit.Exit<A, E>>;
 /**
  * @since 1.20.0
  */
@@ -1315,8 +1315,8 @@ export declare const all: {
  * @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>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<void, E, R | R2>;
+    <R, E, A, R2 = never>(fx: Fx<R, E, A>, queue: Ctx.Enqueue<R2, A> | Queue.Enqueue<A>): Effect.Effect<void, E, R | R2>;
 };
 /**
  * @since 1.20.0
@@ -1425,25 +1425,25 @@ export declare const at: {
 /**
  * @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: <R, E, A>(fx: Fx<R, E, A>) => 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: <R, E, A>(fx: Fx<R, E, A>) => 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: <R, E, A>(fx: Fx<R, E, A>) => 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): <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<Fiber.RuntimeFiber<void, E>, never, R>;
+    <R, E, A>(fx: Fx<R, E, A>, scope: Scope.Scope): Effect.Effect<Fiber.RuntimeFiber<void, E>, never, R>;
 };
 /**
  * @since 1.20.0
@@ -1468,15 +1468,15 @@ export declare const genScoped: <Y extends Effect.EffectGen<any, any, any>, FX e
  * @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>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<B, E, R>;
+    <A>(predicate: Predicate.Predicate<A>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<A, E, R>;
+    <R, E, A, B extends A>(fx: Fx<R, E, A>, refinement: Predicate.Refinement<A, B>): Effect.Effect<B, E, R>;
+    <R, E, A>(fx: Fx<R, E, A>, 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: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<A, E, R>;
 /**
  * @since 1.20.0
  */
@@ -1520,8 +1520,8 @@ export declare const sample: {
  * @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>;
+    <R2, E2, B, A, R3, E3, C>(sampled: Fx<R2, E2, B>, g: (a: A, b: B) => Effect.Effect<C, E3, R3>): <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<C, E3, R3>): Fx<R | R2 | R3, E | E2 | E3, C>;
 };
 declare const if_: {
     <R2, E2, B, R3, E3, C>(options: {
@@ -1554,7 +1554,7 @@ export declare const when: {
 /**
  * @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: <E, A, R = never, E2 = never>(f: (emitter: Emitter.Emitter<E, A>) => Effect.Effect<unknown, E2, R>) => Fx<Scope.Scope | R, E | E2, A>;
 /**
  * Create an Fx which will wait a specified duration of time where no
  * events have occurred before emitting a value.
@@ -1568,8 +1568,8 @@ export declare const delay: {
  * @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>): <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<unknown, never, R2>): Fx<R | R2, E, A>;
 };
 /**
  * @since 1.20.0
@@ -1597,7 +1597,7 @@ export declare abstract class FxEffectBase<R, E, A, R2, E2, B> extends protos.Fx
     /**
      * @since 1.20.0
      */
-    run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<R | R3, never, void>;
+    run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<void, never, R | R3>;
     /**
      * @since 1.20.0
      */
@@ -1605,6 +1605,6 @@ export declare abstract class FxEffectBase<R, E, A, R2, E2, B> extends protos.Fx
     /**
      * @since 1.20.0
      */
-    abstract toEffect(): Effect.Effect<R2, E2, B>;
+    abstract toEffect(): Effect.Effect<B, E2, R2>;
 }
 //# sourceMappingURL=Fx.d.ts.map