@typed/fx 1.19.0 → 1.20.0

package/dist/dts/Fx.d.ts

@@ -1,116 +1,96 @@
 /**
- * Fx<R, E, A> is a representation of an `Effect`-ful workflow that exists over
- * the time dimension. It operates within a context `R`, can fail with an `E`,
- * and succeed with an `A`.
- *
- * Any `Fx`, shorthand for "Effects", can emit 0 or more errors or events over an
- * indefinite period of time. This is in contrast to `Effect` which can only
- * produce exactly 1 error or event.
- *
- * It is defined as a super-type of `Effect`, `Stream`, and `Cause`. This
- * allows for all operators that accept an `Fx` to also capable of
- * accepting an `Effect`, `Stream`, or `Cause`. An Effect or Cause represents a single
- * event or error, while a Stream represents a series of events or errors that will
- * be pulled from the producer as soon as possible.
- *
- * @since 1.18.0
+ * Fx is a push-based reactive primitive built atop of Effect.
+ * @since 1.20.0
  */
-import type * as Context from "@typed/context";
-import type { Stream } from "effect";
+import type * as Ctx from "@typed/context";
+import type { ConfigProvider, Duration, Equivalence, ExecutionStrategy, Exit, Fiber, FiberId, FiberRef, HashSet, Pipeable, Predicate, PubSub, Request, Runtime, Scope, Tracer } from "effect";
 import * as Cause from "effect/Cause";
-import type * as Chunk from "effect/Chunk";
 import type { DurationInput } from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Either from "effect/Either";
-import type { Equivalence } from "effect/Equivalence";
-import type * as Exit from "effect/Exit";
-import type * as Fiber from "effect/Fiber";
-import type * as FiberId from "effect/FiberId";
-import type { FiberRef } from "effect/FiberRef";
-import type * as HashSet from "effect/HashSet";
-import type { Inspectable } from "effect/Inspectable";
-import type * as Layer from "effect/Layer";
+import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import type { Pipeable } from "effect/Pipeable";
-import type * as PubSub from "effect/PubSub";
-import type * as Queue from "effect/Queue";
-import type * as Request from "effect/Request";
-import type * as Runtime from "effect/Runtime";
-import type * as Schedule from "effect/Schedule";
-import type { Scheduler } from "effect/Scheduler";
-import type * as Scope from "effect/Scope";
-import type * as Tracer from "effect/Tracer";
-import type { Emitter } from "./Emitter.js";
-import * as primitive from "./internal/fx-primitive.js";
-import * as internalProtos from "./internal/protos.js";
+import * as Queue from "effect/Queue";
+import * as Schedule from "effect/Schedule";
+import type * as Types from "effect/Types";
+import * as Emitter from "./Emitter.js";
+import * as core from "./internal/core.js";
+import * as protos from "./internal/protos.js";
 import { type RefSubject } from "./RefSubject.js";
-import type * as Sink from "./Sink.js";
-import type { Subject } from "./Subject.js";
+import * as Sink from "./Sink.js";
+import type * as Subject from "./Subject.js";
 import { TypeId } from "./TypeId.js";
 /**
- * Fx<R, E, A> is a representation of an `Effect`-ful workflow that exists over
- * the time dimension. It operates within a context `R`, can fail with an `E`,
- * and succeed with an `A`.
- *
- * @since 1.18.0
- * @category models
+ * Fx is a push-based reactive primitive built atop of Effect.
+ * @since 1.20.0
  */
