export declare const Bounded: (capacity: number) => Bounded

export interface Bounded {
  readonly _tag: "Bounded"
  readonly capacity: number
}

export declare const Exhaust: Exhaust

export interface Exhaust {
  readonly _tag: "Exhaust"
}

export declare const ExhaustLatest: ExhaustLatest

export interface ExhaustLatest {
  readonly _tag: "ExhaustLatest"
}

export type FlattenStrategy = Unbounded | Bounded | Switch | Exhaust | ExhaustLatest

export declare const Switch: Switch

export interface Switch {
  readonly _tag: "Switch"
}

export declare const Unbounded: Unbounded

export interface Unbounded {
  readonly _tag: "Unbounded"
}

export type MergeStrategy = Unordered | Ordered | Switch

export declare const Ordered: (concurrency: number) => Ordered

export interface Ordered {
  readonly _tag: "Ordered"
  readonly concurrency: number
}

export declare const Unordered: (concurrency: number) => Unordered

export interface Unordered {
  readonly _tag: "Unordered"
  readonly concurrency: number
}

export declare const matchTags: {
  <A extends { readonly _tag: string }, Matchers extends DefaultMatchersFrom<A>>(
    matchers: Matchers
  ): <E, R>(
    fx: Fx<A, E, R>
  ) => Fx<
    Fx.Success<ReturnType<Matchers[keyof Matchers]>>,
    E | Fx.Error<ReturnType<Matchers[keyof Matchers]>>,
    R | Fx.Context<ReturnType<Matchers[keyof Matchers]>>
  >
  <A extends { readonly _tag: string }, E, R, Matchers extends DefaultMatchersFrom<A>>(
    fx: Fx<A, E, R>,
    matchers: Matchers
  ): Fx<
    Fx.Success<ReturnType<Matchers[keyof Matchers]>>,
    E | Fx.Error<ReturnType<Matchers[keyof Matchers]>>,
    R | Fx.Context<ReturnType<Matchers[keyof Matchers]>>
  >
}

export type FxFork = <R>(effect: Effect.Effect<void, never, R>) => Effect.Effect<void, never, R>

export type ScopedFork = <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Fiber.Fiber<A, E>, never, R>

export type Context<T> = Fx.Context<T>

export type DefaultMatchersFrom<A extends { readonly _tag: string }> = {
  readonly [Tag in A["_tag"]]: (value: RefSubject<Extract<A, { readonly _tag: Tag }>>) => Fx<any, any, any>
}

export type Error<T> = Fx.Error<T>

export interface Fx<out A, out E = never, out R = never> extends Pipeable.Pipeable {
  readonly [FxTypeId]: Fx.Variance<A, E, R>

