@typed/fx 1.18.4 → 1.20.0

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

@@ -1,456 +1,224 @@
-import type { Exit } from "effect";
-import { Cause, Chunk, Effect, Layer, Option, Scope, Stream } from "effect";
-import { type Context, type Tag } from "@typed/context";
-import * as Schedule from "effect/Schedule";
-import type { DurationInput } from "effect/Duration";
-import type { Equivalence } from "effect/Equivalence";
-import type { Runtime } from "effect/Runtime";
-import * as Emitter from "../Emitter.js";
-import type { FlattenStrategy, Fx, FxInput, WithEarlyExitParams, WithFlattenStrategyParams, WithScopedForkParams } from "../Fx.js";
+import * as Context from "@typed/context";
+import type { ConfigProvider, Duration, Equivalence, FiberId, FiberRef, HashSet, Queue, Request, Runtime, Schedule, Scheduler } from "effect";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Either from "effect/Either";
+import * as ExecutionStrategy from "effect/ExecutionStrategy";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+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 succeed<A>(value: A): Fx<never, never, A>;
-export declare function fromIterable<A>(iterable: Iterable<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>;
-};
-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 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 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 compact: <R, E, A>(fx: Fx<R, E, Option.Option<A>>) => Fx<R, E, A>;
-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 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 filterCause: {
-    <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 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 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 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 filterMapErrorEffect: {
-    <E, R2, E2, B>(f: (e: E) => Effect.Effect<R2, E2, Option.Option<B>>): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, 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 function observe<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 function drain<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, void>;
-export declare function toArray<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, Array<A>>;
-export declare function toReadonlyArray<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, ReadonlyArray<A>>;
-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 switchMap: {
-    <A, R2, E2, B>(f: (a: A) => FxInput<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) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>;
-};
-export declare const exhaustMap: {
-    <A, R2, E2, B>(f: (a: A) => FxInput<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) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>;
-};
-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 exhaustMapLatest: {
-    <A, R2, E2, B>(f: (a: A) => FxInput<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) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>;
-};
-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 flatMap: {
-    <A, R2, E2, B>(f: (a: A) => FxInput<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) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>;
-};
-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 flatMapConcurrently: {
-    <A, R2, E2, B>(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, E2, B>(fx: Fx<R, E, A>, f: (a: A) => FxInput<R2, E2, B>, concurrency: number): Fx<R | R2, E | E2, B>;
-};
-export declare const concatMap: {
-    <A, R2, E2, B>(f: (a: A) => FxInput<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) => FxInput<R2, E2, B>): Fx<R | R2, E | E2, B>;
-};
-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 function combine<const FX extends ReadonlyArray<Fx<any, any, any>>>(fxs: FX): Fx<Fx.Context<FX[number]>, Fx.Error<FX[number]>, {
+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 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?: {
+    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>;
+    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>;
+    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]>, {
     readonly [K in keyof FX]: Fx.Success<FX[K]>;
 }>;
-export declare function struct<const FX extends Readonly<Record<PropertyKey, Fx<any, any, any>>>>(fxs: FX): Fx<Fx.Context<FX[string]>, Fx.Error<FX[string]>, {
+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]>, {
     readonly [K in keyof FX]: Fx.Success<FX[K]>;
 }>;
-export declare function 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 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 function 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 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 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 function 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 empty: Fx<never, never, never>;
-export declare const never: Fx<never, never, never>;
-export declare const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never>;
-export declare const fail: <E>(e: E) => Fx<never, E, never>;
-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 suspend: <R, E, A>(f: () => Fx<R, E, A>) => Fx<R, E, A>;
-export declare const sync: <A>(f: () => A) => Fx<never, never, A>;
-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 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 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 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 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 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 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 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 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 recoverWith: {
-    <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 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 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 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 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 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 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 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 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 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 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 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 flatMapCauseWithStrategy: {
-    <E, R2, E2, B>(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, E2, B>(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 flatMapErrorWithStrategy: {
-    <E, R2, E2, B>(f: (error: E) => FxInput<R2, E2, B>, strategy: FlattenStrategy): <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) => FxInput<R2, E2, B>, strategy: FlattenStrategy): Fx<R | R2, E2, A | B>;
-};
-export declare const flatMapCause: {
-    <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>) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
-};
-export declare const flatMapError: {
-    <E, R2, E2, B>(f: (error: 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: (error: E) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
-};
-export declare const flatMapCauseConcurrently: {
-    <E, R2, E2, B>(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, E2, B>(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 flatMapErrorConcurrently: {
-    <E, R2, E2, B>(f: (error: E) => FxInput<R2, E2, B>, concurrency: number): <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) => FxInput<R2, E2, B>, concurrency: number): Fx<R | R2, E2, A | B>;
-};
-export declare const switchMapCause: {
-    <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>) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
-};
-export declare const switchMapError: {
-    <E, R2, E2, B>(f: (error: 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: (error: E) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
-};
-export declare const exhaustMapCause: {
-    <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>) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
-};
-export declare const exhaustMapError: {
-    <E, R2, E2, B>(f: (error: 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: (error: E) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
-};
-export declare const exhaustMapLatestCause: {
-    <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>) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
-};
-export declare const exhaustMapLatestError: {
-    <E, R2, E2, B>(f: (error: 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: (error: E) => FxInput<R2, E2, B>): Fx<R | R2, E2, A | B>;
-};
-export declare const matchCauseWithStrategy: {
-    <E, R2, E2, B, A, R3, E3, C>(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<R | R2, E2, A | B>;
-    <R, E, A, R2, E2, B, R3, E3, C>(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>;
-};
-export declare const matchErrorWithStrategy: {
-    <E, R2, E2, B, A, R3, E3, C>(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<R | R2, E2, A | B>;
-    <R, E, A, R2, E2, B, R3, E3, C>(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>;
-};
-export declare const matchCause: {
-    <E, R2, E2, B, A, R3, E3, C>(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<R | R2 | R3, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(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 match: {
-    <E, R2, E2, B, A, R3, E3, C>(options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(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 matchCauseConcurrently: {
-    <E, R2, E2, B, A, R3, E3, C>(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<R | R2 | R3, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(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>;
-};
-export declare const matchErrorConcurrently: {
-    <E, R2, E2, B, A, R3, E3, C>(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<R | R2 | R3, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(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>;
-};
-export declare const switchMatchCause: {
-    <E, R2, E2, B, A, R3, E3, C>(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<R | R2 | R3, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(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 switchMatch: {
-    <E, R2, E2, B, A, R3, E3, C>(options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(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 exhaustMatchCause: {
-    <E, R2, E2, B, A, R3, E3, C>(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<R | R2 | R3, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(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 exhaustMatch: {
-    <E, R2, E2, B, A, R3, E3, C>(options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(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 exhaustLatestMatchCause: {
-    <E, R2, E2, B, A, R3, E3, C>(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<R | R2 | R3, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(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 exhaustLatestMatch: {
-    <E, R2, E2, B, A, R3, E3, C>(options: {
-        readonly onFailure: (error: E) => FxInput<R2, E2, B>;
-        readonly onSuccess: (a: A) => FxInput<R3, E3, C>;
-    }): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C>;
-    <R, E, A, R2, E2, B, R3, E3, C>(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 withEarlyExit: <R, E, A>(f: (params: WithEarlyExitParams<E, A>) => Effect.Effect<R, never, unknown>) => Fx<R, E, A>;
-export declare const withScopedFork: <R, E, A>(f: (params: WithScopedForkParams<E, A>) => Effect.Effect<R, never, unknown>) => Fx<R, E, A>;
-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 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 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 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 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 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 provide: {
-    <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>(runtime: Runtime<R2>): <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, R2>, E, A>;
-    <R2>(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<R2>): Fx<Exclude<R, R2>, E, A>;
-    <R, E, A, R2>(fx: Fx<R, E, A>, context: Context<R2>): Fx<Exclude<R, R2>, E, A>;
-};
-export declare const provideService: {
-    <I, S>(tag: 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: Tag<I, S>, service: S): Fx<Exclude<R, I>, E, A>;
-};
-export declare const provideServiceEffect: {
-    <I, S, R2, E2>(tag: 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: Tag<I, S>, service: Effect.Effect<R2, E2, S>): Fx<R2 | Exclude<R, I>, E, A>;
-};
-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 skipRepeats: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>;
-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 function toChunk<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, Chunk.Chunk<A>>;
-export declare const snapshot: {
-    <R2, E2, B, A, R3, E3, C>(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, E2, B, R3, E3, C>(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 function fromEmitter<R, E, A>(f: (emitter: Emitter.Emitter<E, A>) => Effect.Effect<R | Scope.Scope, never, unknown>): Fx<Exclude<R, Scope.Scope>, E, A>;
-export declare function fromEffect<R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A>;
-export declare function fromStream<R, E, A>(stream: Stream.Stream<R, E, A>, options?: {
-    priority?: number;
-}): Fx<R, E, A>;
-export declare function from<A>(input: Iterable<A>): Fx<never, never, A>;
-export declare function from<E>(input: Cause.Cause<E>): Fx<never, E, never>;
-export declare function from<R, E, A>(input: FxInput<R, E, A>): Fx<R, E, A>;
-export declare function from<A>(input: A): Fx<never, never, A>;
+export declare function 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]>;
+}>;
+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]>, {
+    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>;
+export { if_ as if };
+export declare function when<R, E, B, C>(bool: Fx<R, E, boolean>, 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>;
 //# sourceMappingURL=core.d.ts.map