-export interface Fx<R, E, A> extends Fx.Variance<R, E, A>, Pipeable, Inspectable {
+export interface Fx<out R, out E, out A> extends Pipeable.Pipeable {
+    readonly [TypeId]: Fx.Variance<R, E, A>;
+    /**
+     * @since 1.20.0
+     */
+    run<R2 = never>(sink: Sink.Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown>;
 }
 /**
- * FxInput<R, E, A> are all the types that can be transformed into an Fx
- *
- * @since 1.18.0
- * @category models
- */
-export type FxInput<R, E, A> = Fx<R, E, A> | Effect.Effect<R, E, A> | Cause.Cause<E> | Iterable<A>;
-/**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export declare namespace Fx {
     /**
-     * Extract the Context, Error, or Success type from an Fx
-     * @since 1.18.0
+     * @since 1.20.0
+     */
+    interface Variance<R, E, A> {
+        readonly _R: Types.Covariant<R>;
+        readonly _E: Types.Covariant<E>;
+        readonly _A: Types.Covariant<A>;
+    }
+    /**
+     * @since 1.20.0
      */
     type Context<T> = T extends Fx<infer R, infer _E, infer _A> ? R : never;
     /**
-     * Extract the Error type from an Fx
-     * @since 1.18.0
+     * @since 1.20.0
      */
     type Error<T> = T extends Fx<infer _R, infer E, infer _A> ? E : never;
     /**
-     * Extract the Success type from an Fx
-     * @since 1.18.0
+     * @since 1.20.0
      */
     type Success<T> = T extends Fx<infer _R, infer _E, infer A> ? A : never;
     /**
-     * Configures the variance of an Fx
-     * @since 1.18.0
-     * @category models
-     */
-    interface Variance<R, E, A> {
-        readonly [TypeId]: {
-            readonly _R: (_: never) => R;
-            readonly _E: (_: never) => E;
-            readonly _A: (_: never) => A;
-        };
-    }
-    /**
-     * @since 1.18.0
+     * @since 1.20.0
      */
-    type FromInput<T extends FxInput<any, any, any>> = [T] extends [ReadonlyArray<infer A>] ? Fx<never, never, A> : [T] extends [Iterable<infer A>] ? Fx<never, never, A> : [T] extends [Cause.Cause<infer E>] ? Fx<never, E, never> : [T] extends [Fx<infer R, infer E, infer A>] ? Fx<R, E, A> : [T] extends [Effect.Effect<infer R, infer E, infer A>] ? Fx<R, E, A> : never;
+    type Unify<T> = T extends Fx<infer R, infer E, infer A> | infer _ ? Fx<R, E, A> : never;
 }
+/**
+ * @since 1.20.0
+ */
+export type Context<T> = Fx.Context<T>;
+/**
+ * @since 1.20.0
+ */
+export type Error<T> = Fx.Error<T>;
+/**
+ * @since 1.20.0
+ */
+export type Success<T> = Fx.Success<T>;
+/**
+ * @since 1.20.0
+ */
+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>;
 /**
  * FlattenStrategy is a representation of how higher-order effect operators should flatten
  * nested Fx.
  *
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export type FlattenStrategy = Unbounded | Bounded | Switch | Exhaust | ExhaustLatest;
 /**
  * Strategy which will allow for an unbounded number of concurrent effects to be run.
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export interface Unbounded {
@@ -118,13 +98,13 @@ export interface Unbounded {
 }
 /**
  * Singleton instance of Unbounded
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export declare const Unbounded: Unbounded;
 /**
  * Strategy which will allow for a bounded number of concurrent effects to be run.
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export interface Bounded {
@@ -133,13 +113,13 @@ export interface Bounded {
 }
 /**
  * Construct a Bounded strategy
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export declare const Bounded: (capacity: number) => Bounded;
 /**
  * Strategy which will switch to a new effect as soon as it is available.
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export interface Switch {
@@ -147,7 +127,7 @@ export interface Switch {
 }
 /**
  * Singleton instance of Switch
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export declare const Switch: Switch;
@@ -156,7 +136,7 @@ export declare const Switch: Switch;
  * the first Fx is still running. When the first Fx finished, the next event
  * will execute.
  *
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export interface Exhaust {
@@ -164,7 +144,7 @@ export interface Exhaust {
 }
 /**
  * Singleton instance of Exhaust
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export declare const Exhaust: Exhaust;
@@ -173,7 +153,7 @@ export declare const Exhaust: Exhaust;
  * the latest Fx is still running. When the latest Fx finishes, the last seend event
  * will execute.
  *
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export interface ExhaustLatest {
@@ -181,19 +161,19 @@ export interface ExhaustLatest {
 }
 /**
  * Singleton instance of ExhaustLatest
- * @since 1.18.0
+ * @since 1.20.0
  * @category FlattenStrategy
  */
 export declare const ExhaustLatest: ExhaustLatest;
 /**
  * MergeStrategy is a representation of how multiple Fx should be merged together.
- * @since 1.18.0
+ * @since 1.20.0
  * @category MergeStrategy
  */
 export type MergeStrategy = Unordered | Ordered | Switch;
 /**
  * Strategy which will merge Fx in an unordered fashion.
- * @since 1.18.0
+ * @since 1.20.0
  * @category MergeStrategy
  */
 export interface Unordered {
@@ -202,14 +182,14 @@ export interface Unordered {
 }
 /**
  * Construct an Unordered strategy
- * @since 1.18.0
+ * @since 1.20.0
  * @category MergeStrategy
  */
 export declare const Unordered: (concurrency: number) => Unordered;
 /**
  * Strategy which will merge Fx in an ordered fashion with
  * the specified level of concurrency.
- * @since 1.18.0
+ * @since 1.20.0
  * @category MergeStrategy
  */
 export interface Ordered {
@@ -218,1803 +198,1413 @@ export interface Ordered {
 }
 /**
  * Construct an Ordered strategy
- * @since 1.18.0
+ * @since 1.20.0
  * @category MergeStrategy
  */
 export declare const Ordered: (concurrency: number) => Ordered;
 /**
- * An Fx which will immediately end producing 0 events and 0 errors.
- * @since 1.18.0
- * @category constructors
+ * Type-alias for a Effect.forkIn(scope) that returns a Fiber
+ * @since 1.20.0
+ * @category models
  */
-export declare const empty: Fx<never, never, never>;
+export type ScopedFork = <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, never, Fiber.Fiber<E, A>>;
 /**
- * Construct an Fx<never, E, A> from a Cause<E>
- * @since 1.18.0
- * @category constructors
+ * Type-alias for Effect.forkIn(scope) which runs the Effect runtime
+ * of an Fx in a Scope. Used in for higher-order operators.
+ *
+ * @since 1.20.0
+ * @category models
  */
-export declare const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never>;
+export type FxFork = <R>(effect: Effect.Effect<R, never, void>) => Effect.Effect<R, never, void>;
 /**
- * Construct an Fx<never, never, never> from a defect
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const die: (defect: unknown) => Fx<never, never, never>;
+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>;
+};
 /**
- * Interrupt the current Fx with the specified FiberId
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const interrupt: (id: FiberId.FiberId) => Fx<never, never, never>;
+export declare const succeed: <A>(value: A) => Fx<never, never, A>;
 /**
- * Construct an Fx which will fail with the specified error.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const fail: <E>(error: E) => Fx<never, E, never>;
+export declare const sync: <A>(f: () => A) => Fx<never, never, A>;
 /**
- * Construct an Fx<R, E, A> from an Effect<R, E, A>
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
+ */
+export declare const fromArray: <const A extends ReadonlyArray<any>>(array: A) => Fx<never, never, A[number]>;
+/**
+ * @since 1.20.0
+ */
+export declare const fromIterable: <A>(iterable: Iterable<A>) => Fx<never, never, A>;
+/**
+ * @since 1.20.0
  */
 export declare const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Fx<R, E, A>;
 /**
- * Construct an Fx from an Iterable
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const fromIterable: {
-    <A extends ReadonlyArray<any>>(array: A): Fx<never, never, A[number]>;
-    <A>(iterable: Iterable<A>): Fx<never, never, A>;
+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>;
 };
 /**
- * Construct an Fx<R, E, A> from an Effect<R, E, A>
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const fromStream: <R, E, A>(effect: Stream.Stream<R, E, A>) => Fx<R, E, A>;
+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>;
+};
 /**
- * Construct an Fx<R, E, A> from an Effect<R, E, A>
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const from: {
-    <A extends ReadonlyArray<any>>(array: A): Fx<never, never, A[number]>;
-    <A>(iterable: Iterable<A>): Fx<never, never, A>;
-    <E>(cause: Cause.Cause<E>): Fx<never, E, never>;
-    <R, E, A>(fx: FxInput<R, E, A>): Fx<R, E, A>;
-    <A>(value: A): Fx<never, never, A>;
+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>;
 };
 /**
- * Construct an Fx by describing an Effectful workflow that has access to a Sink
- * to emit events and errors.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const fromSink: <R, E, A>(f: (sink: Sink.Sink<E, A>) => Effect.Effect<R, E, unknown>) => Fx<R, E, A>;
+export declare const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never>;
 /**
- * Construct an Fx by describing an Scoped Effect that has access to an Emitter
- * to emit events and errors.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const fromEmitter: <R, E, A>(f: (emitter: Emitter<E, A>) => Effect.Effect<R | Scope.Scope, never, unknown>) => Fx<Exclude<R, Scope.Scope>, E, A>;
+export declare const fail: <E>(error: E) => Fx<never, E, never>;
 /**
- * An Fx which will never emit any errors or events, and will never end
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const never: Fx<never, never, never>;
+export declare const die: (error: unknown) => Fx<never, never, never>;
 /**
- * Construct an Fx which will emit the specified value and then end.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const succeed: <A>(value: A) => Fx<never, never, A>;
+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>;
+};
 /**
- * Construct an Fx which will emit the return of a synchronous function and then end.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const sync: <A>(f: () => A) => Fx<never, never, A>;
+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>;
+};
 /**
- * Lazily construct an Fx.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const suspend: <R, E, A>(f: () => Fx<R, E, A>) => Fx<R, E, A>;
+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>;
+};
 /**
- * Helper for constructing your own custom subtypes of an Fx
- * @since 1.18.0
- * @category Subtyping
+ * @since 1.20.0
  */
-export declare abstract class ToFx<R, E, A> extends primitive.ToFx<R, E, A> implements Fx<R, E, A> {
-    /**
-     * Your implementation of an Fx is returned by this function.
-     * @since 1.18.0
-     */
-    abstract toFx(): Fx<R, E, A>;
-}
+export declare const compact: <R, E, A>(fx: Fx<R, E, Option.Option<A>>) => Fx<R, E, A>;
 /**
- * Create an Fx which will emit a value after waiting for a specified duration.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const at: {
-    (delay: DurationInput): <A>(value: A) => Fx<never, never, A>;
-    <A>(value: A, delay: DurationInput): Fx<never, never, A>;
+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>;
 };
 /**
- * Type-alias for a Effect.forkIn(scope) that returns a Fiber
- * @since 1.18.0
- * @category models
+ * @since 1.20.0
  */
-export type ScopedFork = <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, never, Fiber.Fiber<E, A>>;
+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>;
+};
 /**
- * Type-alias for Effect.forkIn(scope) which runs the Effect runtime
- * of an Fx in a Scope. Used in for higher-order operators.
- *
- * @since 1.18.0
- * @category models
+ * @since 1.20.0
  */
-export type FxFork = <R>(effect: Effect.Effect<R, never, void>) => Effect.Effect<R, never, void>;
+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>;
+};
 /**
- * Params for withScopedFork
- * @since 1.18.0
- * @category params
+ * @since 1.20.0
  */
-export type WithScopedForkParams<E, A> = {
-    readonly sink: Sink.Sink<E, A>;
-    readonly fork: ScopedFork;
-    readonly scope: Scope.Scope;
+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>;
 };
 /**
- * Construct an Fx which can fork effects into a Scope.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const withScopedFork: <R, E, A>(f: (params: WithScopedForkParams<E, A>) => Effect.Effect<R, never, unknown>) => Fx<R, E, A>;
+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>;
+};
 /**
- * Params for withEarlyExit
- * @since 1.18.0
- * @category params
+ * @since 1.20.0
  */
-export type WithEarlyExitParams<E, A> = {
-    readonly sink: Sink.WithEarlyExit<E, A>;
-    readonly fork: ScopedFork;
-    readonly scope: Scope.Scope;
+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>;
 };
 /**
- * Construct an Fx which can exit early from a Scope.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const withEarlyExit: <R, E, A>(f: (params: WithEarlyExitParams<E, A>) => Effect.Effect<R, never, unknown>) => Fx<R, E, A>;
+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>;
+};
 /**
- * Params for withFlattenStrategy
- * @since 1.18.0
- * @category params
+ * @since 1.20.0
  */
-export type WithFlattenStrategyParams<E, A> = {
-    readonly sink: Sink.Sink<E, A>;
-    readonly fork: FxFork;
-    readonly scope: Scope.Scope;
+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>;
 };
 /**
- * Construct an Fx which can flatten nested Fx.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const withFlattenStrategy: <R, E, A>(f: (params: WithFlattenStrategyParams<E, A>) => Effect.Effect<R, never, unknown>, strategy: FlattenStrategy) => Fx<R, E, A>;
+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>;
+};
 /**
- * Acquire a resource, use it to construct an Fx, and then release the resource
- * after the Fx has exited.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const acquireUseRelease: {
-    <A, R2, E2, B, R3, E3>(use: (a: A) => FxInput<R2, E2, B>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, unknown>): <R, E>(acquire: Effect.Effect<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, B>;
-    <R, E, A, R2, E2, B, R3, E3>(acquire: Effect.Effect<R, E, A>, use: (a: A) => FxInput<R2, E2, B>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R3, E3, unknown>): Fx<R | R2 | R3, E | E2 | E3, B>;
+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>;
 };
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * as a tuple of values.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const combine: <const FX extends ReadonlyArray<Fx<any, any, any>>>(fxs: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, {
-    readonly [K in keyof FX]: Fx.Success<FX[K]>;
-}>;
+export declare const drain: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, void>;
 /**
- * Combine a record of Fx into a single Fx that will emit the results of all Fx
- * as a record of values.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const struct: <const FX extends Readonly<Record<string, Fx<any, any, any>>>>(fxs: FX) => Fx<Fx.Context<FX[string]>, Fx.Error<FX[string]>, {
-    readonly [K in keyof FX]: Fx.Success<FX[K]>;
-}>;
+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>;
+};
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * as they occur.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const merge: <const FX extends ReadonlyArray<Fx<any, any, any>>>(fxs: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
+export declare const toReadonlyArray: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>;
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * as they occur, but only allowing `n` concurrent Fx to run at a time.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const mergeConcurrently: {
-    (concurrency: number): <const FX extends ReadonlyArray<Fx<any, any, any>>>(fxs: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
-    <const FX extends ReadonlyArray<Fx<any, any, any>>>(fxs: FX, concurrency: number): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
+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>;
 };
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * in the order the Fx were provided. All Fx will be executed concurrently,
- * and the results will be buffered if necessary to preserve ordering.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const mergeBuffer: <const FX extends ReadonlyArray<Fx<any, any, any>>>(fxs: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
+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>;
+};
 /**
- * Combine multiple Fx into a single Fx that will emit the results of all Fx
- * in the order the Fx were provided. All Fx will be executed concurrently, limited
- * by the provided concurrency, and the results will be buffered if necessary to preserve ordering.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const mergeBufferConcurrently: {
-    (concurrency: number): <const FX extends ReadonlyArray<Fx<any, any, any>>>(fxs: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
-    <const FX extends ReadonlyArray<Fx<any, any, any>>>(fxs: FX, concurrency: number): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
+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>;
 };
 /**
- * Merge together multiple Fx into a single Fx that will emit the results of all Fx
- * allowing only 1 Fx to run at a time.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const mergeSwitch: <const FX extends readonly Fx<any, any, any>[]>(fxs: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
+export declare const skipRepeats: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
 /**
- * Merge together multiple Fx into a single Fx that will emit the results of the
- * first Fx to emit a value.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const race: <const FX extends ReadonlyArray<Fx<any, any, any>>>(fxs: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
+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>;
+};
 /**
- * Schedule an Effect to run using the provided Schedule, emitting its success of failure
- * at the intervals specified by the Schedule.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const fromScheduled: {
-    <R2>(scheduled: Schedule.Schedule<R2, unknown, unknown>): <R, E, A>(fx: Effect.Effect<R, E, A>) => Fx<R | R2, E, A>;
-    <R, E, A, R2>(fx: Effect.Effect<R, E, A>, scheduled: Schedule.Schedule<R2, unknown, unknown>): Fx<R | R2, E, A>;
-};
+export declare const empty: Fx<never, never, never>;
 /**
- * Schedule an Effect to run at the specified duration.
- *
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const periodic: {
-    (duration: DurationInput): <R, E, A>(fx: Effect.Effect<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Effect.Effect<R, E, A>, duration: DurationInput): Fx<R, E, A>;
-};
+export declare const never: Fx<never, never, never>;
 /**
- * Consume a Dequeue as soon as values become available and emit them as a Fx.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const fromDequeue: {
-    <A>(dequeue: Queue.Dequeue<A>): Fx<never, never, A>;
-    <I, A>(dequeue: Context.Dequeue<I, A>): Fx<I, never, A>;
+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>;
 };
 /**
- * Consume a PubSub as soon as values become available and emit them as a Fx.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const fromPubSub: {
-    <A>(PubSub: PubSub.PubSub<A>): Fx<Scope.Scope, never, A>;
-    <I, A>(PubSub: Context.PubSub<I, A>): Fx<Scope.Scope | I, never, A>;
+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>;
 };
 /**
- * Run an Fx to completion with the provided Sink. The
- * Effect will resolve with the first Error of the Fx.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export declare const run: {
-    <E, A, R2>(sink: Sink.WithContext<R2, E, A>): <R>(fx: Fx<R, E, A>) => Effect.Effect<R | R2, never, unknown>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, sink: Sink.WithContext<R2, E, A>): Effect.Effect<R | R2, never, unknown>;
+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>;
 };
 /**
- * Observe an Fx with the provided success value handler. The
- * Effect will resolve with the first Error of the Fx.
- *
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export declare const observe: {
-    <A, R2, E2>(onSuccees: (a: A) => Effect.Effect<R2, E2, unknown>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R | R2, E | E2, void>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, onSuccees: (a: A) => Effect.Effect<R2, E2, unknown>): Effect.Effect<R | R2, E | E2, void>;
+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>;
 };
 /**
- * Run an Fx to completion. The Effect will resolve with the first Error of the Fx.
- *
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export declare const drain: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, void>;
+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>;
+};
 /**
- * Reduce an Fx to a single value.
- * @since 1.18.0
- * @category running
+ * @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>;
+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>;
 };
 /**
- * Run an Fx to completion, collecting all emitted values into an Array.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export declare const toArray: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, Array<A>>;
+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>;
+};
 /**
- * Run an Fx to completion, collecting all emitted values into a ReadonlyArray.
- * @since 1.18.0
- * @category running
+ * @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 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>;
+};
 /**
- * Run an Fx to completion, collecting all emitted values into a Chunk.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export declare const toChunk: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>;
+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>;
+};
 /**
- * Consume an Fx and place its values into an Enqueue.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export declare const toEnqueue: {
-    <A, B>(enqueue: Queue.Enqueue<A | B>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, void>;
-    <I, A, B>(enqueue: Context.Enqueue<I, A | B>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<I | R, E, void>;
-    <R, E, A, B>(fx: Fx<R, E, A>, enqueue: Queue.Enqueue<A | B>): Effect.Effect<R, E, void>;
-    <R, E, I, A, B>(fx: Fx<R, E, A>, enqueue: Context.Enqueue<I, A | B>): Effect.Effect<R, E, void>;
+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>;
 };
 /**
- * Map over the success value of an Fx.
- * @since 1.18.0
- * @category combinators
+ * @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>;
+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>;
 };
 /**
- * Map over both failure and success values of an Fx.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const mapBoth: {
-    <E, E2, A, B>(options: {
-        readonly onFailure: (e: E) => E2;
-        readonly onSuccess: (a: A) => B;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R, E2, B>;
-    <R, E, A, E2, B>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (e: E) => E2;
-        readonly onSuccess: (a: A) => B;
-    }): Fx<R, E2, B>;
+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>;
 };
 /**
- * Filter the success value of an Fx.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const filter: {
-    <A, B extends A>(f: (a: A) => a is B): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, B>;
-    <A>(f: (a: A) => boolean): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A, B extends A>(fx: Fx<R, E, A>, f: (a: A) => a is B): Fx<R, E, B>;
-    <R, E, A>(fx: Fx<R, E, A>, f: (a: A) => boolean): Fx<R, E, A>;
+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>;
 };
 /**
- * Filter and map the success value of an Fx.
- * @since 1.18.0
- * @category combinators
+ * @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>;
+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>;
 };
 /**
- * Unwrap Options by filtering any None values.
- * @since 1.18.0
- * @category combinators
+ * @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 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>;
+};
 /**
- * Map over the Cause  of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export declare const mapErrorCause: {
-    <E, E2>(f: (a: 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: (a: Cause.Cause<E>) => Cause.Cause<E2>): Fx<R, E2, A>;
+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>;
 };
 /**
- * Map over the Error of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export declare const mapError: {
-    <E, E2>(f: (a: E) => E2): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>;
-    <R, E, A, E2>(fx: Fx<R, E, A>, f: (a: E) => E2): Fx<R, E2, A>;
+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>;
 };
 /**
- * Filter the Cause of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export declare const filterErrorCause: {
-    <E, E2 extends E>(f: (a: Cause.Cause<E>) => a is Cause.Cause<E2>): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>;
-    <E>(f: (a: Cause.Cause<E>) => boolean): <R, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, E2 extends E, A>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => a is Cause.Cause<E2>): Fx<R, E2, A>;
-    <R, E, A>(fx: Fx<R, E, A>, f: (a: Cause.Cause<E>) => boolean): Fx<R, E, A>;
+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>;
 };
 /**
- * Filter and map the Cause of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export declare const filterMapCause: {
-    <E, E2>(f: (a: 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: (a: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): Fx<R, E2, A>;
-};
+export declare const fromFxEffect: <R, E, R2, E2, B>(effect: Effect.Effect<R, E, Fx<R2, E2, B>>) => Fx<R | R2, E | E2, B>;
 /**
- * Filter the Error of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export declare const filterError: {
-    <E, E2 extends E>(f: (a: E) => a is E2): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A>;
-    <E>(f: (a: E) => boolean): <R, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, E2 extends E, A>(fx: Fx<R, E, A>, f: (a: E) => a is E2): Fx<R, E2, A>;
-    <R, E, A>(fx: Fx<R, E, A>, f: (a: E) => boolean): Fx<R, E, A>;
+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>;
 };
 /**
- * Filter and map the error of an Fx.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export declare const filterMapError: {
-    <E, E2>(f: (a: 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: (a: E) => Option.Option<E2>): Fx<R, E2, A>;
+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>;
 };
 /**
- * Filter and map the error of an Fx using an Effect.
- * @since 1.18.0
- * @category errors
+ * @since 1.20.0
  */
-export declare const filterMapErrorEffect: {
-    <E, R2, E2, B>(f: (e: E) => Effect.Effect<R2, E2, Option.Option<B>>): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2 | B, A>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, Option.Option<B>>): Fx<R | R2, E2 | B, A>;
+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>;
 };
 /**
- * Map the success value of an Fx to another Fx, flattening the result
- * with the provided FlattenStrategy.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const flatMapWithStrategy: {
-    <A, R2, E2, B>(f: (a: A) => FxInput<R2, E2, B>, strategy: FlattenStrategy): <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) => FxInput<R2, E2, B>, strategy: FlattenStrategy): Fx<R | R2, E | E2, B>;
-};
+export declare const suspend: <R, E, A>(f: () => Fx<R, E, A>) => Fx<R, E, A>;
 /**
- * Map the success value of an Fx to another Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const switchMap: {
-    <A, R2 = never, E2 = never, B = never>(f: (a: A) => FxInput<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>;
+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]>>;
 };
 /**
- * Map the success value of an Fx to another Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const switchLatest: {
-    <R, E, R2, E2, B>(fx: Fx<R, E, FxInput<R2, E2, B>>): Fx<R | R2, E | E2, B>;
+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>;
 };
 /**
- * Map the success value of an Fx to another Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const exhaustMap: {
-    <A, R2 = never, E2 = never, B = never>(f: (a: A) => FxInput<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>;
-};
+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]>>;
 /**
- * Flatten a nested Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const exhaust: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A>;
+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]>>;
 /**
- * Map the success value of an Fx to another Fx, prefering the first
- * until completion, and then running the last emitted Fx if they are not
- * the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const exhaustMapLatest: {
-    <A, R2 = never, E2 = never, B = never>(f: (a: A) => FxInput<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>;
-};
+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]>>;
 /**
- * Flatten a nested Fx, prefering the first until completion, and then running the last emitted Fx if they are not
- * the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const exhaustLatest: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A>;
+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]>>;
 /**
- * Map the success value of an Fx to another Fx with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const flatMap: {
-    <A, R2 = never, E2 = never, B = never>(f: (a: A) => FxInput<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>;
+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>;
 };
 /**
- * Map the success value of an Fx to another Fx with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const flatten: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A>;
+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>;
+};
 /**
- * Map the success value of an Fx to another Fx with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const flatMapConcurrently: {
-    <A, R2 = never, E2 = never, B = never>(f: (a: A) => FxInput<R2, E2, B>, concurrency: number): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>, concurrency: number): Fx<R | R2, E | E2, B>;
+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>;
 };
 /**
- * Map the success value of an Fx to another Fx one at a time.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const concatMap: {
-    <A, R2 = never, E2 = never, B = never>(f: (a: A) => FxInput<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>;
+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>;
 };
 /**
- * Skip and take a number of values from an Fx.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export declare const slice: {
-    (skip: number, take: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, skip: number, take: number): Fx<R, E, A>;
+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>;
 };
 /**
- * Take a number of values from an Fx.
- *
- * @since 1.18.0
- * @category slicing
+ * @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>;
+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>;
 };
 /**
- * Drop a number of values from an Fx.
- *
- * @since 1.18.0
- * @category slicing
+ * @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>;
+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>;
 };
 /**
- * Take values from an Fx while the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export declare const takeWhile: {
-    <A, R2, E2>(predicate: (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>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
+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>;
 };
 /**
- * Take values from an Fx until the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export declare const takeUntil: {
-    <A, R2, E2>(predicate: (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>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
+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>;
 };
 /**
- * Drop values from an Fx while the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export declare const dropWhile: {
-    <A, R2, E2>(predicate: (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>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
+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>;
 };
 /**
- * Drop values from an Fx until the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export declare const dropUntil: {
-    <A, R2, E2>(predicate: (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>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
+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>;
 };
 /**
- * Drop values from an Fx after the predicate returns true.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export declare const dropAfter: {
-    <A, R2, E2>(predicate: (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>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
+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>;
 };
 /**
- * Concatenate an Fx after the successful completion of another Fx
- *
- * @since 1.18.0
- * @category combinators
+ * @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>;
+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>;
 };
 /**
- * Concatenate an Fx after the failure of another Fx
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const orElse: {
-    <E, R2, E2, B>(f: (cause: Cause.Cause<E>) => FxInput<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, A>): Fx<R | R2, E2, A | B>;
+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>;
 };
 /**
- * Map the success value of an Fx to an Effect, doesn't fork any fibers like flatMap* etc.
- *
- * @since 1.18.0
- * @category combinators
+ * @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>;
+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>;
 };
 /**
- * Perform an Effect for each value emitted by an Fx, not affecting the output of the Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const tap: {
-    <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>): Fx<R | R2, E | E2, A>;
+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>;
 };
 /**
- * Filter the success value of an Fx with an Effect.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const filterEffect: {
-    <A, R2, E2>(predicate: (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>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
+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>;
 };
 /**
- * Filter and map the success value of an Fx with an Effect.
- *
- * @since 1.18.0
- * @category combinators
+ * @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>;
-};
+export declare const scoped: <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, Scope.Scope>, E, A>;
 /**
- * Apply a function to the constructed Effect that represents the running Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const middleware: {
-    <R, E, A, R2>(f: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R2, never, unknown>, g?: (sink: Sink.Sink<E, A>) => Sink.Sink<E, A>): (fx: Fx<R, E, A>) => Fx<R2, E, A>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, f: (effect: Effect.Effect<R, never, unknown>) => Effect.Effect<R2, never, unknown>, g?: (sink: Sink.Sink<E, A>) => Sink.Sink<E, A>): Fx<R2, E, A>;
+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>;
 };
 /**
- * Accumulate a value over the success values of an Fx and atomically produce derived value.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const loop: {
-    <A, B, 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>;
+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>;
 };
 /**
- * Emit values with their previously emitted values when possible.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const withPrevious: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, readonly [previous: Option.Option<A>, current: A]>;
+export declare const interruptible: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
 /**
- * Accumulate a value over the success values of an Fx and atomically produce derived value
- * useing an Effect. A SynchronizedRef is utilized to ensure ordering of events.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const loopEffect: {
-    <B, A, R2, E2, 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, B, R2, E2, 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>;
-};
+export declare const uninterruptible: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
 /**
- * Prepends a value to the beginning of an Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const startWith: {
-    <B>(value: B): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B>;
-    <R, E, A, B>(fx: Fx<R, E, A>, value: B): Fx<R, E, A | B>;
+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>;
 };
 /**
- * Appends a value to the end of an Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const endWith: {
-    <B>(value: B): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B>;
-    <R, E, A, B>(fx: Fx<R, E, A>, value: B): Fx<R, E, A | B>;
+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>;
 };
 /**
- * Run a reducer over the success values of an Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const scan: {
-    <A, B>(seed: B, f: (acc: 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: (acc: B, a: A) => B): Fx<R, E, B>;
+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>;
 };
 /**
- * Run an Effect-ful reducer over the success values of an Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const scanEffect: {
-    <A, B, R2, E2>(seed: B, f: (acc: B, a: A) => Effect.Effect<R2, E2, B>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B>;
-    <R, E, A, B, R2, E2>(fx: Fx<R, E, A>, seed: B, f: (acc: B, a: A) => Effect.Effect<R2, E2, B>): Fx<R | R2, E | E2, B>;
+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>;
 };
 /**
- * Map the failures of an Fx to another Fx, flattening the result
- * with the provided FlattenStrategy.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const flatMapCauseWithStrategy: {
-    <E, R2 = never, E2 = never, B = never>(f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>, strategy: FlattenStrategy): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>, strategy: FlattenStrategy): Fx<R | R2, E2, A | B>;
+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>;
 };
 /**
- * Map the failures of an Fx to another Fx, flattening the result
- * with the provided FlattenStrategy.
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const flatMapErrorWithStrategy: {
-    <E, R2 = never, E2 = never, B = never>(f: (error: E) => FxInput<R2, E2, B>, strategy: FlattenStrategy): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (error: E) => FxInput<R2, E2, B>, strategy: FlattenStrategy): Fx<R | R2, E2, A | B>;
+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>;
 };
 /**
- * Map the failures of an Fx to another Fx, flattening the result with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const flatMapCause: {
-    <E, R2 = never, E2 = never, B = never>(f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
+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>;
 };
 /**
- * Map the failures of an Fx to another Fx, flattening the result with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const flatMapError: {
-    <E, R2 = never, E2 = never, B = never>(f: (error: E) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (error: E) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
+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>;
 };
 /**
- * Map the failures of an Fx to another Fx with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const flatMapCauseConcurrently: {
-    <E, R2 = never, E2 = never, B = never>(f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>, concurrency: number): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>, concurrency: number): Fx<R | R2, E2, A | B>;
+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>;
 };
 /**
- * Map the failures of an Fx to another Fx with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const flatMapErrorConcurrently: {
-    <E, R2 = never, E2 = never, B = never>(f: (error: E) => FxInput<R2, E2, B>, concurrency: number): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (error: E) => FxInput<R2, E2, B>, concurrency: number): Fx<R | R2, E2, A | B>;
+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>;
 };
 /**
- * Map the failures of an Fx to another Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const switchMapCause: {
-    <E, R2 = never, E2 = never, B = never>(f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
+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>;
 };
 /**
- * Map the failures of an Fx to another Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const switchMapError: {
-    <E, R2 = never, E2 = never, B = never>(f: (error: E) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (error: E) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
+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>;
 };
 /**
- * Map the failures of an Fx to another Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const exhaustMapCause: {
-    <E, R2 = never, E2 = never, B = never>(f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
+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>;
 };
 /**
- * Map the failures of an Fx to another Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const exhaustMapError: {
-    <E, R2 = never, E2 = never, B = never>(f: (error: E) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (error: E) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
+export declare const withSpan: {
+    (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>;
+    }): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, A>;
+    <R, E, A>(self: Fx<R, E, A>, 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>;
 };
 /**
- * Map the failures of an Fx to another Fx, prefering the first
- * until completion, and then running the last emitted Fx if they are not
- * the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const exhaustMapLatestCause: {
-    <E, R2 = never, E2 = never, B = never>(f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
+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>;
 };
 /**
- * Map the failures of an Fx to another Fx,  prefering the first
- * until completion, and then running the last emitted Fx if they are not
- * the same Fx.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const exhaustMapLatestError: {
-    <E, R2 = never, E2 = never, B = never>(f: (error: E) => FxInput<R2, E2, B>): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, A>, f: (error: E) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
+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>;
 };
 /**
- * Map over the failures and successes of an Fx, flattening both using the same strategy.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const matchCauseWithStrategy: {
-    <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-        readonly strategy: FlattenStrategy;
-    }): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-        readonly strategy: FlattenStrategy;
-    }): Fx<R | R2, E2 | E3, B | C>;
-};
-/**
- * Map over the failures and successes of an Fx, flattening both using the same strategy.
- *
- * @since 1.18.0
- * @category flattening
- */
-export declare const matchErrorWithStrategy: {
-    <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-        readonly strategy: FlattenStrategy;
-    }): <R, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2, B | A>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-        readonly strategy: FlattenStrategy;
-    }): Fx<R | R2, E2 | E3, B | C>;
-};
-/**
- * Map over the failures and successes of an Fx, flattening both with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
- */
-export declare const matchCause: {
-    <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): Fx<R | R2 | R3, E2 | E3, B | C>;
+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>;
 };
 /**
- * Map over the failures and successes of an Fx, flattening both with unbounded concurrency.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const match: {
-    <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): Fx<R | R2 | R3, E2 | E3, B | C>;
+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>;
 };
 /**
- * Map over the failures and successes of an Fx, flattening both with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
- */
-export declare const matchCauseConcurrently: {
-    <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-        readonly concurrency: number;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-        readonly concurrency: number;
-    }): Fx<R | R2 | R3, E2 | E3, B | C>;
-};
-/**
- * Map over the failures and successes of an Fx, flattening both with the specified concurrency.
- *
- * @since 1.18.0
- * @category flattening
- */
-export declare const matchErrorConcurrently: {
-    <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-        readonly concurrency: number;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-        readonly concurrency: number;
-    }): Fx<R | R2 | R3, E2 | E3, B | C>;
-};
-/**
- * Map over the failures and successes of an Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- *
- * @since 1.18.0
- * @category flattening
+ * @since 1.20.0
  */
