@typed/fx 1.22.2 → 1.24.0

package/dist/dts/internal/core.d.ts

@@ -12,213 +12,213 @@ import * as Scope from "effect/Scope";
 import * as Tracer from "effect/Tracer";
 import type { FlattenStrategy, Fx, MergeStrategy } from "../Fx.js";
 import * as Sink from "../Sink.js";
-export declare function make<A>(run: (sink: Sink.Sink<never, never, A>) => Effect.Effect<never, never, unknown>): Fx<never, never, A>;
-export declare function make<E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<never, never, unknown>): Fx<never, E, A>;
-export declare function make<R, E, A>(run: (sink: Sink.Sink<never, E, A>) => Effect.Effect<R, never, unknown>): Fx<R, E, A>;
-export declare const succeed: <A>(value: A) => Fx<never, never, A>;
-export declare const fromSync: <A>(f: () => A) => Fx<never, never, A>;
-export declare const fromArray: <const A extends readonly any[]>(array: A) => Fx<never, never, A[number]>;
-export declare const fromIterable: <A>(iterable: Iterable<A>) => Fx<never, never, A>;
-export declare const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Fx<R, E, A>;
-export declare const fromScheduled: <R, E, I, R2, O>(input: Effect.Effect<R, E, I>, schedule: Schedule.Schedule<R2, I, O>) => Fx<R | R2, E, O>;
-export declare const schedule: <R, E, A, R2, O>(input: Effect.Effect<R, E, A>, schedule: Schedule.Schedule<R2, unknown, O>) => Fx<R | R2, E, A>;
+export declare function make<A>(run: (sink: Sink.Sink<A>) => Effect.Effect<unknown>): Fx<A>;
+export declare function make<A, E>(run: (sink: Sink.Sink<A, E>) => Effect.Effect<unknown>): Fx<A, E>;
+export declare function make<A, E, R>(run: (sink: Sink.Sink<A, E>) => Effect.Effect<unknown, never, R>): Fx<A, E, R>;
+export declare const succeed: <A>(value: A) => Fx<A, never, never>;
+export declare const fromSync: <A>(f: () => A) => Fx<A, never, never>;
+export declare const fromArray: <const A extends readonly any[]>(array: A) => Fx<A[number], never, never>;
+export declare const fromIterable: <A>(iterable: Iterable<A>) => Fx<A, never, never>;
+export declare const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Fx<A, E, R>;
+export declare const fromScheduled: <R, E, I, R2, O>(input: Effect.Effect<I, E, R>, schedule: Schedule.Schedule<R2, I, O>) => Fx<O, E, R | R2>;
+export declare const schedule: <A, E, R, R2, O>(input: Effect.Effect<A, E, R>, schedule: Schedule.Schedule<R2, unknown, O>) => Fx<A, E, R | R2>;
 export declare const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never>;
 export declare const fail: <E>(error: E) => Fx<never, E, never>;