  /**
   * @since 1.20.0
   */
  run<R2 = never>(sink: Sink.Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2>
}

export interface Variance<A, E, R> {
  readonly _R: Types.Covariant<R>
  readonly _E: Types.Covariant<E>
  readonly _A: Types.Covariant<A>
}

export type Context<T> = T extends Fx<infer _A, infer _E, infer R> ? R : never

export type Error<T> = T extends Fx<infer _A, infer E, infer _R> ? E : never

export type Success<T> = T extends Fx<infer A, infer _E, infer _R> ? A : never

export type Unify<T> = [T] extends [Fx<infer A, infer E, infer R>] ? Fx<A, E, R> : never

export declare class FxEffectBase<A, E, R, B, E2, R2>

run<R3>(sink: Sink.Sink<A, E, R3>): Effect.Effect<void, never, R | R3>

abstract toFx(): Fx<A, E, R>

abstract toEffect(): Effect.Effect<B, E2, R2>

export interface KeyedOptions<A, B, C, E2, R2> {
  readonly getKey: (a: A) => B
  readonly onValue: (ref: RefSubject<A>, key: B) => Fx<C, E2, R2>
  readonly debounce?: Duration.DurationInput
}

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 type MatchCauseOptionsEffect<E, A, B, E2, R2, C, E3, R3> = {
  readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
  readonly onSuccess: (a: A) => Effect.Effect<C, E3, R3>
  readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
}

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 type MatchErrorOptionsEffect<E, A, B, E2, R2, C, E3, R3> = {
  readonly onFailure: (e: E) => Effect.Effect<B, E2, R2>
  readonly onSuccess: (a: A) => Effect.Effect<C, E3, R3>
  readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
}

export type Success<T> = Fx.Success<T>

export type Unify<T> = Fx.Unify<T>

export interface WithKeyOptions<A, B, C, E2, R2> {
  readonly getKey: (a: A) => B
  readonly onValue: (ref: RefSubject<A>, key: B) => Fx<C, E2, R2>
}

export declare const acquireUseRelease: {
  <A, B, E2, R2, C, E3, R3>(
    use: (a: A) => Fx<B, E2, R2>,
    release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<C, E3, R3>
  ): <E, R>(acquire: Effect.Effect<A, E, R>) => Fx<B, E | E2 | E3, R | R2 | R3>
  <A, E, R, B, E2, R2, C, E3, R3>(
    acquire: Effect.Effect<A, E, R>,
    use: (a: A) => Fx<B, E2, R2>,
    release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<C, E3, R3>
  ): Fx<B, E | E2 | E3, R | R2 | R3>
}

export declare const all: {
  <const FX extends ReadonlyArray<Fx<any, any, any>>>(
    fx: FX
  ): Fx<{ readonly [K in keyof FX]: Fx.Success<FX[K]> }, Fx.Error<FX[number]>, Fx.Context<FX[number]>>
  <const FX extends Readonly<Record<string, Fx<any, any, any>>>>(
    fx: FX
  ): Fx<{ readonly [K in keyof FX]: Fx.Success<FX[K]> }, Fx.Error<FX[string]>, Fx.Context<FX[string]>>
}

export declare const annotateLogs: {
  (key: string | Record<string, unknown>, value?: unknown): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>
  <A, E, R>(fx: Fx<A, E, R>, key: string | Record<string, unknown>, value?: unknown): Fx<A, E, R>
}

export declare const annotateSpans: {
  (key: string | Record<string, unknown>, value?: unknown): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>
  <A, E, R>(fx: Fx<A, E, R>, key: string | Record<string, unknown>, value?: unknown): Fx<A, E, R>
}

export declare const append: {
  <C>(end: C): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | C, E, R>
  <A, E, R, C>(fx: Fx<A, E, R>, end: C): Fx<A | C, E, R>
}

export declare const appendAll: {
  <C>(end: Iterable<C>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | C, E, R>
  <A, E, R, C>(fx: Fx<A, E, R>, end: Iterable<C>): Fx<A | C, E, R>
}

export declare const at: {
  (duration: Duration.DurationInput): <A>(value: A) => Fx<A>
  <A>(value: A, duration: Duration.DurationInput): Fx<A>
}

export declare const compact: <A, E, R>(fx: Fx<Option.Option<A>, E, R>) => Fx<A, E, R>

export declare const concatMap: {
  <A, B, E2, R2>(
    f: (a: A) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, Scope.Scope | R | R2>
  <A, E, R, B, E2, R2>(
    fx: Fx<A, E, R>,
    f: (a: A) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): Fx<B, E | E2, Scope.Scope | R | R2>
}

export declare const continueWith: {
  <B, E2, R2>(f: () => Fx<B, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E | E2, R | R2>
  <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: () => Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>
}

export declare const debounce: {
  (delay: Duration.DurationInput): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R | Scope.Scope>
  <A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope>
}

export declare const delay: {
  (delay: Duration.DurationInput): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R | Scope.Scope>
  <A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope>
}

export declare const die: (error: unknown) => Fx<never>

export declare const drain: <A, E, R>(fx: Fx<A, E, R>) => Effect.Effect<void, E, R>

export declare function drainLayer<FXS extends ReadonlyArray<Fx<any, never, any>>>(
  ...fxs: FXS
): Layer.Layer<never, never, Exclude<Fx.Context<FXS[number]>, Scope.Scope>>

export declare const drop: {
  (n: number): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>
  <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R>
}

export declare const dropAfter: {
  <A, B extends A>(f: Predicate.Refinement<A, B>): <E, R>(fx: Fx<A, E, R>) => Fx<Exclude<A, B>, E, R>
  <A>(f: Predicate.Predicate<A>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>
  <A, E, R, B extends A>(fx: Fx<A, E, R>, f: Predicate.Refinement<A, B>): Fx<Exclude<A, B>, E, R>
  <A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>
}

export declare const dropAfterEffect: {
  <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>
  <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>
}

export declare const dropUntil: {
  <A, B extends A>(f: Predicate.Refinement<A, B>): <E, R>(fx: Fx<A, E, R>) => Fx<A | B, E, R>
  <A>(f: Predicate.Predicate<A>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>
  <A, E, R, B extends A>(fx: Fx<A, E, R>, f: Predicate.Refinement<A, B>): Fx<A | B, E, R>
  <A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>
}

export declare const dropUntilEffect: {
  <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>
  <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>
}

export declare const dropWhile: {
  <A, B extends A>(f: Predicate.Refinement<A, B>): <E, R>(fx: Fx<A, E, R>) => Fx<Exclude<A, B>, E, R>
  <A>(f: Predicate.Predicate<A>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>
  <A, E, R, B extends A>(fx: Fx<A, E, R>, f: Predicate.Refinement<A, B>): Fx<Exclude<A, B>, E, R>
  <A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>
}

export declare const dropWhileEffect: {
  <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>
  <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>
}

export declare const during: {
  <E2, R2, A, R3, E3, B>(
    window: Fx<Fx<B, E3, R3>, E2, R2>
  ): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2 | E3, R | R2 | R3 | Scope.Scope>
  <A, E, R, E2, R2, R3, E3, B>(
    fx: Fx<A, E, R>,
    window: Fx<Fx<B, E3, R3>, E2, R2>
  ): Fx<A, E | E2 | E3, R | R2 | R3 | Scope.Scope>
}

export declare const either: <A, E, R>(fx: Fx<A, E, R>) => Fx<Either.Either<A, E>, never, R>

export declare const empty: Fx<never, never, never>

export declare const ensuring: {
  <R2>(finalizer: Effect.Effect<unknown, never, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E, R | R2>
  <A, E, R, R2>(self: Fx<A, E, R>, finalizer: Effect.Effect<unknown, never, R2>): Fx<A, E, R | R2>
}

export declare const exhaustMap: {
  <A, B, E2, R2>(
    f: (a: A) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>
  <A, E, R, B, E2, R2>(
    fx: Fx<A, E, R>,
    f: (a: A) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): Fx<B, E | E2, R | R2 | Scope.Scope>
}

export declare const exhaustMapCause: {
  <E, B, E2, R2>(
    f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>
  <A, E, R, B, E2, R2>(
    fx: Fx<A, E, R>,
    f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): Fx<A | B, E2, R | R2 | Scope.Scope>
}

export declare const exhaustMapEffect: {
  <A, B, E2, R2>(
    f: (a: A) => Effect.Effect<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>
  <A, E, R, B, E2, R2>(
    fx: Fx<A, E, R>,
    f: (a: A) => Effect.Effect<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): Fx<B, E | E2, R | R2 | Scope.Scope>
}

export declare const exhaustMapError: {
  <E, B, E2, R2>(
    f: (e: E) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>
  <A, E, R, B, E2, R2>(
    fx: Fx<A, E, R>,
    f: (e: E) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): Fx<A | B, E2, R | R2 | Scope.Scope>
}

export declare const exhaustMapLatest: {
  <A, B, E2, R2>(
    f: (a: A) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>
  <A, E, R, B, E2, R2>(
    fx: Fx<A, E, R>,
    f: (a: A) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): Fx<B, E | E2, R | R2 | Scope.Scope>
}

export declare const exhaustMapLatestCause: {
  <E, B, E2, R2>(
    f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>
  <A, E, R, B, E2, R2>(
    fx: Fx<A, E, R>,
    f: (cause: Cause.Cause<E>) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): Fx<A | B, E2, R | R2 | Scope.Scope>
}

export declare const exhaustMapLatestEffect: {
  <A, B, E2, R2>(
    f: (a: A) => Effect.Effect<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): <E, R>(fx: Fx<A, E, R>) => Fx<B, E | E2, R | R2 | Scope.Scope>
  <A, E, R, B, E2, R2>(
    fx: Fx<A, E, R>,
    f: (a: A) => Effect.Effect<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): Fx<B, E | E2, R | R2 | Scope.Scope>
}

export declare const exhaustMapLatestError: {
  <E, B, E2, R2>(
    f: (e: E) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): <R, A>(fx: Fx<A, E, R>) => Fx<A | B, E2, R | R2 | Scope.Scope>
  <A, E, R, B, E2, R2>(
    fx: Fx<A, E, R>,
    f: (e: E) => Fx<B, E2, R2>,
    executionStrategy?: ExecutionStrategy.ExecutionStrategy | undefined
  ): Fx<A | B, E2, R | R2 | Scope.Scope>
}

export declare const exhaustMatchCause: {
  <E, A, B, E2, R2, C, E3, R3>(
    opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>
  ): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>
  <A, E, R, B, E2, R2, C, E3, R3>(
    fx: Fx<A, E, R>,
    opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>
  ): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>
}

export declare const exhaustMatchError: {
  <E, A, B, E2, R2, C, E3, R3>(
    opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>
  ): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>
  <A, E, R, B, E2, R2, C, E3, R3>(
    fx: Fx<A, E, R>,
    opts: core.MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>
  ): Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>
}

export declare const exhaustMatchLatestCause: {
  <E, A, B, E2, R2, C, E3, R3>(
    opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>
  ): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>
  <A, E, R, B, E2, R2, C, E3, R3>(
    fx: Fx<A, E, R>,
    opts: MatchCauseOptions<E, A, B, E2, R2, C, E3, R3>
  ): Fx<B | C, E2 | E3, Scope.Scope | R | R2 | R3>
}

export declare const exhaustMatchLatestError: {
  <E, A, B, E2, R2, C, E3, R3>(
    opts: MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>
  ): <R>(fx: Fx<A, E, R>) => Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>
  <A, E, R, B, E2, R2, C, E3, R3>(
    fx: Fx<A, E, R>,
    opts: core.MatchErrorOptions<E, A, B, E2, R2, C, E3, R3>
  ): Fx<B | C, E2 | E3, R | R2 | R3 | Scope.Scope>
}

export declare const exit: <A, E, R>(fx: Fx<A, E, R>) => Fx<Exit.Exit<A, E>, never, R>

export declare const fail: <E>(error: E) => Fx<never, E>

export declare const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E>

export declare const filter: {
  <A, B extends A>(f: Predicate.Refinement<A, B>): <E, R>(fx: Fx<A, E, R>) => Fx<B, E, R>
  <A>(f: Predicate.Predicate<A>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>
  <A, E, R, B extends A>(fx: Fx<A, E, R>, f: Predicate.Refinement<A, B>): Fx<B, E, R>
  <A, E, R>(fx: Fx<A, E, R>, f: Predicate.Predicate<A>): Fx<A, E, R>
}

export declare const filterCause: {
  <E>(f: (cause: Cause.Cause<E>) => boolean): <R, A>(fx: Fx<A, E, R>) => Fx<A, E, R>
  <A, E, R>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => boolean): Fx<A, E, R>
}

export declare const filterCauseEffect: {
  <E, E2, R2>(
    f: (cause: Cause.Cause<E>) => Effect.Effect<boolean, E2, R2>
  ): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2, R | R2>
  <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Effect.Effect<boolean, E2, R2>): Fx<A, E2, R | R2>
}

export declare const filterEffect: {
  <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>
  <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Fx<A, E | E2, R | R2>
}

export declare const filterError: {
  <E>(f: (e: E) => boolean): <R, A>(fx: Fx<A, E, R>) => Fx<A, E, R>
  <A, E, R>(fx: Fx<A, E, R>, f: (e: E) => boolean): Fx<A, E, R>
}

export declare const filterErrorEffect: {
  <E, E2, R2>(f: (e: E) => Effect.Effect<boolean, E2, R2>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2, R | R2>
  <A, E, R, E2, R2>(fx: Fx<A, E, R>, f: (e: E) => Effect.Effect<boolean, E2, R2>): Fx<A, E2, R | R2>
}

export declare const filterMap: {
  <A, B>(f: (a: A) => Option.Option<B>): <E, R>(fx: Fx<A, E, R>) => Fx<B, E, R>
  <A, E, R, B>(fx: Fx<A, E, R>, f: (a: A) => Option.Option<B>): Fx<B, E, R>
}

export declare const filterMapCause: {
  <E, E2>(f: (cause: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): <R, A>(fx: Fx<A, E, R>) => Fx<A, E2, R>
  <A, E, R, E2>(fx: Fx<A, E, R>, f: (cause: Cause.Cause<E>) => Option.Option<Cause.Cause<E2>>): Fx<A, E2, R>
}