-export declare const switchMatchCause: {
-    <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): Fx<R | R2 | R3, E2 | E3, B | C>;
-};
-/**
- * Map over the failures and successes of an Fx, switching to the latest
- * Fx emitted and interrupting the previous.
- *
- * @since 1.18.0
- * @category flattening
- */
-export declare const switchMatch: {
-    <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): Fx<R | R2 | R3, E2 | E3, B | C>;
+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>;
 };
 /**
- * Map over the failures and successes of an Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- *
- * @since 1.18.0
- * @category flattening
- */
-export declare const exhaustMatchCause: {
-    <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): Fx<R | R2 | R3, E2 | E3, B | C>;
-};
-/**
- * Map over the failures and successes of an Fx, prefering the first
- * Fx emitted and dropping any subsequent Fx until it has completed.
- *
- * @since 1.18.0
- * @category flattening
- */
-export declare const exhaustMatch: {
-    <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): Fx<R | R2 | R3, E2 | E3, B | C>;
-};
-/**
- * Map over the failures and successes of an Fx, prefering the first
- * Fx emitted and starting the latest Fx when the first completes
- * if they are not the same Fx.
- *
- * @since 1.18.0
- * @category flattening
- */
-export declare const exhaustLatestMatchCause: {
-    <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (cause: Cause.Cause<E>) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): Fx<R | R2 | R3, E2 | E3, B | C>;
-};
-/**
- * Map over the failures and successes of an Fx, prefering the first
- * Fx emitted and starting the latest Fx when the first completes
- * if they are not the same Fx.
- *
- * @since 1.18.0
- * @category flattening
- */
-export declare const exhaustLatestMatch: {
-    <E, R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R2 | R3 | R, E2 | E3, B | C>;
-    <R, E, A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): Fx<R | R2 | R3, E2 | E3, B | C>;
-};
-/**
- * Listen to the events of an Fx within the provided window. When the window Fx
- * emits the inner stream, the fx will begin allowing events to pass through,
- * and when the inner stream emits, the fx will be interrupted.
- *
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export declare const during: {
-    <R2, E2, R3, E3>(window: Fx<R2, E2, Fx<R3, E3, unknown>>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E | E2 | E3, A>;
-    <R, E, A, R2, E2, R3, E3>(fx: Fx<R, E, A>, window: Fx<R2, E2, Fx<R3, E3, unknown>>): Fx<R | R2 | R3, E | E2 | E3, A>;
+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>;
 };
 /**
- * Listen to the events of an Fx after the provided window emits.
- *
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export declare const since: {
-    <R2, E2>(window: Fx<R2, E2, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, window: Fx<R2, E2, unknown>): Fx<R | R2, E | E2, A>;
+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>;
 };
 /**
- * Listen to the events of an Fx until the provided window emits.
- *
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export declare const until: {
-    <R2, E2>(window: Fx<R2, E2, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, window: Fx<R2, E2, unknown>): Fx<R | R2, E | E2, A>;
-};
+export declare const multicast: <R, E, A>(fx: Fx<R, E, A>) => Fx<Scope.Scope | R, E, A>;
 /**
- * Provide the environment to an Fx.
- *
- * @since 1.18.0
- * @category context
+ * @since 1.20.0
  */