-export declare const die: (error: unknown) => Fx<never, never, never>;
-export declare const map: <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B) => Fx<R, E, B>;
-export declare const filter: <R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>) => Fx<R, E, A>;
-export declare const filterMap: <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Option.Option<B>) => Fx<R, E, B>;
-export declare const mapEffect: <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 filterMapEffect: <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 filterEffect: <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>) => Fx<R | R2, E | E2, A>;
-export declare const tapEffect: <R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, unknown>) => Fx<R | R2, E | E2, A>;
-export declare const loop: <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 withPrevious: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, readonly [Option.Option<A>, A]>;
-export declare const filterMapLoop: <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>;
-export declare const loopEffect: <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>;
-export declare const filterMapLoopEffect: <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>;
-export declare const observe: <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>;
-export declare const drain: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, void>;
-export declare const reduce: <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 toReadonlyArray: <R, E, A>(fx: Fx<R, E, A>) => Effect.Effect<R, E, readonly A[]>;
-export declare const slice: <R, E, A>(fx: Fx<R, E, A>, drop: number, take: number) => Fx<R, E, A>;
-export declare const take: <R, E, A>(fx: Fx<R, E, A>, n: number) => Fx<R, E, A>;
-export declare const drop: <R, E, A>(fx: Fx<R, E, A>, n: number) => Fx<R, E, A>;
-export declare function skipRepeatsWith<R, E, A>(fx: Fx<R, E, A>, eq: Equivalence.Equivalence<A>): Fx<R, E, A>;
-export declare function skipRepeats<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A>;
-export declare const empty: Fx<never, never, never>;
-export declare const never: Fx<never, never, never>;
-export declare function padWith<R, E, A, B, C>(fx: Fx<R, E, A>, start: Iterable<B>, end: Iterable<C>): Fx<R, E, A | B | C>;
-export declare function prependAll<R, E, A, B>(fx: Fx<R, E, A>, start: Iterable<B>): Fx<R, E, A | B>;
-export declare function appendAll<R, E, A, C>(fx: Fx<R, E, A>, end: Iterable<C>): Fx<R, E, A | C>;
-export declare function prepend<R, E, A, B>(fx: Fx<R, E, A>, start: B): Fx<R, E, A | B>;
-export declare function append<R, E, A, C>(fx: Fx<R, E, A>, end: C): Fx<R, E, A | C>;
-export declare function scan<R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (b: B, a: A) => B): Fx<R, E, B>;
-export declare function flatMapWithStrategy<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>;
-export declare function switchMap<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
-export declare function switchMapEffect<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
-export declare function exhaustMap<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
-export declare function exhaustMapEffect<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
-export declare function exhaustMapLatest<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
-export declare function exhaustMapLatestEffect<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
-export declare function exhaustFilterMapLatestEffect<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
-export declare function flatMapConcurrently<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
-export declare function concatMap<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
-export declare function flatMapConcurrentlyEffect<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
-export declare function flatMap<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
-export declare function flatMapEffect<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E | E2, B>;
-export declare function fromFxEffect<R, E, R2, E2, B>(effect: Effect.Effect<R, E, Fx<R2, E2, B>>): Fx<R | R2, E | E2, B>;
-export declare function gen<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(f: (_: Effect.Adapter) => Generator<Y, FX, any>): Fx<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Effect.Effect.Error<Y["value"]> | Fx.Error<FX>, Fx.Success<FX>>;
-export declare function genScoped<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(f: (_: Effect.Adapter) => Generator<Y, FX, any>): Fx<Exclude<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Scope.Scope>, Effect.Effect.Error<Y["value"]> | Fx.Error<FX>, Fx.Success<FX>>;
-export declare function continueWith<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 function orElseCause<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>;
-export declare function orElse<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (error: E) => Fx<R2, E2, B>): Fx<R | R2, E2, A | B>;
-export declare function suspend<R, E, A>(f: () => Fx<R, E, A>): Fx<R, E, A>;
-export declare function mergeWithStrategy<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]>>;
-export declare function merge<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, other: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>;
-export declare function mergeAll<FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
-export declare function mergeOrdered<FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
-export declare function mergeOrderedConcurrently<FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX, concurrency: number): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
-export declare function mergeSwitch<FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
-export declare function takeWhile<R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>;
-export declare function takeUntil<R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>;
-export declare function dropWhile<R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>;
-export declare function dropUntil<R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>;
-export declare function dropAfter<R, E, A>(fx: Fx<R, E, A>, f: Predicate.Predicate<A>): Fx<R, E, A>;
-export declare function takeWhileEffect<R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
-export declare function takeUntilEffect<R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
-export declare function dropWhileEffect<R, E, A>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R, E, boolean>): Fx<R, E, A>;
-export declare function dropUntilEffect<R, E, A>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R, E, boolean>): Fx<R, E, A>;
-export declare function dropAfterEffect<R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E | E2, A>;
-export declare function during<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>;
-export declare function since<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, window: Fx<R2, E2, B>): Fx<R | R2 | Scope.Scope, E | E2, A>;
-export declare function until<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, window: Fx<R2, E2, B>): Fx<R | R2 | Scope.Scope, E | E2, A>;
-export declare function middleware<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>): Fx<R3, E, A>;
-export declare function onExit<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 function onInterrupt<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 function onError<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 scoped: <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, Scope.Scope>, E, A>;
-export declare function annotateLogs<R, E, A>(fx: Fx<R, E, A>, key: string | Record<string, unknown>, value?: unknown): Fx<R, E, A>;
-export declare function annotateSpans<R, E, A>(fx: Fx<R, E, A>, key: string | Record<string, unknown>, value?: unknown): Fx<R, E, A>;
-export declare const interruptible: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-export declare const uninterruptible: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-export declare function locally<R, E, B, A>(use: Fx<R, E, B>, self: FiberRef.FiberRef<A>, value: A): Fx<R, E, B>;
-export declare function locallyWith<R, E, B, A>(use: Fx<R, E, B>, self: FiberRef.FiberRef<A>, f: (a: A) => A): Fx<R, E, B>;
-export declare function withTracerTiming<R, E, A>(fx: Fx<R, E, A>, enabled: boolean): Fx<R, E, A>;
-export declare function withConcurrency<R, E, A>(fx: Fx<R, E, A>, concurrency: number | "unbounded"): Fx<R, E, A>;
-export declare function withConfigProvider<R, E, A>(fx: Fx<R, E, A>, configProvider: ConfigProvider.ConfigProvider): Fx<R, E, A>;
-export declare function withLogSpan<R, E, A>(fx: Fx<R, E, A>, span: string): Fx<R, E, A>;
-export declare function withMaxOpsBeforeYield<R, E, A>(fx: Fx<R, E, A>, maxOps: number): Fx<R, E, A>;
-export declare function withParentSpan<R, E, A>(fx: Fx<R, E, A>, parentSpan: Tracer.ParentSpan): Fx<R, E, A>;
-export declare function withRequestBatching<R, E, A>(fx: Fx<R, E, A>, requestBatching: boolean): Fx<R, E, A>;
-export declare function withRequestCache<R, E, A>(fx: Fx<R, E, A>, cache: Request.Cache): Fx<R, E, A>;
-export declare function withRequestCaching<R, E, A>(fx: Fx<R, E, A>, requestCaching: boolean): Fx<R, E, A>;
-export declare function withScheduler<R, E, A>(fx: Fx<R, E, A>, scheduler: Scheduler.Scheduler): Fx<R, E, A>;
-export declare function withTracer<R, E, A>(fx: Fx<R, E, A>, tracer: Tracer.Tracer): Fx<R, E, A>;
-export declare function acquireUseRelease<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>;
-export declare function withSpan<R, E, A>(self: Fx<R, E, A>, name: string, options?: {
+export declare const die: (error: unknown) => Fx<never>;
+export declare const map: <A, E, R, B>(fx: Fx<A, E, R>, f: (a: A) => B) => Fx<B, E, R>;
+export declare const filter: <A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>) => Fx<A, E, R>;
+export declare const filterMap: <A, E, R, B>(fx: Fx<A, E, R>, f: (a: A) => Option.Option<B>) => Fx<B, E, R>;
+export declare const mapEffect: <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>) => Fx<B, E | E2, R | R2>;
+export declare const filterMapEffect: <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>) => Fx<B, E | E2, R | R2>;
+export declare const filterEffect: <A, E, R, R2, E2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>) => Fx<A, E | E2, R | R2>;
+export declare const tapEffect: <A, E, R, R2, E2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<unknown, E2, R2>) => Fx<A, E | E2, R | R2>;
+export declare const loop: <A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => readonly [C, B]) => Fx<C, E, R>;
+export declare const withPrevious: <A, E, R>(fx: Fx<A, E, R>) => Fx<readonly [Option.Option<A>, A], E, R>;
+export declare const filterMapLoop: <A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => readonly [Option.Option<C>, B]) => Fx<C, E, R>;
+export declare const loopEffect: <A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => Effect.Effect<readonly [C, B], E2, R2>) => Fx<C, E | E2, R | R2>;
+export declare const filterMapLoopEffect: <A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>) => Fx<C, E | E2, R | R2>;
+export declare const observe: <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>) => Effect.Effect<void, E | E2, R | R2>;
+export declare const drain: <A, E, R>(fx: Fx<A, E, R>) => Effect.Effect<void, E, R>;
+export declare const reduce: <A, E, R, B>(fx: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => B) => Effect.Effect<B, E, R>;
+export declare const toReadonlyArray: <A, E, R>(fx: Fx<A, E, R>) => Effect.Effect<readonly A[], E, R>;
+export declare const slice: <A, E, R>(fx: Fx<A, E, R>, drop: number, take: number) => Fx<A, E, R>;
+export declare const take: <A, E, R>(fx: Fx<A, E, R>, n: number) => Fx<A, E, R>;
+export declare const drop: <A, E, R>(fx: Fx<A, E, R>, n: number) => Fx<A, E, R>;
+export declare function skipRepeatsWith<A, E, R>(fx: Fx<A, E, R>, eq: Equivalence.Equivalence<A>): Fx<A, E, R>;
+export declare function skipRepeats<A, E, R>(fx: Fx<A, E, R>): Fx<A, E, R>;
+export declare const empty: Fx<never>;
+export declare const never: Fx<never>;
+export declare function padWith<A, E, R, B, C>(fx: Fx<A, E, R>, start: Iterable<B>, end: Iterable<C>): Fx<A | B | C, E, R>;
+export declare function prependAll<A, E, R, B>(fx: Fx<A, E, R>, start: Iterable<B>): Fx<A | B, E, R>;
+export declare function appendAll<A, E, R, C>(fx: Fx<A, E, R>, end: Iterable<C>): Fx<A | C, E, R>;
+export declare function prepend<A, E, R, B>(fx: Fx<A, E, R>, start: B): Fx<A | B, E, R>;
+export declare function append<A, E, R, C>(fx: Fx<A, E, R>, end: C): Fx<A | C, E, R>;
+export declare function scan<A, E, R, B>(fx: Fx<A, E, R>, seed: B, f: (b: B, a: A) => B): Fx<B, E, R>;
+export declare function flatMapWithStrategy<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, strategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function switchMap<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function switchMapEffect<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function exhaustMap<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function exhaustMapEffect<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function exhaustMapLatest<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function exhaustMapLatestEffect<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function exhaustFilterMapLatestEffect<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function flatMapConcurrently<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function concatMap<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function flatMapConcurrentlyEffect<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>, capacity: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function flatMap<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function flatMapEffect<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<B, E | E2, R | R2 | Scope.Scope>;
+export declare function fromFxEffect<B, E, R, E2, R2>(effect: Effect.Effect<Fx<B, E2, R2>, E, R>): Fx<B, E | E2, R | R2>;
+export declare function gen<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(f: (_: Effect.Adapter) => Generator<Y, FX, any>): Fx<Fx.Success<FX>, Effect.Effect.Error<Y["value"]> | Fx.Error<FX>, Effect.Effect.Context<Y["value"]> | Fx.Context<FX>>;
+export declare function genScoped<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(f: (_: Effect.Adapter) => Generator<Y, FX, any>): Fx<Fx.Success<FX>, Effect.Effect.Error<Y["value"]> | Fx.Error<FX>, Exclude<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Scope.Scope>>;
+export declare function continueWith<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: () => Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>;
+export declare function orElseCause<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>): Fx<A | B, E2, R | R2>;
+export declare function orElse<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (error: E) => Fx<B, E2, R2>): Fx<A | B, E2, R | R2>;
+export declare function suspend<A, E, R>(f: () => Fx<A, E, R>): Fx<A, E, R>;
+export declare function mergeWithStrategy<const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX, stategy: MergeStrategy): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
+export declare function merge<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, other: Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>;
+export declare function mergeAll<FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
+export declare function mergeOrdered<FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
+export declare function mergeOrderedConcurrently<FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX, concurrency: number): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
+export declare function mergeSwitch<FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
+export declare function takeWhile<A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>;
+export declare function takeUntil<A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>;
+export declare function dropWhile<A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>;
+export declare function dropUntil<A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>;
+export declare function dropAfter<A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>;
+export declare function takeWhileEffect<A, E, R, R2, E2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>;
+export declare function takeUntilEffect<A, E, R, R2, E2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>;
+export declare function dropWhileEffect<A, E, R>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E, R>): Fx<A, E, R>;
+export declare function dropUntilEffect<A, E, R>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E, R>): Fx<A, E, R>;
+export declare function dropAfterEffect<A, E, R, R2, E2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>;
+export declare function during<A, E, R, B, E2, R2, E3, R3>(fx: Fx<A, E, R>, window: Fx<Fx<B, E3, R3>, E2, R2>): Fx<A, E | E2 | E3, R | R2 | R3 | Scope.Scope>;
+export declare function since<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, window: Fx<B, E2, R2>): Fx<A, E | E2, R | R2 | Scope.Scope>;
+export declare function until<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, window: Fx<B, E2, R2>): Fx<A, E | E2, R | R2 | Scope.Scope>;
+export declare function middleware<A, E, R, R3>(fx: Fx<A, E, R>, effect: (effect: Effect.Effect<unknown, never, R>) => Effect.Effect<unknown, never, R3>, sink?: (sink: Sink.Sink<A, E>) => Sink.Sink<A, E, R>): Fx<A, E, R3>;
+export declare function onExit<A, E, R, R2>(fx: Fx<A, E, R>, f: (exit: Exit.Exit<unknown>) => Effect.Effect<unknown, never, R2>): Fx<A, E, R | R2>;
+export declare function onInterrupt<A, E, R, R2>(fx: Fx<A, E, R>, f: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect.Effect<unknown, never, R2>): Fx<A, E, R | R2>;
+export declare function onError<A, E, R, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<never>) => Effect.Effect<unknown, never, R2>): Fx<A, E, R | R2>;
+export declare const scoped: <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, Exclude<R, Scope.Scope>>;
+export declare function annotateLogs<A, E, R>(fx: Fx<A, E, R>, key: string | Record<string, unknown>, value?: unknown): Fx<A, E, R>;
+export declare function annotateSpans<A, E, R>(fx: Fx<A, E, R>, key: string | Record<string, unknown>, value?: unknown): Fx<A, E, R>;
+export declare const interruptible: <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+export declare const uninterruptible: <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
+export declare function locally<B, E, R, A>(use: Fx<B, E, R>, self: FiberRef.FiberRef<A>, value: A): Fx<B, E, R>;
+export declare function locallyWith<B, E, R, A>(use: Fx<B, E, R>, self: FiberRef.FiberRef<A>, f: (a: A) => A): Fx<B, E, R>;
+export declare function withTracerTiming<A, E, R>(fx: Fx<A, E, R>, enabled: boolean): Fx<A, E, R>;
+export declare function withConcurrency<A, E, R>(fx: Fx<A, E, R>, concurrency: number | "unbounded"): Fx<A, E, R>;
+export declare function withConfigProvider<A, E, R>(fx: Fx<A, E, R>, configProvider: ConfigProvider.ConfigProvider): Fx<A, E, R>;
+export declare function withLogSpan<A, E, R>(fx: Fx<A, E, R>, span: string): Fx<A, E, R>;
+export declare function withMaxOpsBeforeYield<A, E, R>(fx: Fx<A, E, R>, maxOps: number): Fx<A, E, R>;
+export declare function withParentSpan<A, E, R>(fx: Fx<A, E, R>, parentSpan: Tracer.ParentSpan): Fx<A, E, R>;
+export declare function withRequestBatching<A, E, R>(fx: Fx<A, E, R>, requestBatching: boolean): Fx<A, E, R>;
+export declare function withRequestCache<A, E, R>(fx: Fx<A, E, R>, cache: Request.Cache): Fx<A, E, R>;
+export declare function withRequestCaching<A, E, R>(fx: Fx<A, E, R>, requestCaching: boolean): Fx<A, E, R>;
+export declare function withScheduler<A, E, R>(fx: Fx<A, E, R>, scheduler: Scheduler.Scheduler): Fx<A, E, R>;
+export declare function withTracer<A, E, R>(fx: Fx<A, E, R>, tracer: Tracer.Tracer): Fx<A, E, R>;
+export declare function acquireUseRelease<A, E, R, B, E2, R2, C, E3, R3>(acquire: Effect.Effect<A, E, R>, use: (a: A) => Fx<B, E2, R2>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<C, E3, R3>): Fx<B, E | E2 | E3, R | R2 | R3>;
+export declare function withSpan<A, E, R>(self: Fx<A, E, R>, name: string, options?: {
     readonly attributes?: Record<string, unknown>;
     readonly links?: ReadonlyArray<Tracer.SpanLink>;
     readonly parent?: Tracer.ParentSpan;
     readonly root?: boolean;
     readonly context?: Context.Context<never>;
-}): Fx<R, E, A>;
-export declare function provideContext<R, E, A, R2>(fx: Fx<R, E, A>, context: Context.Context<R2>): Fx<Exclude<R, R2>, E, A>;
-export declare function provideLayer<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>;
-export declare function provideRuntime<R, E, A, R2>(fx: Fx<R, E, A>, runtime: Runtime.Runtime<R2>): Fx<Exclude<R, R2>, E, A>;
-export declare function provideService<R, E, A, I, S>(fx: Fx<R, E, A>, service: Context.Tag<I, S>, instance: S): Fx<Exclude<R, I>, E, A>;
-export declare function provideServiceEffect<R, E, A, I, S, R2, E2>(fx: Fx<R, E, A>, service: Context.Tag<I, S>, instance: Effect.Effect<R2, E2, S>): Fx<Exclude<R, I> | R2, E | E2, A>;
-export declare function provide<R, E, A, R2 = never, E2 = never, S = never>(fx: Fx<R, E, A>, provide: Layer.Layer<R2, E2, S> | Context.Context<S> | Runtime.Runtime<S>): Fx<Exclude<R, S> | R2, E | E2, A>;
-export declare function mapCause<R, E, A, E2>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Fx<R, E2, A>;
-export declare function mapError<R, E, A, E2>(fx: Fx<R, E, A>, f: (e: E) => E2): Fx<R, E2, A>;
-export declare function filterCause<R, E, A>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => boolean): Fx<R, E, A>;
-export declare function filterError<R, E, A>(fx: Fx<R, E, A>, f: (e: E) => boolean): Fx<R, E, A>;
-export declare function filterMapCause<R, E, A, E2>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): Fx<R, E2, A>;
-export declare function filterMapError<R, E, A, E2>(fx: Fx<R, E, A>, f: (e: E) => Option.Option<E2>): Fx<R, E2, A>;
-export declare function mapCauseEffect<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>;
-export declare function mapErrorEffect<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>;
-export declare function filterCauseEffect<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>;
-export declare function filterErrorEffect<R, E, A, R2, E2>(fx: Fx<R, E, A>, f: (e: E) => Effect.Effect<R2, E2, boolean>): Fx<R | R2, E2, A>;
-export declare function filterMapCauseEffect<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>;
-export declare function filterMapErrorEffect<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>;
-export declare function loopCause<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>;
-export declare function loopError<R, E, A, B, C>(fx: Fx<R, E, A>, seed: B, f: (b: B, e: E) => readonly [C, B]): Fx<R, C, A>;
-export declare function loopCauseEffect<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>;
-export declare function loopErrorEffect<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>;
-export declare function filterMapLoopCause<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>;
-export declare function filterMapLoopError<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>;
-export declare function filterMapLoopCauseEffect<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>;
-export declare function filterMapLoopErrorEffect<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>;
-export declare function flatMapCauseWithStrategy<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>;
-export declare function flatMapErrorWithStrategy<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>;
-export declare function switchMapCause<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E2, A | B>;
-export declare function switchMapError<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E2, A | B>;
-export declare function flatMapCause<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E2, A | B>;
-export declare function flatMapError<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E2, A | B>;
-export declare function flatMapCauseConcurrently<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): Fx<R | R2 | Scope.Scope, E2, A | B>;
-export declare function flatMapErrorConcurrently<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>, concurrency: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E2, A | B>;
-export declare function exhaustMapCause<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E2, A | B>;
-export declare function exhaustMapError<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E2, A | B>;
-export declare function exhaustMapLatestCause<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E2, A | B>;
-export declare function exhaustMapLatestError<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (e: E) => Fx<R2, E2, B>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<R | R2 | Scope.Scope, E2, A | B>;
-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>;
+}): Fx<A, E, R>;
+export declare function provideContext<A, E, R, R2>(fx: Fx<A, E, R>, context: Context.Context<R2>): Fx<A, E, Exclude<R, R2>>;
+export declare function provideLayer<A, E, R, S, E2, R2>(fx: Fx<A, E, R>, layer: Layer.Layer<S, E2, R2>): Fx<A, E | E2, R2 | Exclude<R, S>>;
+export declare function provideRuntime<A, E, R, R2>(fx: Fx<A, E, R>, runtime: Runtime.Runtime<R2>): Fx<A, E, Exclude<R, R2>>;
+export declare function provideService<A, E, R, I, S>(fx: Fx<A, E, R>, service: Context.Tag<I, S>, instance: S): Fx<A, E, Exclude<R, I>>;
+export declare function provideServiceEffect<A, E, R, I, S, R2, E2>(fx: Fx<A, E, R>, service: Context.Tag<I, S>, instance: Effect.Effect<S, E2, R2>): Fx<A, E | E2, Exclude<R, I> | R2>;
+export declare function provide<A, E, R, R2 = never, E2 = never, S = never>(fx: Fx<A, E, R>, provide: Layer.Layer<S, E2, R2> | Context.Context<S> | Runtime.Runtime<S>): Fx<A, E | E2, Exclude<R, S> | R2>;
+export declare function mapCause<A, E, R, E2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Fx<A, E2, R>;
+export declare function mapError<A, E, R, E2>(fx: Fx<A, E, R>, f: (e: E) => E2): Fx<A, E2, R>;
+export declare function filterCause<A, E, R>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => boolean): Fx<A, E, R>;
+export declare function filterError<A, E, R>(fx: Fx<A, E, R>, f: (e: E) => boolean): Fx<A, E, R>;
+export declare function filterMapCause<A, E, R, E2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): Fx<A, E2, R>;
+export declare function filterMapError<A, E, R, E2>(fx: Fx<A, E, R>, f: (e: E) => Option.Option<E2>): Fx<A, E2, R>;
+export declare function mapCauseEffect<A, E, R, R2, E2, E3>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Effect.Effect<Cause.Cause<E3>, E2, R2>): Fx<A, E2 | E3, R | R2>;
+export declare function mapErrorEffect<A, E, R, R2, E2, E3>(fx: Fx<A, E, R>, f: (e: E) => Effect.Effect<E3, E2, R2>): Fx<A, E2 | E3, R | R2>;
+export declare function filterCauseEffect<A, E, R, R2, E2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Effect.Effect<boolean, E2, R2>): Fx<A, E2, R | R2>;
+export declare function filterErrorEffect<A, E, R, R2, E2>(fx: Fx<A, E, R>, f: (e: E) => Effect.Effect<boolean, E2, R2>): Fx<A, E2, R | R2>;
+export declare function filterMapCauseEffect<A, E, R, R2, E2, E3>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Effect.Effect<Option.Option<Cause.Cause<E3>>, E2, R2>): Fx<A, E2 | E3, R | R2>;
+export declare function filterMapErrorEffect<A, E, R, R2, E2, E3>(fx: Fx<A, E, R>, f: (e: E) => Effect.Effect<Option.Option<E3>, E2, R2>): Fx<A, E2 | E3, R | R2>;
+export declare function loopCause<A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, cause: Cause.Cause<E>) => readonly [Cause.Cause<C>, B]): Fx<A, C, R>;
+export declare function loopError<A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, e: E) => readonly [C, B]): Fx<A, C, R>;
+export declare function loopCauseEffect<A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<readonly [Cause.Cause<C>, B], E2, R2>): Fx<A, E2 | C, R | R2>;
+export declare function loopErrorEffect<A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, e: E) => Effect.Effect<readonly [C, B], E2, R2>): Fx<A, E2 | C, R | R2>;
+export declare function filterMapLoopCause<A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, cause: Cause.Cause<E>) => readonly [Option.Option<Cause.Cause<C>>, B]): Fx<A, C, R>;
+export declare function filterMapLoopError<A, E, R, B, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, e: E) => readonly [Option.Option<C>, B]): Fx<A, C, R>;
+export declare function filterMapLoopCauseEffect<A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, cause: Cause.Cause<E>) => Effect.Effect<readonly [Option.Option<Cause.Cause<C>>, B], E2, R2>): Fx<A, E2 | C, R | R2>;
+export declare function filterMapLoopErrorEffect<A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, seed: B, f: (b: B, e: E) => Effect.Effect<readonly [Option.Option<C>, B], E2, R2>): Fx<A, E2 | C, R | R2>;
+export declare function flatMapCauseWithStrategy<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, flattenStrategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
+export declare function flatMapErrorWithStrategy<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Fx<B, E2, R2>, flattenStrategy: FlattenStrategy, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
+export declare function switchMapCause<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
+export declare function switchMapError<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
+export declare function flatMapCause<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
+export declare function flatMapError<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
+export declare function flatMapCauseConcurrently<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, concurrency: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
+export declare function flatMapErrorConcurrently<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Fx<B, E2, R2>, concurrency: number, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
+export declare function exhaustMapCause<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
+export declare function exhaustMapError<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
+export declare function exhaustMapLatestCause<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
+export declare function exhaustMapLatestError<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Fx<B, E2, R2>, executionStrategy?: ExecutionStrategy.ExecutionStrategy): Fx<A | B, E2, R | R2 | Scope.Scope>;
+export type MatchCauseOptions<E, A, B, E2, R2, C, E3, R3> = {
+    readonly onFailure: (cause: Cause.Cause<E>) => Fx<B, E2, R2>;
+    readonly onSuccess: (a: A) => Fx<C, E3, R3>;
     readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined;
 };
