@fncts/io 0.0.11 → 0.0.14

package/IO/api.d.ts

@@ -1,21 +1,21 @@
-import { FiberId } from "@fncts/base/data/FiberId";
-import { Maybe } from "@fncts/base/data/Maybe";
-import { Either } from "@fncts/base/data/Either";
-import { Lazy } from "@fncts/base/data/function";
-import { Cause } from "@fncts/base/data/Cause";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
 import { InterruptStatus } from "@fncts/io/InterruptStatus";
 import { URIO, FIO, UIO } from "@fncts/io/IO/definition";
 import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
 import { FiberDescriptor } from "@fncts/io/FiberDescriptor";
 import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
-import { Refinement } from "@fncts/base/data/Refinement";
-import { Predicate } from "@fncts/base/data/Predicate";
-import { NonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray";
-import { Eval } from "@fncts/base/control/Eval";
-import { Exit } from "@fncts/base/data/Exit";
+import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { NonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import { Eval } from "@fncts/base/control/Eval/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { Trace } from "@fncts/base/data/Trace/definition";
-import { List } from "@fncts/base/collection/immutable/List";
-import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray";
+import { List } from "@fncts/base/collection/immutable/List/definition";
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import { Supervisor } from "@fncts/io/Supervisor/definition";
 import { FiberRefs } from "@fncts/io/FiberRefs";
 import type * as P from "@fncts/base/typeclass";
@@ -70,19 +70,19 @@ export declare function absorbWith_<R, E, A>(ma: IO<R, E, A>, f: (e: E) => unkno
  * @tsplus operator fncts.io.IO <
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function apFirst_<R, E, A, R1, E1, B>(self: IO<R, E, A>, fb: IO<R1, E1, B>, __tsplusTrace?: string): IO<R1 & R, E1 | E, A>;
+export declare function apFirst_<R, E, A, R1, E1, B>(self: IO<R, E, A>, fb: IO<R1, E1, B>, __tsplusTrace?: string): IO<R1 | R, E1 | E, A>;
 /**
  * Combine two effectful actions, keeping only the result of the second
  * @tsplus fluent fncts.io.IO apSecond
  * @tsplus operator fncts.io.IO >
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function apSecond_<R, E, A, R1, E1, B>(self: IO<R, E, A>, fb: IO<R1, E1, B>, __tsplusTrace?: string): IO<R1 & R, E1 | E, B>;
+export declare function apSecond_<R, E, A, R1, E1, B>(self: IO<R, E, A>, fb: IO<R1, E1, B>, __tsplusTrace?: string): IO<R1 | R, E1 | E, B>;
 /**
  * @tsplus fluent fncts.io.IO as
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function as_<R, E, A, B>(self: IO<R, E, A>, b: Lazy<B>): IO<R, E, B>;
+export declare function as_<R, E, A, B>(self: IO<R, E, A>, b: Lazy<B>, __tsplusTrace?: string): IO<R, E, B>;
 /**
  * Maps the success value of this effect to an optional value.
  * @tsplus getter fncts.io.IO asJust
@@ -99,7 +99,7 @@ export declare function asJustError<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: st
  * @tsplus getter fncts.io.IO asUnit
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function asUnit<R, E, A>(self: IO<R, E, A>): IO<R, E, void>;
+export declare function asUnit<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, void>;
 /**
  * Returns an IO whose failure and success channels have been mapped by
  * the specified pair of functions, `f` and `g`.
@@ -113,7 +113,7 @@ export declare function bimap_<R, E, A, E1, B>(self: IO<R, E, A>, f: (e: E) => E
  * @tsplus fluent fncts.io.IO bitap
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function bitap_<R, E, A, R1, E1, R2, E2>(self: IO<R, E, A>, onFailure: (e: E) => IO<R1, E1, any>, onSuccess: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): IO<R & R1 & R2, E | E1 | E2, A>;
+export declare function bitap_<R, E, A, R1, E1, R2, E2>(self: IO<R, E, A>, onFailure: (e: E) => IO<R1, E1, any>, onSuccess: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): IO<R | R1 | R2, E | E1 | E2, A>;
 /**
  * Recovers from the specified error
  * @tsplus fluent fncts.io.IO catch
@@ -121,7 +121,7 @@ export declare function bitap_<R, E, A, R1, E1, R2, E2>(self: IO<R, E, A>, onFai
  */
 export declare function catch_<N extends keyof E, K extends E[N] & string, R, E, A, R1, E1, A1>(ma: IO<R, E, A>, tag: N, k: K, f: (e: Extract<E, {
     [n in N]: K;
-}>) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R & R1, Exclude<E, {
+}>) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, Exclude<E, {
     [n in N]: K;
 }> | E1, A | A1>;
 /**
@@ -129,26 +129,26 @@ export declare function catch_<N extends keyof E, K extends E[N] & string, R, E,
  * @tsplus fluent fncts.io.IO catchAll
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchAll_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f: (e: E) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R & R1, E1, A | A1>;
+export declare function catchAll_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f: (e: E) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, E1, A | A1>;
 /**
  *
  * Recovers from all errors with provided cause.
  * @tsplus fluent fncts.io.IO catchAllCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchAllCause_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f: (_: Cause<E>) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R & R1, E1, A | A1>;
+export declare function catchAllCause_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f: (_: Cause<E>) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, E1, A | A1>;
 /**
  * Recovers from some or all of the error cases.
  * @tsplus fluent fncts.io.IO catchJust
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchJust_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f: (e: E) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R & R1, E | E1, A | A1>;
+export declare function catchJust_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f: (e: E) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R | R1, E | E1, A | A1>;
 /**
  * Recovers from some or all of the error cases with provided cause.
  * @tsplus fluent fncts.io.IO catchJustCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchJustCause_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f: (_: Cause<E>) => Maybe<IO<R1, E1, A1>>): IO<R & R1, E | E1, A | A1>;
+export declare function catchJustCause_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f: (_: Cause<E>) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R | R1, E | E1, A | A1>;
 /**
  * Recovers from some or all of the defects with provided partial function.
  *
@@ -159,7 +159,7 @@ export declare function catchJustCause_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f:
  * @tsplus fluent fncts.io.IO catchJustDefect
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchJustDefect_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f: (_: unknown) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R & R1, E | E1, A | A1>;
+export declare function catchJustDefect_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, f: (_: unknown) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R | R1, E | E1, A | A1>;
 /**
  * Recovers from the specified error
  * @tsplus fluent IO catchTag
@@ -169,7 +169,7 @@ export declare function catchTag_<K extends E["_tag"] & string, R, E extends {
     _tag: string;
 }, A, R1, E1, A1>(ma: IO<R, E, A>, k: K, f: (e: Extract<E, {
     _tag: K;
-}>) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R & R1, Exclude<E, {
+}>) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, Exclude<E, {
     _tag: K;
 }> | E1, A | A1>;
 /**
@@ -189,12 +189,12 @@ export declare function causeAsError<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: s
  * @tsplus fluent fncts.io.IO flatMap
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function flatMap_<R, E, A, R1, E1, B>(ma: IO<R, E, A>, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): IO<R & R1, E | E1, B>;
+export declare function flatMap_<R, E, A, R1, E1, B>(ma: IO<R, E, A>, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): IO<R | R1, E | E1, B>;
 /**
  * @tsplus fluent fncts.io.IO flatMapError
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function flatMapError_<R, R1, E, E1, A>(ma: IO<R, E, A>, f: (e: E) => IO<R1, never, E1>): IO<R & R1, E1, A>;
+export declare function flatMapError_<R, R1, E, E1, A>(ma: IO<R, E, A>, f: (e: E) => IO<R1, never, E1>, __tsplusTrace?: string): IO<R | R1, E1, A>;
 /**
  * Checks the interrupt status, and produces the IO returned by the
  * specified callback.
@@ -211,12 +211,12 @@ export declare function collect_<R, E, A, E1, A1>(ma: IO<R, E, A>, f: Lazy<E1>,
  * @tsplus fluent fncts.io.IO collectIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function collectIO_<R, E, A, R1, E1, A1, E2>(ma: IO<R, E, A>, f: Lazy<E2>, pf: (a: A) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R & R1, E | E1 | E2, A1>;
+export declare function collectIO_<R, E, A, R1, E1, A1, E2>(ma: IO<R, E, A>, f: Lazy<E2>, pf: (a: A) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R | R1, E | E1 | E2, A1>;
 /**
  * @tsplus static fncts.io.IOOps condIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function condIO_<R, R1, E, A>(b: boolean, onTrue: URIO<R, A>, onFalse: URIO<R1, E>): IO<R & R1, E, A>;
+export declare function condIO_<R, R1, E, A>(b: boolean, onTrue: URIO<R, A>, onFalse: URIO<R1, E>, __tsplusTrace?: string): IO<R | R1, E, A>;
 /**
  * Returns a lazily constructed effect, whose construction may itself require
  * effects. The effect must not throw any exceptions. When no environment is required (i.e., when R == unknown)
@@ -248,7 +248,7 @@ export declare function deferTry<R, E, A>(io: () => IO<R, E, A>, __tsplusTrace?:
  * @tsplus static IOOps deferTryWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function deferTryWith<R, E, A>(io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>): IO<R, unknown, A>;
+export declare function deferTryWith<R, E, A>(io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A>;
 /**
  * Returns a lazily constructed effect, whose construction may itself require effects,
  * translating any thrown exceptions into typed failed effects and mapping the error.
@@ -257,7 +257,7 @@ export declare function deferTryWith<R, E, A>(io: (runtimeConfig: RuntimeConfig,
  * @tsplus static IOOps deferTryCatch
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function deferTryCatch<R, E, A, E1>(io: () => IO<R, E, A>, onThrow: (error: unknown) => E1): IO<R, E | E1, A>;
+export declare function deferTryCatch<R, E, A, E1>(io: () => IO<R, E, A>, onThrow: (error: unknown) => E1, __tsplusTrace?: string): IO<R, E | E1, A>;
 /**
  * Returns a lazily constructed effect, whose construction may itself require effects,
  * translating any thrown exceptions into typed failed effects and mapping the error.
@@ -266,12 +266,12 @@ export declare function deferTryCatch<R, E, A, E1>(io: () => IO<R, E, A>, onThro
  * @tsplus static IOOps deferTryCatchWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function deferTryCatchWith<R, E, A, E1>(io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>, onThrow: (error: unknown) => E1): IO<R, E | E1, A>;
+export declare function deferTryCatchWith<R, E, A, E1>(io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>, onThrow: (error: unknown) => E1, __tsplusTrace?: string): IO<R, E | E1, A>;
 /**
  * @tsplus static fncts.io.IOOps descriptor
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare const descriptor: IO<unknown, never, import("../FiberDescriptor").FiberDescriptor>;
+export declare const descriptor: IO<never, never, import("../FiberDescriptor").FiberDescriptor>;
 /**
  * Constructs an IO based on information about the current fiber, such as
  * its identity.
@@ -289,7 +289,7 @@ export declare function either<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string)
  * @tsplus fluent fncts.io.IO ensuring
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function ensuring_<R, E, A, R1>(self: IO<R, E, A>, finalizer: IO<R1, never, any>, __tsplusTrace?: string): IO<R & R1, E, A>;
+export declare function ensuring_<R, E, A, R1>(self: IO<R, E, A>, finalizer: IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1, E, A>;
 /**
  * @tsplus fluent fncts.io.IO errorAsCause
  * @tsplus location "@fncts/io/IO/api"
@@ -332,7 +332,7 @@ export declare function failCause<E = never, A = never>(cause: Lazy<Cause<E>>, _
  * @tsplus static fncts.io.IOOps fiberId
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare const fiberId: IO<unknown, never, FiberId>;
+export declare const fiberId: IO<never, never, FiberId>;
 /**
  * Filters the collection using the specified effectual predicate.
  * @tsplus static fncts.io.IOOps filter
@@ -361,8 +361,8 @@ export declare function filterNot_<A, R, E>(as: Iterable<A>, f: (a: A) => IO<R,
  * @tsplus fluent fncts.io.IO filterOrElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function filterOrElse_<R, E, A, B extends A, R1, E1, A1>(fa: IO<R, E, A>, refinement: Refinement<A, B>, or: (a: Exclude<A, B>) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R & R1, E | E1, B | A1>;
-export declare function filterOrElse_<R, E, A, R1, E1, A1>(fa: IO<R, E, A>, predicate: Predicate<A>, or: (a: A) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R & R1, E | E1, A | A1>;
+export declare function filterOrElse_<R, E, A, B extends A, R1, E1, A1>(fa: IO<R, E, A>, refinement: Refinement<A, B>, or: (a: Exclude<A, B>) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, E | E1, B | A1>;
+export declare function filterOrElse_<R, E, A, R1, E1, A1>(fa: IO<R, E, A>, predicate: Predicate<A>, or: (a: A) => IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, E | E1, A | A1>;
 /**
  * Fails with `failWith` if the predicate fails.
  * @tsplus fluent fncts.io.IO filterOrFail
@@ -376,7 +376,7 @@ export declare function filterOrFail_<R, E, A, E1>(fa: IO<R, E, A>, predicate: P
  * @tsplus static fncts.io.IOOps firstSuccess
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function firstSuccess<R, E, A>(mas: NonEmptyArray<IO<R, E, A>>): IO<R, E, A>;
+export declare function firstSuccess<R, E, A>(mas: NonEmptyArray<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Halts with specified `unknown` if the predicate fails.
  * @tsplus fluent fncts.io.IO filterOrHalt
@@ -388,7 +388,7 @@ export declare function filterOrHalt_<R, E, A>(fa: IO<R, E, A>, predicate: Predi
  * @tsplus getter fncts.io.IO flatten
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function flatten<R, E, R1, E1, A>(self: IO<R, E, IO<R1, E1, A>>): IO<R & R1, E | E1, A>;
+export declare function flatten<R, E, R1, E1, A>(self: IO<R, E, IO<R1, E1, A>>, __tsplusTrace?: string): IO<R | R1, E | E1, A>;
 /**
  * Folds an `Iterable<A>` using an effectful function f, working sequentially from left to right.
  * @tsplus static fncts.io.IOOps foldLeft
@@ -407,7 +407,7 @@ export declare function foldMap_<R, E, A, M>(as: Iterable<IO<R, E, A>>, f: (a: A
  * @tsplus static fncts.io.IOOps foldRight
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function foldRight_<A, B, R, E>(as: Iterable<A>, b: UIO<B>, f: (a: A, b: IO<R, E, B>) => IO<R, E, B>): IO<R, E, B>;
+export declare function foldRight_<A, B, R, E>(as: Iterable<A>, b: UIO<B>, f: (a: A, b: IO<R, E, B>) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, B>;
 /**
  * Applies the function `f` to each element of the `Iterable<A>` and
  * returns the results in a new `Conc<B>`.
@@ -427,25 +427,25 @@ export declare function foreach_<A, R, E, B>(as: Iterable<A>, f: (a: A) => IO<R,
  * @tsplus static fncts.io.IOOps foreachWithIndex
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function foreachWithIndex_<A, R, E, B>(as: Iterable<A>, f: (i: number, a: A) => IO<R, E, B>): IO<R, E, Conc<B>>;
+export declare function foreachWithIndex_<A, R, E, B>(as: Iterable<A>, f: (i: number, a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;
 /**
  * @tsplus static fncts.io.IOOps foreachWithIndexDiscard
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function foreachWithIndexDiscard_<A, R, E, B>(as: Iterable<A>, f: (i: number, a: A) => IO<R, E, B>): IO<R, E, void>;
+export declare function foreachWithIndexDiscard_<A, R, E, B>(as: Iterable<A>, f: (i: number, a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, void>;
 /**
  * Applies the function `f` to each element of the `Iterable<A>` and runs
  * produced IOs sequentially.
  * @tsplus static fncts.io.IOOps foreachDiscard
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function foreachDiscard_<A, R, E, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>): IO<R, E, void>;
+export declare function foreachDiscard_<A, R, E, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, void>;
 /**
  * Repeats this effect forever (until the first failure).
  * @tsplus getter fncts.io.IO forever
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function forever<R, E, A>(ma: IO<R, E, A>): IO<R, E, never>;
+export declare function forever<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, never>;
 /**
  * Returns an IO that forks this IO into its own separate fiber,
  * returning the fiber immediately, without waiting for it to begin executing
@@ -476,19 +476,19 @@ export declare function fork<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string):
  * @tsplus static fncts.io.IOOps fromEither
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function fromEither<E, A>(either: Lazy<Either<E, A>>, __tsplusTrace?: string): IO<unknown, E, A>;
+export declare function fromEither<E, A>(either: Lazy<Either<E, A>>, __tsplusTrace?: string): IO<never, E, A>;
 /**
  * Lifts an `Either` into an `IO`
  * @tsplus static fncts.io.IOOps fromEitherNow
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function fromEitherNow<E, A>(either: Either<E, A>, __tsplusTrace?: string): IO<unknown, E, A>;
+export declare function fromEitherNow<E, A>(either: Either<E, A>, __tsplusTrace?: string): IO<never, E, A>;
 /**
  * Lifts an `Eval` into an `IO`
  * @tsplus static fncts.io.IOOps fromEval
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function fromEval<A>(computation: Eval<A>, __tsplusTrace?: string): IO<unknown, never, A>;
+export declare function fromEval<A>(computation: Eval<A>, __tsplusTrace?: string): IO<never, never, A>;
 /**
  * Creates a `IO` from an exit value
  * @tsplus static fncts.io.IOOps fromExit
@@ -538,31 +538,31 @@ export declare function fromPromiseHalt<A>(promise: Lazy<Promise<A>>, __tsplusTr
  * @tsplus getter fncts.io.IO get
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function get<R, E, A>(ma: IO<R, E, Maybe<A>>): IO<R, Maybe<E>, A>;
+export declare function get<R, E, A>(ma: IO<R, E, Maybe<A>>, __tsplusTrace?: string): IO<R, Maybe<E>, A>;
 /**
  * Extracts the optional value, or returns the given 'orElse'.
  * @tsplus fluent fncts.io.IO getOrElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function getOrElse_<R, E, A, B>(ma: IO<R, E, Maybe<A>>, orElse: Lazy<B>): IO<R, E, A | B>;
+export declare function getOrElse_<R, E, A, B>(ma: IO<R, E, Maybe<A>>, orElse: Lazy<B>, __tsplusTrace?: string): IO<R, E, A | B>;
 /**
  * Extracts the optional value, or executes the effect 'orElse'.
  * @tsplus fluent fncts.io.IO getOrElseIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function getOrElseIO_<R, E, A, R1, E1, B>(ma: IO<R, E, Maybe<A>>, orElse: Lazy<IO<R1, E1, B>>): IO<R & R1, E | E1, A | B>;
+export declare function getOrElseIO_<R, E, A, R1, E1, B>(ma: IO<R, E, Maybe<A>>, orElse: Lazy<IO<R1, E1, B>>, __tsplusTrace?: string): IO<R | R1, E | E1, A | B>;
 /**
  * Lifts a Maybe into an IO. If the option is `Nothing`, fail with `onNothing`.
  * @tsplus static fncts.io.IOOps getOrFailWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function getOrFailWith_<E, A>(maybe: Maybe<A>, onNothing: Lazy<E>): FIO<E, A>;
+export declare function getOrFailWith_<E, A>(maybe: Maybe<A>, onNothing: Lazy<E>, __tsplusTrace?: string): FIO<E, A>;
 /**
  * Lifts a Maybe into a IO, if the Maybe is `Nothing` it fails with Unit.
  * @tsplus static fncts.io.IOOps getOrFailUnit
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function getOrFailUnit<A>(option: Maybe<A>): FIO<void, A>;
+export declare function getOrFailUnit<A>(option: Maybe<A>, __tsplusTrace?: string): FIO<void, A>;
 /**
  * Creates an `IO` that halts with the specified lazily-evaluated defect.
  * This method can be used for terminating a fiber because a defect has been
@@ -583,29 +583,29 @@ export declare function haltNow(e: unknown, __tsplusTrace?: string): UIO<never>;
  * @tsplus fluent fncts.io.IO ifIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function ifIO_<R, E, R1, E1, B, R2, E2, C>(self: IO<R, E, boolean>, onFalse: Lazy<IO<R1, E1, B>>, onTrue: Lazy<IO<R2, E2, C>>): IO<R & R1 & R2, E | E1 | E2, B | C>;
+export declare function ifIO_<R, E, R1, E1, B, R2, E2, C>(self: IO<R, E, boolean>, onFalse: Lazy<IO<R1, E1, B>>, onTrue: Lazy<IO<R2, E2, C>>, __tsplusTrace?: string): IO<R | R1 | R2, E | E1 | E2, B | C>;
 /**
  * @tsplus static fncts.io.IOOps if
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function if_<R, E, A, R1, E1, A1>(b: boolean, onTrue: Lazy<IO<R, E, A>>, onFalse: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R & R1, E | E1, A | A1>;
+export declare function if_<R, E, A, R1, E1, A1>(b: boolean, onTrue: Lazy<IO<R, E, A>>, onFalse: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R | R1, E | E1, A | A1>;
 /**
  * @tsplus getter fncts.io.IO ignore
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function ignore<R, E, A>(fa: IO<R, E, A>): URIO<R, void>;
+export declare function ignore<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string): URIO<R, void>;
 /**
  * Folds a `IO` to a boolean describing whether or not it is a failure
  * @tsplus getter fncts.io.IO isFailure
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function isFailure<R, E, A>(ma: IO<R, E, A>): IO<R, never, boolean>;
+export declare function isFailure<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, boolean>;
 /**
  * Folds a `IO` to a boolean describing whether or not it is a success
  * @tsplus getter fncts.io.IO isSuccess
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function isSuccess<R, E, A>(ma: IO<R, E, A>): IO<R, never, boolean>;
+export declare function isSuccess<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, boolean>;
 /**
  * Iterates with the specified effectual function. The moral equivalent of:
  *
@@ -627,7 +627,7 @@ export declare function iterate_<R, E, A>(initial: A, cont: (a: A) => boolean, b
  * @tsplus static fncts.io.IOOps left
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function left<A>(a: Lazy<A>): UIO<Either<A, never>>;
+export declare function left<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Either<A, never>>;
 /**
  * @tsplus static fncts.io.IOOps log
  * @tsplus location "@fncts/io/IO/api"
@@ -708,12 +708,12 @@ export declare function matchCause_<R, E, A, A1, A2>(self: IO<R, E, A>, onFailur
  * @tsplus fluent fncts.io.IO matchCauseIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function matchCauseIO_<R, E, A, R1, E1, A1, R2, E2, A2>(self: IO<R, E, A>, onFailure: (cause: Cause<E>) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): IO<R & R1 & R2, E1 | E2, A1 | A2>;
+export declare function matchCauseIO_<R, E, A, R1, E1, A1, R2, E2, A2>(self: IO<R, E, A>, onFailure: (cause: Cause<E>) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): IO<R | R1 | R2, E1 | E2, A1 | A2>;
 /**
  * @tsplus fluent fncts.io.IO matchIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function matchIO_<R, R1, R2, E, E1, E2, A, A1, A2>(self: IO<R, E, A>, onFailure: (e: E) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): IO<R & R1 & R2, E1 | E2, A1 | A2>;
+export declare function matchIO_<R, R1, R2, E, E1, E2, A, A1, A2>(self: IO<R, E, A>, onFailure: (e: E) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): IO<R | R1 | R2, E1 | E2, A1 | A2>;
 /**
  * Folds over the failure value or the success value to yield an IO that
  * does not fail, but succeeds with the value returned by the left or right
@@ -727,7 +727,7 @@ export declare function match_<R, E, A, B, C>(self: IO<R, E, A>, onFailure: (e:
  * @tsplus fluent fncts.io.IO matchTraceIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function matchTraceIO_<R, E, A, R1, E1, A1, R2, E2, A2>(ma: IO<R, E, A>, onFailure: (e: E, trace: Trace) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): IO<R & R1 & R2, E1 | E2, A1 | A2>;
+export declare function matchTraceIO_<R, E, A, R1, E1, A1, R2, E2, A2>(ma: IO<R, E, A>, onFailure: (e: E, trace: Trace) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): IO<R | R1 | R2, E1 | E2, A1 | A2>;
 /**
  * @tsplus getter fncts.io.IO maybe
  * @tsplus location "@fncts/io/IO/api"
@@ -756,7 +756,7 @@ export declare const never: UIO<never>;
  * @tsplus getter fncts.io.IO optional
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function optional<R, E, A>(ma: IO<R, Maybe<E>, A>): IO<R, E, Maybe<A>>;
+export declare function optional<R, E, A>(ma: IO<R, Maybe<E>, A>, __tsplusTrace?: string): IO<R, E, Maybe<A>>;
 /**
  * Returns the logical disjunction of the `Boolean` value returned by this
  * effect and the `Boolean` value returned by the specified effect. This
@@ -765,27 +765,27 @@ export declare function optional<R, E, A>(ma: IO<R, Maybe<E>, A>): IO<R, E, Mayb
  * @tsplus fluent fncts.io.IO or
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function or_<R, E, R1, E1>(ma: IO<R, E, boolean>, mb: IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R & R1, E | E1, boolean>;
+export declare function or_<R, E, R1, E1>(ma: IO<R, E, boolean>, mb: IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R | R1, E | E1, boolean>;
 /**
  * @tsplus fluent fncts.io.IO orElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElse_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R & R1, E1, A | A1>;
+export declare function orElse_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R | R1, E1, A | A1>;
 /**
  * @tsplus fluent fncts.io.IO orElseEither
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElseEither_<R, E, A, R1, E1, A1>(self: IO<R, E, A>, that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R & R1, E1, Either<A, A1>>;
+export declare function orElseEither_<R, E, A, R1, E1, A1>(self: IO<R, E, A>, that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): IO<R | R1, E1, Either<A, A1>>;
 /**
  * @tsplus fluent fncts.io.IO orElseFail
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElseFail_<R, E, A, E1>(ma: IO<R, E, A>, e: Lazy<E1>): IO<R, E1, A>;
+export declare function orElseFail_<R, E, A, E1>(ma: IO<R, E, A>, e: Lazy<E1>, __tsplusTrace?: string): IO<R, E1, A>;
 /**
  * @tsplus fluent fncts.io.IO orElseMaybe
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElseMaybe_<R, E, A, R1, E1, A1>(ma: IO<R, Maybe<E>, A>, that: Lazy<IO<R1, Maybe<E1>, A1>>, __tsplusTrace?: string): IO<R & R1, Maybe<E | E1>, A | A1>;
+export declare function orElseMaybe_<R, E, A, R1, E1, A1>(ma: IO<R, Maybe<E>, A>, that: Lazy<IO<R1, Maybe<E1>, A1>>, __tsplusTrace?: string): IO<R | R1, Maybe<E | E1>, A | A1>;
 /**
  * @tsplus fluent fncts.io.IO orElseSucceed
  * @tsplus location "@fncts/io/IO/api"
@@ -800,7 +800,7 @@ export declare function orHalt<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string)
  * @tsplus getter fncts.io.IO orHaltKeep
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orHaltKeep<R, E, A>(ma: IO<R, E, A>): IO<R, never, A>;
+export declare function orHaltKeep<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, A>;
 /**
  * @tsplus fluent fncts.io.IO orHaltWith
  * @tsplus location "@fncts/io/IO/api"
@@ -811,7 +811,7 @@ export declare function orHaltWith_<R, E, A>(ma: IO<R, E, A>, f: (e: E) => unkno
  * @tsplus fluent fncts.io.IO parallelErrors
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function parallelErrors<R, E, A>(io: IO<R, E, A>): IO<R, List<E>, A>;
+export declare function parallelErrors<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, List<E>, A>;
 /**
  * Feeds elements of type `A` to a function `f` that returns an IO.
  * Collects all successes and failures in a separated fashion.
@@ -831,7 +831,7 @@ export declare function refineOrHalt_<R, E, A, E1>(fa: IO<R, E, A>, pf: (e: E) =
  * @tsplus fluent fncts.io.IO refineOrHaltWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function refineOrHaltWith_<R, E, A, E1>(fa: IO<R, E, A>, pf: (e: E) => Maybe<E1>, f: (e: E) => unknown): IO<R, E1, A>;
+export declare function refineOrHaltWith_<R, E, A, E1>(fa: IO<R, E, A>, pf: (e: E) => Maybe<E1>, f: (e: E) => unknown, __tsplusTrace?: string): IO<R, E1, A>;
 /**
  * Fail with the returned value if the partial function `pf` matches, otherwise
  * continue with the held value.
@@ -846,7 +846,7 @@ export declare function reject_<R, E, A, E1>(fa: IO<R, E, A>, pf: (a: A) => Mayb
  * @tsplus fluent fncts.io.IO rejectIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function rejectIO_<R, E, A, R1, E1>(fa: IO<R, E, A>, pf: (a: A) => Maybe<IO<R1, E1, E1>>, __tsplusTrace?: string): IO<R & R1, E | E1, A>;
+export declare function rejectIO_<R, E, A, R1, E1>(fa: IO<R, E, A>, pf: (a: A) => Maybe<IO<R1, E1, E1>>, __tsplusTrace?: string): IO<R | R1, E | E1, A>;
 /**
  * Repeats this effect the specified number of times.
  * @tsplus fluent fncts.io.IO repeatN
@@ -864,19 +864,19 @@ export declare function repeatUntil_<R, E, A>(ma: IO<R, E, A>, f: (a: A) => bool
  * @tsplus fluent fncts.io.IO repeatUntilIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatUntilIO_<R, E, A, R1, E1>(ma: IO<R, E, A>, f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R & R1, E | E1, A>;
+export declare function repeatUntilIO_<R, E, A, R1, E1>(ma: IO<R, E, A>, f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R | R1, E | E1, A>;
 /**
  * Repeats this effect while its error satisfies the specified predicate.
  * @tsplus fluent fncts.io.IO repeatWhile
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatWhile_<R, E, A>(ma: IO<R, E, A>, f: (a: A) => boolean): IO<R, E, A>;
+export declare function repeatWhile_<R, E, A>(ma: IO<R, E, A>, f: (a: A) => boolean, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Repeats this effect while its error satisfies the specified effectful predicate.
  * @tsplus fluent fncts.io.IO repeatWhileIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatWhileIO_<R, E, A, R1, E1>(ma: IO<R, E, A>, f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R & R1, E | E1, A>;
+export declare function repeatWhileIO_<R, E, A, R1, E1>(ma: IO<R, E, A>, f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.io.IO replicate
  * @tsplus location "@fncts/io/IO/api"
@@ -899,7 +899,7 @@ export declare function result<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string)
  *
  * @trace call
  */
-export declare function resurrect<R, E, A>(io: IO<R, E, A>): IO<R, unknown, A>;
+export declare function resurrect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A>;
 /**
  * Retries this effect until its error satisfies the specified predicate.
  * @tsplus fluent fncts.io.IO retryUntil
@@ -911,7 +911,7 @@ export declare function retryUntil_<R, E, A>(fa: IO<R, E, A>, f: (e: E) => boole
  * @tsplus fluent fncts.io.IO retryUntilIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function retryUntilIO_<R, E, A, R1, E1>(fa: IO<R, E, A>, f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R & R1, E | E1, A>;
+export declare function retryUntilIO_<R, E, A, R1, E1>(fa: IO<R, E, A>, f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R | R1, E | E1, A>;
 /**
  * Retries this effect while its error satisfies the specified predicate.
  * @tsplus fluent fncts.io.IO retryWhile
@@ -923,7 +923,7 @@ export declare function retryWhile_<R, E, A>(fa: IO<R, E, A>, f: (e: E) => boole
  * @tsplus fluent fncts.io.IO retryWhileIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function retryWhileIO_<R, E, A, R1, E1>(fa: IO<R, E, A>, f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R & R1, E | E1, A>;
+export declare function retryWhileIO_<R, E, A, R1, E1>(fa: IO<R, E, A>, f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R | R1, E | E1, A>;
 /**
  * Retrieves the runtimeConfig that this effect is running on.
  * @tsplus static fncts.io.IOOps runtimeConfig
@@ -951,7 +951,7 @@ export declare function setRuntimeConfig(runtimeConfig: Lazy<RuntimeConfig>, __t
  * @tsplus static fncts.io.IOOps sequenceIterable
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function sequenceIterable<R, E, A>(as: Iterable<IO<R, E, A>>): IO<R, E, Conc<A>>;
+export declare function sequenceIterable<R, E, A>(as: Iterable<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, Conc<A>>;
 /**
  * @tsplus static fncts.io.IOOps sequenceIterableDiscard
  * @tsplus location "@fncts/io/IO/api"
@@ -962,7 +962,7 @@ export declare function sequenceIterableDiscard<R, E, A>(as: Iterable<IO<R, E, A
  * @tsplus static fncts.io.IOOps succeedNow
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function succeedNow<A>(value: A, __tsplusTrace?: string): IO<unknown, never, A>;
+export declare function succeedNow<A>(value: A, __tsplusTrace?: string): IO<never, never, A>;
 /**
  * Imports a total synchronous effect into a pure `IO` value.
  * The effect must not throw any exceptions. If you wonder if the effect
@@ -984,25 +984,25 @@ export declare function supervised_<R, E, A>(fa: IO<R, E, A>, supervisor: Superv
  * @tsplus fluent fncts.io.IO summarized
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function summarized_<R, E, A, R1, E1, B, C>(ma: IO<R, E, A>, summary: IO<R1, E1, B>, f: (start: B, end: B) => C, __tsplusTrace?: string): IO<R & R1, E | E1, readonly [C, A]>;
+export declare function summarized_<R, E, A, R1, E1, B, C>(ma: IO<R, E, A>, summary: IO<R1, E1, B>, f: (start: B, end: B) => C, __tsplusTrace?: string): IO<R | R1, E | E1, readonly [C, A]>;
 /**
  * Swaps the positions of a Bifunctor's arguments
  * @tsplus getter fncts.io.IO swap
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function swap<R, E, A>(pab: IO<R, E, A>): IO<R, A, E>;
+export declare function swap<R, E, A>(pab: IO<R, E, A>, __tsplusTrace?: string): IO<R, A, E>;
 /**
  * Swaps the error/value parameters, applies the function `f` and flips the parameters back
  * @tsplus fluent fncts.io.IO swapWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function swapWith_<R, E, A, R1, E1, A1>(fa: IO<R, E, A>, f: (ma: IO<R, A, E>) => IO<R1, A1, E1>): IO<R1, E1, A1>;
+export declare function swapWith_<R, E, A, R1, E1, A1>(fa: IO<R, E, A>, f: (ma: IO<R, A, E>) => IO<R1, A1, E1>, __tsplusTrace?: string): IO<R1, E1, A1>;
 /**
  * A more powerful variation of `timed` that allows specifying the clock.
  * @tsplus fluent fncts.io.IO timedWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function timedWith_<R, E, A, R1, E1>(ma: IO<R, E, A>, msTime: IO<R1, E1, number>, __tsplusTrace?: string): IO<R & R1, E | E1, readonly [number, A]>;
+export declare function timedWith_<R, E, A, R1, E1>(ma: IO<R, E, A>, msTime: IO<R1, E1, number>, __tsplusTrace?: string): IO<R | R1, E | E1, readonly [number, A]>;
 /**
  * Creates a `IO` that has succeeded with a pure value
  * @tsplus static fncts.io.IOOps tryCatch
@@ -1023,32 +1023,32 @@ export declare function absolve<R, E, E1, A>(ma: IO<R, E, Either<E1, A>>, __tspl
  * @tsplus fluent fncts.io.IO tap
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tap_<R, E, A, R1, E1, B>(self: IO<R, E, A>, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): IO<R1 & R, E1 | E, A>;
+export declare function tap_<R, E, A, R1, E1, B>(self: IO<R, E, A>, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): IO<R1 | R, E1 | E, A>;
 /**
  * Returns an IO that effectually "peeks" at the cause of the failure of
  * this IO.
  * @tsplus fluent fncts.io.IO tapCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tapCause_<R2, A2, R, E, E2>(ma: IO<R2, E2, A2>, f: (e: Cause<E2>) => IO<R, E, any>, __tsplusTrace?: string): IO<R2 & R, E | E2, A2>;
+export declare function tapCause_<R2, A2, R, E, E2>(ma: IO<R2, E2, A2>, f: (e: Cause<E2>) => IO<R, E, any>, __tsplusTrace?: string): IO<R2 | R, E | E2, A2>;
 /**
  * Returns an IO that effectfully "peeks" at the failure of this effect.
  * @tsplus fluent fncts.io.IO tapError
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tapError_<R, E, A, R1, E1>(self: IO<R, E, A>, f: (e: E) => IO<R1, E1, any>, __tsplusTrace?: string): IO<R & R1, E | E1, A>;
+export declare function tapError_<R, E, A, R1, E1>(self: IO<R, E, A>, f: (e: E) => IO<R1, E1, any>, __tsplusTrace?: string): IO<R | R1, E | E1, A>;
 /**
  * Returns an effect that effectually "peeks" at the cause of the failure of
  * this effect.
  * @tsplus fluent fncts.io.IO tapErrorCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tapErrorCause_<R, E, A, R1, E1>(self: IO<R, E, A>, f: (e: Cause<E>) => IO<R1, E1, any>, __tsplusTrace?: string): IO<R & R1, E | E1, A>;
+export declare function tapErrorCause_<R, E, A, R1, E1>(self: IO<R, E, A>, f: (e: Cause<E>) => IO<R1, E1, any>, __tsplusTrace?: string): IO<R | R1, E | E1, A>;
 /**
  * @tsplus fluent fncts.io.IO tryOrElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tryOrElse_<R, E, A, R1, E1, A1, R2, E2, A2>(ma: IO<R, E, A>, that: Lazy<IO<R1, E1, A1>>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): IO<R & R1 & R2, E1 | E2, A1 | A2>;
+export declare function tryOrElse_<R, E, A, R1, E1, A1, R2, E2, A2>(ma: IO<R, E, A>, that: Lazy<IO<R1, E1, A1>>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): IO<R | R1 | R2, E1 | E2, A1 | A2>;
 /**
  * @tsplus static fncts.io.IOOps unit
  * @tsplus location "@fncts/io/IO/api"
@@ -1059,7 +1059,7 @@ export declare const unit: UIO<void>;
  * @tsplus getter fncts.io.IO unjust
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function unjust<R, E, A>(self: IO<R, Maybe<E>, A>): IO<R, E, Maybe<A>>;
+export declare function unjust<R, E, A>(self: IO<R, Maybe<E>, A>, __tsplusTrace?: string): IO<R, E, Maybe<A>>;
 /**
  * Takes some fiber failures and converts them into errors, using the
  * specified function to convert the `E` into an `E1 | E2`.
@@ -1072,7 +1072,7 @@ export declare function unrefineWith_<R, E, A, E1, E2>(fa: IO<R, E, A>, pf: (u:
  * @tsplus getter fncts.io.IO unsandbox
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function unsandbox<R, E, A>(ma: IO<R, Cause<E>, A>): IO<R, E, A>;
+export declare function unsandbox<R, E, A>(ma: IO<R, Cause<E>, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Updates the `FiberRef` values for the fiber running this effect using the
  * specified function
@@ -1095,7 +1095,7 @@ export declare function when_<R, E, A>(ma: IO<R, E, A>, b: Lazy<boolean>, __tspl
  * @tsplus fluent fncts.io.IO whenIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function whenIO_<R, E, A, R1, E1>(ma: IO<R, E, A>, mb: IO<R1, E1, boolean>): IO<R1 & R, E | E1, void>;
+export declare function whenIO_<R, E, A, R1, E1>(ma: IO<R, E, A>, mb: IO<R1, E1, boolean>, __tsplusTrace?: string): IO<R1 | R, E | E1, void>;
 /**
  * Returns an effect that yields to the runtime system, starting on a fresh
  * stack. Manual use of this method can improve fairness, at the cost of
@@ -1108,16 +1108,16 @@ export declare const yieldNow: UIO<void>;
  * @tsplus fluent fncts.io.IO zip
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function zip_<R, E, A, R1, E1, B>(self: IO<R, E, A>, that: IO<R1, E1, B>): IO<R & R1, E | E1, readonly [A, B]>;
+export declare function zip_<R, E, A, R1, E1, B>(self: IO<R, E, A>, that: IO<R1, E1, B>, __tsplusTrace?: string): IO<R | R1, E | E1, readonly [A, B]>;
 /**
  * @tsplus fluent fncts.io.IO zipWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function zipWith_<R, E, A, R1, E1, B, C>(self: IO<R, E, A>, that: IO<R1, E1, B>, f: (a: A, b: B) => C): IO<R & R1, E | E1, C>;
+export declare function zipWith_<R, E, A, R1, E1, B, C>(self: IO<R, E, A>, that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): IO<R | R1, E | E1, C>;
 export declare class GenIO<R, E, A> {
     readonly effect: IO<R, E, A>;
     readonly _trace?: string | undefined;
-    readonly _R: (_R: R) => void;
+    readonly _R: () => R;
     readonly _E: () => E;
     readonly _A: () => A;
     constructor(effect: IO<R, E, A>, _trace?: string | undefined);
@@ -1134,4 +1134,4 @@ export declare const __adapter: (_: any) => any;
  */
 export declare function gen<T extends GenIO<any, any, any>, A>(f: (i: {
     <R, E, A>(_: IO<R, E, A>, __tsplusTrace?: string): GenIO<R, E, A>;
-}) => Generator<T, A, any>): IO<_R<T>, _E<T>, A>;
+}) => Generator<T, A, any>, __tsplusTrace?: string): IO<_R<T>, _E<T>, A>;