-export declare const provide: {
-    <R2, E2, S>(layer: Layer.Layer<R2, E2, S>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, S>, E2 | E, A>;
-    <R2>(runtime: Runtime.Runtime<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>;
-    <R2>(context: Context.Context<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>;
-    <R, E, A, R2, E2, S>(fx: Fx<R, E, A>, layer: Layer.Layer<R2, E2, S>): Fx<Exclude<R, S> | R2, E | E2, A>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, runtime: Runtime.Runtime<R2>): Fx<Exclude<R, R2>, E, A>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, context: Context.Context<R2>): Fx<Exclude<R, R2>, E, A>;
+export declare const hold: <R, E, A>(fx: Fx<R, E, A>) => Fx<Scope.Scope | R, E, A>;
+/**
+ * @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>;
 };
 /**
- * Provide a service to an Fx using a Tag.
- * @since 1.18.0
- * @category context
+ * @since 1.20.0
  */
-export declare const provideService: {
-    <I, S>(tag: Context.Tag<I, S>, service: 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>, tag: Context.Tag<I, S>, service: S): Fx<Exclude<R, I>, E, A>;
+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>;
 };
 /**
- * Provide a service using an Effect to an Fx using a Tag.
- *
- * @since 1.18.0
- * @category context
+ * @since 1.20.0
  */
-export declare const provideServiceEffect: {
-    <I, S, R2, E2>(tag: Context.Tag<I, S>, service: Effect.Effect<R2, E2, S>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | Exclude<R, I>, E, A>;
-    <R, E, A, I, S, R2, E2>(fx: Fx<R, E, A>, tag: Context.Tag<I, S>, service: Effect.Effect<R2, E2, S>): Fx<R2 | Exclude<R, I>, E, A>;
+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>;
 };
 /**
- * Skip repeated values, using the provided Equivalence to compare values.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export declare const skipRepeatsWith: {
-    <A>(eq: Equivalence<A>): <R, E>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, eq: Equivalence<A>): Fx<R, E, A>;
+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>;
 };
 /**
- * Skip repeated values, using @effect/data/Equal for value comparison.
- *
- * @since 1.18.0
- * @category slicing
+ * @since 1.20.0
  */
-export declare const skipRepeats: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+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>;
+};
 /**
- * Sample the values of an Fx, or Effect, during the events of another Fx.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const snapshot: {
-    <R2 = never, E2 = never, B = never, A = never, R3 = never, E3 = never, C = never>(sampled: FxInput<R2, E2, B>, f: (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 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(fx: Fx<R, E, A>, sampled: FxInput<R2, E2, B>, f: (a: A, b: B) => Effect.Effect<R3, E3, C>): Fx<R | R2 | R3, E | E2 | E3, C>;
+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>;
 };
 /**
- * Share the output of an Fx, or Effect, with other Fx's using the behavior of the
- * provided Subject.
- *
- * @since 1.18.0
- * @category sharing
+ * @since 1.20.0
  */
-export declare const share: <R, E, A, R2>(fx: Fx<R, E, A>, subject: Subject<R2, E, A>) => Fx<R | R2, E, A>;
+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>;
+};
 /**
- * Effeciently share an underlying stream with multiple subscribers.
- *
- * @since 1.18.0
- * @category sharing
+ * @since 1.20.0
  */
-export declare const multicast: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+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>;
+};
 /**
- * Effeciently share an underlying stream with multiple subscribers, saving the most
- * recent event and emitting it to new subscribers.
- *
- * @since 1.18.0
- * @category sharing
+ * @since 1.20.0
  */