-export declare function matchCauseWithStrategy<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>;
-export type MatchErrorOptions<E, A, R2, E2, B, R3, E3, C> = {
-    readonly onFailure: (e: E) => Fx<R2, E2, B>;
-    readonly onSuccess: (a: A) => Fx<R3, E3, C>;
+export declare function matchCauseWithStrategy<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, flattenStrategy: FlattenStrategy, opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+export type MatchErrorOptions<E, A, B, E2, R2, C, E3, R3> = {
+    readonly onFailure: (e: E) => Fx<B, E2, R2>;
+    readonly onSuccess: (a: A) => Fx<C, E3, R3>;
     readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined;
 };
-export declare function matchErrorWithStrategy<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<R | R2 | R3 | Scope.Scope, E2 | E3, B | C>;
-export declare function matchCause<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>;
-export declare function matchError<R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>;
-export declare function matchCauseConcurrently<R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, concurrency: number, opts: MatchCauseOptions<E, A, R2, E2, B, R3, E3, C>): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>;
-export declare function matchErrorConcurrently<R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, concurrency: number, opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>;
-export declare function switchMatchCause<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>;
-export declare function switchMatchError<R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>;
-export declare function exhaustMatchCause<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>;
-export declare function exhaustMatchError<R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>;
-export declare function exhaustMatchLatestCause<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>;
-export declare function exhaustMatchLatestError<R, E, A, R2, E2, B, R3, E3, C>(fx: Fx<R, E, A>, opts: MatchErrorOptions<E, A, R2, E2, B, R3, E3, C>): Fx<Scope.Scope | R | R2 | R3, E2 | E3, B | C>;
-export declare function tuple<const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, {
+export declare function matchErrorWithStrategy<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, flattenStrategy: FlattenStrategy, { executionStrategy, onFailure, onSuccess }: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>;
+export declare function matchCause<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
+export declare function matchError<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
+export declare function matchCauseConcurrently<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, concurrency: number, opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
+export declare function matchErrorConcurrently<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, concurrency: number, opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
+export declare function switchMatchCause<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
+export declare function switchMatchError<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
+export declare function exhaustMatchCause<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
+export declare function exhaustMatchError<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
+export declare function exhaustMatchLatestCause<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
+export declare function exhaustMatchLatestError<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>;
+export declare function tuple<const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<{
     readonly [K in keyof FX]: Fx.Success<FX[K]>;
-}>;
-export declare function struct<const FX extends Readonly<Record<string, Fx<any, any, any>>>>(fx: FX): Fx<Fx.Context<FX[string]>, Fx.Error<FX[string]>, {
+}, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
+export declare function struct<const FX extends Readonly<Record<string, Fx<any, any, any>>>>(fx: FX): Fx<{
     readonly [K in keyof FX]: Fx.Success<FX[K]>;
-}>;
-export declare function all<const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, {
+}, Fx.Error<FX[string]>, Fx.Context<FX[string]>>;
+export declare function all<const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<{
     readonly [K in keyof FX]: Fx.Success<FX[K]>;
-}>;
-export declare function all<const FX extends Readonly<Record<string, Fx<any, any, any>>>>(fx: FX): Fx<Fx.Context<FX[string]>, Fx.Error<FX[string]>, {
+}, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
+export declare function all<const FX extends Readonly<Record<string, Fx<any, any, any>>>>(fx: FX): Fx<{
     readonly [K in keyof FX]: Fx.Success<FX[K]>;
-}>;
-export declare function exit<R, E, A>(fx: Fx<R, E, A>): Fx<R, never, Exit.Exit<E, A>>;
-export declare function toEnqueue<R, E, A, R2 = never>(fx: Fx<R, E, A>, queue: Context.Enqueue<R2, A> | Queue.Enqueue<A>): Effect.Effect<R | R2, E, void>;
-export declare function debounce<R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A>;
-export declare function throttle<R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A>;
-export declare function throttleLatest<R, E, A>(fx: Fx<R, E, A>, delay: Duration.DurationInput): Fx<R | Scope.Scope, E, A>;
-export declare function fromAsyncIterable<A>(iterable: AsyncIterable<A>): Fx<never, never, A>;
-export declare function findFirst<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate.Predicate<A>): Effect.Effect<R, E, A>;
-export declare function first<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, A>;
-export declare function either<R, E, A>(fx: Fx<R, E, A>): Fx<R, never, Either.Either<E, A>>;
-export declare function mergeFirst<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, that: Fx<R2, E2, B>): Fx<R | R2, E | E2, A>;
-export declare function mergeRace<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, that: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>;
-export declare function raceAll<const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, Fx.Success<FX[number]>>;
-export declare function race<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, that: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>;
-export declare function snapshot<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>;
-export declare function sample<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, sampled: Fx<R2, E2, B>): Fx<R | R2, E | E2, B>;
-export declare function snapshotEffect<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 function if_<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>;
+}, Fx.Error<FX[string]>, Fx.Context<FX[string]>>;
+export declare function exit<A, E, R>(fx: Fx<A, E, R>): Fx<Exit.Exit<A, E>, never, R>;
+export declare function toEnqueue<A, E, R, R2 = never>(fx: Fx<A, E, R>, queue: Context.Enqueue<R2, A> | Queue.Enqueue<A>): Effect.Effect<void, E, R | R2>;
+export declare function debounce<A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope>;
+export declare function throttle<A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope>;
+export declare function throttleLatest<A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope>;
+export declare function fromAsyncIterable<A>(iterable: AsyncIterable<A>): Fx<A>;
+export declare function findFirst<A, E, R>(fx: Fx<A, E, R>, predicate: Predicate.Predicate<A>): Effect.Effect<A, E, R>;
+export declare function first<A, E, R>(fx: Fx<A, E, R>): Effect.Effect<A, E, R>;
+export declare function either<A, E, R>(fx: Fx<A, E, R>): Fx<Either.Either<E, A>, never, R>;
+export declare function mergeFirst<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, that: Fx<B, E2, R2>): Fx<A, E | E2, R | R2>;
+export declare function mergeRace<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, that: Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>;
+export declare function raceAll<const FX extends ReadonlyArray<Fx<any, any, any>>>(fx: FX): Fx<Fx.Success<FX[number]>, Fx.Error<FX[number]>, Fx.Context<FX[number]>>;
+export declare function race<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, that: Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>;
+export declare function snapshot<A, E, R, B, E2, R2, C>(fx: Fx<A, E, R>, sampled: Fx<B, E2, R2>, f: (a: A, b: B) => C): Fx<C, E | E2, R | R2>;
+export declare function sample<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, sampled: Fx<B, E2, R2>): Fx<B, E | E2, R | R2>;
+export declare function snapshotEffect<A, E, R, B, E2, R2, C, E3, R3>(fx: Fx<A, E, R>, sampled: Fx<B, E2, R2>, f: (a: A, b: B) => Effect.Effect<C, E3, R3>): Fx<C, E | E2 | E3, R | R2 | R3>;
+declare function if_<B, E, R, E2, R2, C, E3, R3>(bool: Fx<boolean, E, R>, options: {
+    readonly onTrue: Fx<B, E2, R2>;
+    readonly onFalse: Fx<C, E3, R3>;
+}): Fx<B | C, E | E2 | E3, R | R2 | R3 | Scope.Scope>;
 export { if_ as if };
-export declare function when<R, E, B, C>(bool: Fx<R, E, boolean>, options: {
+export declare function when<B, E, R, C>(bool: Fx<boolean, E, R>, options: {
     readonly onTrue: B;
     readonly onFalse: C;
-}): Fx<R | Scope.Scope, E, B | C>;
-export declare function mapBoth<R, E, A, B, C>(fx: Fx<R, E, A>, f: (e: E) => B, g: (a: A) => C): Fx<R, B, C>;
+}): Fx<B | C, E, R | Scope.Scope>;
+export declare function mapBoth<A, E, R, B, C>(fx: Fx<A, E, R>, f: (e: E) => B, g: (a: A) => C): Fx<C, B, R>;
 //# sourceMappingURL=core.d.ts.map