-export declare const hold: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+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>;
+};
 /**
- * Effeciently share an underlying stream with multiple subscribers,
- * saving up to the most recent `n` events and emitting them to new subscribers.
- *
- * @since 1.18.0
- * @category sharing
+ * @since 1.20.0
  */
-export declare const replay: {
-    (capacity: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, capacity: number): Fx<R, E, A>;
+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>;
 };
 /**
- * Create an Fx which will wait a specified duration of time where no
- * events have occurred before emitting a value.
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export declare const debounce: {
-    (delay: DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, delay: DurationInput): Fx<R, E, A>;
+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>;
 };
 /**
- * Create an Fx which will wait a specified duration of time before emitting
- * an event after the last event.
- * @since 1.18.0
- * @category time slicing
+ * @since 1.20.0
  */
-export declare const throttle: {
-    (delay: DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, delay: DurationInput): Fx<R, E, A>;
+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>;
 };
 /**
- * Create an Fx which will wait a specified duration of time where no
- * events have occurred before emitting a value.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const delay: {
-    (delay: DurationInput): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, delay: DurationInput): Fx<R, E, A>;
+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>;
 };
 /**
- * Run an Effect to produce an Fx to run.
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const fromFxEffect: <R, E, R2, E2, B>(fxEffect: Effect.Effect<R, E, Fx<R2, E2, B>>) => Fx<R | R2, E | E2, B>;
+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>;
+};
 /**
- * Extract the context from an EffectGen
- * @since 1.18.0
+ * @since 1.20.0
  */
-export type EffectGenContext<T> = [T] extends [never] ? never : [T] extends [Effect.EffectGen<infer R, any, any>] ? R : never;
+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>;
+};
 /**
- * Extract the error from an EffectGen
- * @since 1.18.0
+ * @since 1.20.0
  */
-export type EffectGenError<T> = [T] extends [never] ? never : [T] extends [Effect.EffectGen<any, infer E, any>] ? E : never;
+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>;
+};
 /**
- * Extract the success value from an EffectGen
- * @since 1.18.0
+ * @since 1.20.0
  */
-export type EffectGenSuccess<T> = [T] extends [never] ? never : [T] extends [Effect.EffectGen<any, any, infer A>] ? A : never;
+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>;
+};
 /**
- * Utilize Effect.gen to construct an Fx
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare function gen<Yield extends Effect.EffectGen<any, any, any>, R, E, A>(f: (_: Effect.Adapter) => Generator<Yield, Fx<R, E, A>, any>): Fx<R | EffectGenContext<Yield>, E | EffectGenError<Yield>, A>;
+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>;
+};
 /**
- * Utilize Effect.gen to construct an Fx
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare function genScoped<Yield extends Effect.EffectGen<any, any, any>, R, E, A>(f: (_: Effect.Adapter) => Generator<Yield, Fx<R, E, A>, any>): Fx<Exclude<R | EffectGenContext<Yield>, Scope.Scope>, E | EffectGenError<Yield>, A>;
+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>;
+};
 /**
- * Run an Effect when an Fx exits
- * @since 1.18.0
- * @category lifecycles
+ * @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<R | 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>;
+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>;
 };
 /**
- * Run an Effect when an Fx is interrupted
- * @since 1.18.0
- * @category lifecycles
+ * @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<R | 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>;
+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>;
 };
 /**
- * Run an Effect when an Fx ends with an error
- * @since 1.18.0
- * @category lifecycles
+ * @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<R | 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>;
+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>;
 };
 /**
- * Provide a Scope to an Fx
- * @since 1.18.0
- * @category context
+ * @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 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>;
+};
 /**
- * Annotate the logs of an Fx
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const annotateLogs: {
-    (key: string, value: unknown): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    (values: Record<string, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, key: string, value: unknown): Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, values: Record<string, unknown>): Fx<R, E, A>;
+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>;
 };
 /**
- * Annotate the spans of an Fx
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const annotateSpans: {
-    (key: string, value: unknown): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    (values: Record<string, unknown>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, key: string, value: unknown): Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, values: Record<string, unknown>): Fx<R, E, A>;
+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>;
 };
 /**
- * Create an Fx which will succeed with Option.None
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const succeedNone: <A = never>() => Fx<never, never, Option.Option<A>>;
+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>;
+};
 /**
- * Create an Fx which will succeed with Option.Some
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const succeedSome: <A>(value: A) => Fx<never, never, Option.Option<A>>;
+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>;
+};
 /**
- * Do simulation
- * @since 1.18.0
- * @category Do
+ * @since 1.20.0
  */
-export declare const Do: Fx<never, never, {}>;
+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>;
+};
 /**
- * Do simulation
- * @since 1.18.0
- * @category Do
+ * @since 1.20.0
  */
-export declare const bind: {
-    <N extends string, A extends object, R2, E2, B>(name: Exclude<N, keyof A>, f: (a: A) => Fx<R2, E2, B>): <R1, E1>(self: Fx<R1, E1, A>) => Fx<R2 | R1, E2 | E1, {
-        [K in N | keyof A]: K extends keyof A ? A[K] : B;
-    }>;
-    <R1, E1, A1 extends object, N extends string, R2, E2, B>(self: Fx<R1, E1, A1>, name: Exclude<N, keyof A1>, f: (a: A1) => Fx<R2, E2, B>): Fx<R1 | R2, E1 | E2, {
-        [K in N | keyof A1]: K extends keyof A1 ? A1[K] : B;
-    }>;
+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>;
 };
 /**
- * Do simulation
- * @since 1.18.0
- * @category Do
+ * @since 1.20.0
  */
-export declare const bindTo: {
-    <N extends string>(name: N): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, {
-        [K in N]: A;
-    }>;
-    <R, E, A, N extends string>(self: Fx<R, E, A>, name: N): Fx<R, E, {
-        [K_1 in N]: A;
-    }>;
-};
-declare const let_: {
-    <N extends string, A extends object, B>(name: Exclude<N, keyof A>, f: (a: A) => B): <R1, E1>(self: Fx<R1, E1, A>) => Fx<R1, E1, {
-        [K in N | keyof A]: K extends keyof A ? A[K] : B;
-    }>;
-    <R1, E1, A1 extends object, N extends string, B>(self: Fx<R1, E1, A1>, name: Exclude<N, keyof A1>, f: (a: A1) => B): Fx<R1, E1, {
-        [K in N | keyof A1]: K extends keyof A1 ? A1[K] : B;
-    }>;
+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>;
 };
-export { 
 /**
- * Do simulation
- * @since 1.18.0
- * @category Do
+ * @since 1.20.0
  */
-let_ as let };
+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>;
+};
 /**
- * Ensure a finalizer runs on Fx ext.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const ensuring: {
-    <R2>(finalizer: Effect.Effect<R2, never, unknown>): <R, E, A>(self: Fx<R, E, A>) => Fx<R2 | R, E, A>;
-    <R, E, A, R2>(self: Fx<R, E, A>, finalizer: Effect.Effect<R2, never, unknown>): Fx<R | R2, E, A>;
+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>;
 };
 /**
- * Capture the errors and success values as Exit
- * @since 1.18.0
- * @category combinators
+ * @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 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>;
+};
 /**
- * Capture the errors and success values as Either
- * @since 1.18.0
- * @category combinators
+ * @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 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>;
+};
 /**
- * Run an Fx until finding a value which satisfies the predicate.
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export declare const findFirst: {
-    <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R2 | R, E2 | E, Option.Option<A>>;
-    <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Effect.Effect<R | R2, E | E2, Option.Option<A>>;
+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>;
+    readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined;
 };
 /**
- * Grab the first value emitted by an Fx
- * @since 1.18.0
- * @category running
+ * @since 1.20.0
  */
-export declare const first: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, Option.Option<A>>;
+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>;
+    readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined;
+};
 /**
- * Transform success values into failures and failures into successes.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const flip: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, A, E>;
+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>;
+};
 /**
- * Lift a nullable value into an Fx
- * @since 1.18.0
- * @category constructors
+ * @since 1.20.0
  */
-export declare const fromNullable: <A>(value: void | A | null | undefined) => Fx<never, never, NonNullable<A>>;
-declare const if_: {
-    <R2, E2, B, R3, E3, C>(onTrue: Fx<R2, E2, B>, onFalse: Fx<R3, E3, C>): {
-        <R, E>(bool: Fx<R, E, boolean>): Fx<R2 | R3 | R, E2 | E3 | E, B | C>;
-        (bool: boolean): Fx<R2 | R3, E2 | E3, B | C>;
-    };
-    <R, E, R2, E2, B, R3, E3, C>(bool: Fx<R, E, boolean>, onTrue: Fx<R2, E2, B>, onFalse: Fx<R3, E3, C>): Fx<R | R2 | R3, E | E2 | E3, B | C>;
-    <R2, E2, B, R3, E3, C>(bool: boolean, onTrue: Fx<R2, E2, B>, onFalse: Fx<R3, E3, C>): Fx<R2 | R3, E2 | E3, B | C>;
+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>;
 };
-export { 
 /**
- * Logical if/else using Fx.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-if_ as if };
+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>;
+};
 /**
- * Logical if/else using static values.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const when: {
-    <B, C>(onTrue: B, onFalse: C): {
-        <R, E>(bool: Fx<R, E, boolean>): Fx<R, E, B | C>;
-        (bool: boolean): Fx<never, never, B | C>;
-    };
-    <R, E, B, C>(bool: Fx<R, E, boolean>, onTrue: B, onFalse: C): Fx<R, E, B | C>;
-    <B, C>(bool: boolean, onTrue: B, onFalse: C): Fx<never, never, B | C>;
+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>;
 };
 /**
- * Mark an Fx as interruptible
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const interruptible: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+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>;
+};
 /**
- * Mark an Fx as uninterruptible
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const uninterruptible: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
+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>;
+};
 /**
- * Locally set the value of a FiberRef
- * @since 1.18.0
- * @category FiberRef
+ * @since 1.20.0
  */
-export declare const locally: {
-    <A>(self: FiberRef<A>, value: A): <R, E, B>(use: Fx<R, E, B>) => Fx<R, E, B>;
-    <R, E, B, A>(use: Fx<R, E, B>, self: FiberRef<A>, value: A): Fx<R, E, B>;
+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>;
 };
 /**
- * Locally set the value of a FiberRef by updating the current value
- * @since 1.18.0
- * @category FiberRef
+ * @since 1.20.0
  */
-export declare const locallyWith: {
-    <A>(self: FiberRef<A>, f: (a: A) => A): <R, E, B>(use: Fx<R, E, B>) => Fx<R, E, B>;
-    <R, E, B, A>(use: Fx<R, E, B>, self: FiberRef<A>, f: (a: A) => A): Fx<R, E, B>;
+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>;
 };
 /**
- * Enable/disable tracer timing for an Fx
- * @since 1.18.0
- * @category tracing
+ * @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>;
+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>;
 };
 /**
- * Configure the concurreny limit of Fibers running within an Fx
- * @since 1.18.0
- * @category concurrency
+ * @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>;
+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>;
 };
 /**
- * Add a span to your log messages
- * @since 1.18.0
- * @category logging
+ * @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>;
+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>;
 };
 /**
- * Configure the maximum number of operations to run before yielding to the runtime
- * @since 1.18.0
- * @category concurrency
+ * @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>;
+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>;
 };
 /**
- * Set the parent Span of an Fx
- * @since 1.18.0
- * @category tracing
+ * @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>;
-};
+export declare const exit: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Exit.Exit<E, A>>;
 /**
- * Enable/disable request batching within an Fx
- * @since 1.18.0
- * @category batching
+ * @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>;
-};
+export declare const either: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, never, Either.Either<E, A>>;
 /**
- * Set the request cache Effects running within an Fx
- * @since 1.18.0
- * @category batching
+ * @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>;
-};
+export declare const tuple: <const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX) => Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, {
+    readonly [K in keyof FX]: Fx.Success<FX[K]>;
+}>;
 /**
- * Enable/disable request caching within an Fx
- * @since 1.18.0
- * @category batching
+ * @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>;
+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]>, {
+    readonly [K in keyof FX]: Fx.Success<FX[K]>;
+}>;
+/**
+ * @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]>, {
+        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]>, {
+        readonly [K in keyof FX]: Fx.Success<FX[K]>;
+    }>;
 };
 /**
- * Configure the scheduler to use within an Fx
- * @since 1.18.0
- * @category concurrency
+ * @since 1.20.0
  */
-export declare const withScheduler: {
-    (scheduler: Scheduler): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-    <R, E, A>(fx: Fx<R, E, A>, scheduler: Scheduler): Fx<R, E, A>;
+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>;
 };
 /**
- * Set the span of an Fx
- * @since 1.18.0
- * @category tracing
+ * @since 1.20.0
  */
-export declare const withSpan: {
-    (name: string, options?: {
-        readonly attributes?: Record<string, unknown>;
-        readonly links?: ReadonlyArray<Tracer.SpanLink>;
-        readonly parent?: Tracer.ParentSpan;
-        readonly root?: boolean;
-        readonly context?: Context.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?: {
-        readonly attributes?: Record<string, unknown>;
-        readonly links?: ReadonlyArray<Tracer.SpanLink>;
-        readonly parent?: Tracer.ParentSpan;
-        readonly root?: boolean;
-        readonly context?: Context.Context<never>;
-    }): Fx<R, E, A>;
+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>;
 };
 /**
- * Set the tracer used within an Fx
- * @since 1.18.0
- * @category tracing
+ * @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>;
+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>;
 };
 /**
- * Partition an Fx into two Fx's based on a either-returning function.
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
  */
-export declare const partitionMap: {
-    <A, B, C>(f: (a: A) => Either.Either<B, C>): <R, E>(self: Fx<R, E, A>) => readonly [Fx<R, E, B>, Fx<R, E, C>];
-    <R, E, A, B, C>(self: Fx<R, E, A>, f: (a: A) => Either.Either<B, C>): readonly [Fx<R, E, B>, Fx<R, E, C>];
+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>;
 };
 /**
- * Convert a list of keyed values into persistent workflows for given each key of the list
- * even when the list has been re-ordered.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
+ */
+export interface KeyedOptions<A, B, R2, E2, C> {
+    readonly getKey: (a: A) => B;
+    readonly onValue: (ref: RefSubject<never, never, A>, key: B) => Fx<R2, E2, C>;
+    readonly debounce?: Duration.DurationInput;
+}
+/**
+ * @since 1.20.0
  */
 export declare const keyed: {
-    <A, B, R2, E2, C>(getKey: (a: A) => B, f: (ref: RefSubject<never, never, A>, key: B) => FxInput<R2, E2, C>): <R, E>(fx: Fx<R, E, ReadonlyArray<A>>) => Fx<R | R2, E | E2, ReadonlyArray<C>>;
-    <R, E, A, B, R2, E2, C>(fx: Fx<R, E, ReadonlyArray<A>>, getKey: (a: A) => B, f: (ref: RefSubject<never, never, A>, key: B) => FxInput<R2, E2, C>): Fx<R | R2, E | E2, ReadonlyArray<C>>;
+    <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>>;
 };
 /**
- * Map an Fx of values into workflows similar to Fx.switchMap, but
- * instead of providing the value directly, it is exposed as a RefSubject to
- * allow creating a persistent workflows similar to Fx.keyed but for a single value.
- *
- * @since 1.18.0
- * @category combinators
+ * @since 1.20.0
+ */
+export interface WithKeyOptions<A, B, R2, E2, C> {
+    readonly getKey: (a: A) => B;
+    readonly onValue: (ref: RefSubject<never, never, A>, key: B) => Fx<R2, E2, C>;
+}
+/**
+ * @since 1.20.0
  */
 export declare const withKey: {
-    <A, B, R2, E2, C>(getKey: (a: A) => B, f: (ref: RefSubject<never, never, A>, key: B) => FxInput<R2, E2, C>): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, C>;
-    <R, E, A, B, R2, E2, C>(fx: Fx<R, E, A>, getKey: (a: A) => B, f: (ref: RefSubject<never, never, A>, key: B) => FxInput<R2, E2, C>): Fx<R | R2, E | E2, C>;
+    <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>;
 };
 /**
  * Match over a tagged union of values into a set of persistent workflows
  * that allow listening to changes of values with the same tag using the same
  * Fx.
  *
- * @since 1.18.0
+ * @since 1.20.0
  * @category combinators
  */
 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<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>, E | Fx.Error<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>, Fx.Success<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>>;
+    }, 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 {
         readonly _tag: string;
-    }, Matchers extends DefaultMatchersFrom<A>>(fx: Fx<R, E, A>, matchers: Matchers): Fx<R | Fx.Context<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>, E | Fx.Error<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>, Fx.Success<Fx.FromInput<ReturnType<Matchers[keyof Matchers]>>>>;
+    }, 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]>>>;
 };
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export type DefaultMatchersFrom<A extends {
     readonly _tag: string;
 }> = {
     readonly [Tag in A["_tag"]]: (value: RefSubject<never, never, Extract<A, {
         readonly _tag: Tag;
-    }>>) => FxInput<any, any, any>;
+    }>>) => Fx<any, any, any>;
 };
 /**
- * @since 1.18.0
- */
-export declare const drainLayer: <FXS extends ReadonlyArray<Fx<any, never, any>>>(...fxs: FXS) => Layer.Layer<Exclude<Fx.Context<FXS[number]>, Scope.Scope>, never, never>;
-/**
- * @since 1.18.0
- */
-export declare function isFx<R = unknown, E = unknown, A = unknown>(u: unknown): u is Fx<R, E, A>;
-/**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export declare const matchOption: {
-    <A, R2 = never, E2 = never, B = never, R3 = never, E3 = never, C = never>(onNone: () => FxInput<R2, E2, B>, onSome: (a: RefSubject<never, never, A>) => FxInput<R3, E3, C>): <R, E>(fx: Fx<R, E, Option.Option<A>>) => Fx<R | R2, E | E2, 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: () => FxInput<R2, E2, B>, onSome: (a: RefSubject<never, never, A>) => FxInput<R3, E3, C>): Fx<R | R2, E | E2, B | C>;
+    <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>;
 };
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export declare const getOrElse: {
-    <A, R2 = never, E2 = never, B = never>(orElse: () => FxInput<R2, E2, B>): <R, E>(fx: Fx<R, E, Option.Option<A>>) => Fx<R | R2, E | E2, A | B>;
-    <R, E, A, R2 = never, E2 = never, B = never>(fx: Fx<R, E, Option.Option<A>>, orElse: () => FxInput<R2, E2, B>): Fx<R | R2, E | E2, A | B>;
+    <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>;
 };
 /**
- * @since 1.18.0
+ * @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>) => FxInput<R2, E2, B>, onRight: (a: RefSubject<never, never, A>) => FxInput<R3, E3, C>): <R, E>(fx: Fx<R, E, Either.Either<E1, A>>) => Fx<R | R2, E | E2, 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>) => FxInput<R2, E2, B>, onRight: (a: RefSubject<never, never, A>) => FxInput<R3, E3, C>): Fx<R | R2, E | E2, B | C>;
+    <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>;
 };
 /**
- * @since 1.18.0
+ * @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>;
+};
+/**
+ * @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>;
+/**
+ * @since 1.20.0
  */
 export declare const fork: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<E, void>>;
 /**
- * @since 1.18.0
+ * @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>>;
 /**
- * @since 1.18.0
+ * @since 1.20.0
  */
 export declare const forkDaemon: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, never, Fiber.RuntimeFiber<E, void>>;
 /**
- * @since 1.18.0
+ * @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>>;
 };
 /**
- * @since 1.18.0
+ * @since 1.20.0
+ */
+export declare const fromAsyncIterable: <A>(iterable: AsyncIterable<A>) => Fx<never, never, 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>];
+};
+/**
+ * @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>>;
+/**
+ * @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>>;
+/**
+ * @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>;
+};
+/**
+ * @since 1.20.0
+ */
+export declare const first: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, A>;
+/**
+ * @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>;
+};
+/**
+ * @since 1.20.0
  */
 export declare const mergeRace: {
-    <R2, E2, B>(other: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R2 | R, E2 | E, B | A>;
-    <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, other: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>;
+    <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>;
+};
+/**
+ * @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]>>;
+/**
+ * @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>;
+};
+/**
+ * @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>;
+};
+/**
+ * @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>;
+};
+/**
+ * @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>;
+};
+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>;
+};
+export { 
+/**
+ * @since 1.20.0
+ */
+if_ as if };
+/**
+ * @since 1.20.0
+ */
+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: {
+        readonly onTrue: B;
+        readonly onFalse: C;
+    }): Fx<R | Scope.Scope, E, B | C>;
 };
 /**
+ * @since 1.20.0
+ */
+export declare const withEmitter: <E, A, R = never>(f: (emitter: Emitter.Emitter<E, A>) => Effect.Effect<R, E, unknown>) => Fx<Scope.Scope | R, E, A>;
+/**
+ * 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 abstract class FxEffectBase<R, E, A, R2, E2, B> extends internalProtos.FxEffectBase<R, E, A, R2, E2, B> implements Fx<R, E, A>, Effect.Effect<R2, E2, B> {
+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>;
+};
+/**
+ * @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>;
+};
+/**
+ * @since 1.20.0
+ */
+export declare const flip: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, A, E>;
+/**
+ * @since 1.20.0
+ */
+export declare const fromNullable: <A>(value: void | A | null | undefined) => Fx<never, never, NonNullable<A>>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @since 1.20.0
+ */
+export declare abstract class FxEffectBase<R, E, A, R2, E2, B> extends protos.FxEffectBase<R, E, A, R2, E2, B> {
+    private _fx;
+    /**
+     * @since 1.20.0
+     */
+    run<R3>(sink: Sink.Sink<R3, E, A>): Effect.Effect<R | R3, never, void>;
     /**
-     * @since 1.18.0
+     * @since 1.20.0
      */
-    protected abstract toFx(): Fx<R, E, A>;
+    abstract toFx(): Fx<R, E, A>;
     /**
-     * @since 1.18.0
+     * @since 1.20.0
      */
-    protected abstract toEffect(): Effect.Effect<R2, E2, B>;
+    abstract toEffect(): Effect.Effect<R2, E2, B>;
 }
 //# sourceMappingURL=Fx.d.ts.map