@fncts/io 0.0.38 → 0.0.40

package/Stream/api.d.ts

@@ -45,13 +45,13 @@ export declare function absolve<R, E, E2, A>(self: Stream<R, E, Either<E2, A>>,
  * @tsplus pipeable fncts.io.Stream aggregateAsync
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function aggregateAsync<R1, E1, A1, B>(sink: Sink<R1, E1, A1, A1, B>, __tsplusTrace?: string): <R, E, A extends A1>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function aggregateAsync<R1, E1, A1, B>(sink: Sink<R1, E1, A1, A1, B>, __tsplusTrace?: string): <R, E, A extends A1>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Like `aggregateAsyncWithinEither`, but only returns the `Right` results.
  * @tsplus pipeable fncts.io.Stream aggregateAsyncWithin
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function aggregateAsyncWithin<R1, E1, A1, B, R2, C>(sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>, __tsplusTrace?: string): <R, E, A extends A1>(stream: Stream<R, E, A>) => Stream<R1 | R2 | R, E1 | E, B>;
+export declare function aggregateAsyncWithin<R1, E1, A1, B, R2, C>(sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>, __tsplusTrace?: string): <R, E, A extends A1>(stream: Stream<R, E, A>) => Stream<R | R1 | R2, E | E1, B>;
 /**
  * Aggregates elements using the provided sink until it completes, or until the
  * delay signalled by the schedule has passed.
@@ -66,7 +66,7 @@ export declare function aggregateAsyncWithin<R1, E1, A1, B, R2, C>(sink: Sink<R1
  * @tsplus pipeable fncts.io.Stream aggregateAsyncWithinEither
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>, __tsplusTrace?: string): <R, E, A extends A1>(stream: Stream<R, E, A>) => Stream<R1 | R2 | R, E1 | E, import("@fncts/base/data/Either.js").Either<C, B>>;
+export declare function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>, __tsplusTrace?: string): <R, E, A extends A1>(stream: Stream<R, E, A>) => Stream<R | R1 | R2, E | E1, Either<C, B>>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements,
  * but keeps only elements from this stream.
@@ -74,7 +74,7 @@ export declare function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(sink: S
  * @tsplus pipeable fncts.io.Stream zipLeft
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function zipLeft<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function zipLeft<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements,
  * but keeps only elements from the other stream.
@@ -82,7 +82,7 @@ export declare function zipLeft<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTr
  * @tsplus pipeable fncts.io.Stream zipRight
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function zipRight<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A1>;
+export declare function zipRight<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, A1>;
 /**
  * Maps the success values of this stream to the specified constant value.
  * @tsplus pipeable fncts.io.Stream as
@@ -141,7 +141,7 @@ export declare function acquireReleaseExit<R, E, A, R1>(acquire: IO<R, E, A>, re
  * @tsplus pipeable fncts.io.Stream broadcast
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcast(n: number, maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<Stream<unknown, E, A>>>;
+export declare function broadcast(n: number, maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => IO<R | Scope, never, Conc<Stream<unknown, E, A>>>;
 /**
  * Fan out the stream, producing a dynamic number of streams that have the same elements as this stream.
  * The driver stream will only ever advance of the `maximumLag` chunks before the
@@ -149,7 +149,7 @@ export declare function broadcast(n: number, maximumLag: number, __tsplusTrace?:
  * @tsplus pipeable fncts.io.Stream broadcastDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastDynamic(maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Stream<unknown, E, A>>;
+export declare function broadcastDynamic(maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => IO<R | Scope, never, Stream<unknown, E, A>>;
 /**
  * Converts the stream to a managed list of queues. Every value will be replicated to every queue with the
  * slowest queue being allowed to buffer `maximumLag` chunks before the driver is backpressured.
@@ -158,7 +158,7 @@ export declare function broadcastDynamic(maximumLag: number, __tsplusTrace?: str
  * @tsplus pipeable fncts.io.Stream broadcastedQueues
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastedQueues(n: number, maximumLag: number, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<Queue.Dequeue<Take<E, A>>>>;
+export declare function broadcastedQueues(n: number, maximumLag: number, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => IO<R | Scope, never, Conc<Queue.Dequeue<Take<E, A>>>>;
 /**
  * Converts the stream to a managed dynamic amount of queues. Every chunk will be replicated to every queue with the
  * slowest queue being allowed to buffer `maximumLag` chunks before the driver is backpressured.
@@ -167,7 +167,7 @@ export declare function broadcastedQueues(n: number, maximumLag: number, __tsplu
  * @tsplus pipeable fncts.io.Stream broadcastedQueuesDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastedQueuesDynamic(maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../IO.js").IO<import("../Scope.js").Scope, never, Queue.Dequeue<Take<E, A>>>>;
+export declare function broadcastedQueuesDynamic(maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => IO<R | Scope, never, IO<Scope, never, Queue.Dequeue<Take<E, A>>>>;
 /**
  * Allows a faster producer to progress independently of a slower consumer by buffering
  * up to `capacity` elements in a queue.
@@ -193,7 +193,7 @@ export declare function bufferUnbounded<R, E, A>(stream: Stream<R, E, A>, __tspl
  * @tsplus pipeable fncts.io.Stream catchAll
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function catchAll<R1, E, E1, A1>(f: (e: E) => Stream<R1, E1, A1>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1, A1 | A>;
+export declare function catchAll<R1, E, E1, A1>(f: (e: E) => Stream<R1, E1, A1>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R | R1, E1, A | A1>;
 /**
  * Switches over to the stream produced by the provided function in case this one
  * fails. Allows recovery from all causes of failure, including interruption if the
@@ -201,14 +201,14 @@ export declare function catchAll<R1, E, E1, A1>(f: (e: E) => Stream<R1, E1, A1>,
  * @tsplus pipeable fncts.io.Stream catchAllCause
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function catchAllCause<R1, E, E1, A1>(f: (cause: Cause<E>) => Stream<R1, E1, A1>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1, A1 | A>;
+export declare function catchAllCause<R1, E, E1, A1>(f: (cause: Cause<E>) => Stream<R1, E1, A1>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R | R1, E1, A | A1>;
 /**
  * Switches over to the stream produced by the provided function in case this one
  * fails with some typed error.
  * @tsplus pipeable fncts.io.Stream catchJust
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function catchJust<R1, E, E1, A1>(pf: (e: E) => Maybe<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E | E1, A1 | A>;
+export declare function catchJust<R1, E, E1, A1>(pf: (e: E) => Maybe<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, A | A1>;
 /**
  * Switches over to the stream produced by the provided function in case this one
  * fails with some errors. Allows recovery from all causes of failure, including interruption if the
@@ -216,14 +216,14 @@ export declare function catchJust<R1, E, E1, A1>(pf: (e: E) => Maybe<Stream<R1,
  * @tsplus pipeable fncts.io.Stream catchJustCause
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function catchJustCause<R1, E, E1, A1>(pf: (e: Cause<E>) => Maybe<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E | E1, A1 | A>;
+export declare function catchJustCause<R1, E, E1, A1>(pf: (e: Cause<E>) => Maybe<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, A | A1>;
 /**
  * Returns a stream made of the concatenation in strict order of all the streams
  * produced by passing each element of this stream to `f`
  * @tsplus pipeable fncts.io.Stream flatMap
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function flatMap<A, R1, E1, B>(f: (a: A) => Stream<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function flatMap<A, R1, E1, B>(f: (a: A) => Stream<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Exposes the underlying chunks of the stream as a stream of chunks of elements
  * @tsplus getter fncts.io.Stream chunks
@@ -281,14 +281,14 @@ export declare function combineChunks<R, E, A, R1, E1, A1, S, R2, A2>(that: Stre
  * @tsplus pipeable fncts.io.Stream concat
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function concat<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A1 | A>;
+export declare function concat<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, A | A1>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements.
  * The `that` stream would be run multiple times, for every element in the `this` stream.
  * @tsplus pipeable fncts.io.Stream cross
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function cross<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, readonly [A, B]>;
+export declare function cross<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, readonly [A, B]>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements
  * with a specified function.
@@ -296,7 +296,7 @@ export declare function cross<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?
  * @tsplus pipeable fncts.io.Stream crossWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function crossWith<A, R1, E1, B, C>(fb: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, C>;
+export declare function crossWith<A, R1, E1, B, C>(fb: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, C>;
 /**
  * Provides some of the environment required to run this effect,
  * leaving the remainder `R0`.
@@ -319,7 +319,7 @@ export declare function defer<R, E, A>(self: Lazy<Stream<R, E, A>>): Stream<R, E
  * @tsplus pipeable fncts.io.Stream defaultIfEmpty
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function defaultIfEmpty<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | A>;
+export declare function defaultIfEmpty<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, A | B>;
 /**
  * More powerful version of `broadcast`. Allows to provide a function that determines what
  * queues should receive which elements. The decide function will receive the indices of the queues
@@ -327,7 +327,7 @@ export declare function defaultIfEmpty<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplu
  * @tsplus pipeable fncts.io.Stream distributedWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function distributedWith<A>(n: number, maximumLag: number, decide: (_: A) => UIO<(_: number) => boolean>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<Queue.Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>>>;
+export declare function distributedWith<A>(n: number, maximumLag: number, decide: (_: A) => UIO<(_: number) => boolean>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => IO<R | Scope, never, Conc<Queue.Dequeue<Exit<Maybe<E>, A>>>>;
 /**
  * More powerful version of `ZStream#distributedWith`. This returns a function that will produce
  * new queues and corresponding indices.
@@ -338,7 +338,7 @@ export declare function distributedWith<A>(n: number, maximumLag: number, decide
  * @tsplus pipeable fncts.io.Stream distributedWithDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function distributedWithDynamic<E, A>(maximumLag: number, decide: (a: A) => UIO<(_: symbol) => boolean>, done?: (exit: Exit<Maybe<E>, never>) => UIO<any>, __tsplusTrace?: string): <R>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../IO.js").UIO<readonly [symbol, Queue.Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>]>>;
+export declare function distributedWithDynamic<E, A>(maximumLag: number, decide: (a: A) => UIO<(_: symbol) => boolean>, done?: (exit: Exit<Maybe<E>, never>) => UIO<any>, __tsplusTrace?: string): <R>(self: Stream<R, E, A>) => IO<R | Scope, never, UIO<readonly [symbol, Queue.Dequeue<Exit<Maybe<E>, A>>]>>;
 /**
  * Converts this stream to a stream that executes its effects but emits no
  * elements. Useful for sequencing effects using streams.
@@ -391,12 +391,12 @@ export declare const empty: Stream<never, never, never>;
  * @tsplus pipeable fncts.io.Stream endWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function endWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function endWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.Stream ensuring
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E, A>;
+export declare function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R | R1, E, A>;
 /**
  * @tsplus static fncts.io.StreamOps environment
  * @tsplus location "@fncts/io/Stream/api"
@@ -460,7 +460,7 @@ export declare function filter<A>(predicate: Predicate<A>): <R, E>(fa: Stream<R,
  * @tsplus pipeable fncts.io.Stream filterIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function filterIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function filterIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.Stream filterMap
  * @tsplus location "@fncts/io/Stream/api"
@@ -470,7 +470,7 @@ export declare function filterMap<A, B>(f: (a: A) => Maybe<B>, __tsplusTrace?: s
  * @tsplus pipeable fncts.io.Stream filterMapIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function filterMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, Maybe<B>>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function filterMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, Maybe<B>>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Finds the first element emitted by this stream that satisfies the provided predicate.
  * @tsplus pipeable fncts.io.Stream find
@@ -482,7 +482,7 @@ export declare function find<A>(p: Predicate<A>, __tsplusTrace?: string): <R, E>
  * @tsplus pipeable fncts.io.Stream findIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function findIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function findIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * Flattens this stream-of-streams into a stream made of the concatenation in
  * strict order of all the streams.
@@ -540,7 +540,7 @@ export declare function scoped<R, E, A>(stream: Lazy<IO<R, E, A>>, __tsplusTrace
  * @tsplus pipeable fncts.io.Stream sliding
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function sliding(chunkSize: number, stepSize: number, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, import("@fncts/base/collection/immutable/Conc.js").Conc<A>>;
+export declare function sliding(chunkSize: number, stepSize: number, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Conc<A>>;
 /**
  * Creates a stream from an effect producing a value of type `A`
  * @tsplus static fncts.io.StreamOps fromIO
@@ -618,7 +618,7 @@ export declare function halt(u: Lazy<unknown>, __tsplusTrace?: string): Stream<n
  * @tsplus pipeable fncts.io.Stream haltWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function haltWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function haltWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * Halts the evaluation of this stream when the provided promise resolves.
  *
@@ -626,12 +626,12 @@ export declare function haltWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: st
  * @tsplus pipeable fncts.io.Stream haltWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function haltWhenFuture<E1>(future: Future<E1, any>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R, E1 | E, A>;
+export declare function haltWhenFuture<E1>(future: Future<E1, any>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.Stream interleave
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function interleave<R1, E1, B>(sb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(sa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | A>;
+export declare function interleave<R1, E1, B>(sb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(sa: Stream<R, E, A>) => Stream<R | R1, E | E1, A | B>;
 /**
  * Combines this stream and the specified stream deterministically using the
  * stream of boolean values `b` to control which stream to pull from next.
@@ -642,7 +642,7 @@ export declare function interleave<R1, E1, B>(sb: Stream<R1, E1, B>, __tsplusTra
  * @tsplus pipeable fncts.io.Stream interleaveWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function interleaveWith<R1, E1, B, R2, E2>(sb: Stream<R1, E1, B>, b: Stream<R2, E2, boolean>, __tsplusTrace?: string): <R, E, A>(sa: Stream<R, E, A>) => Stream<R1 | R2 | R, E1 | E2 | E, B | A>;
+export declare function interleaveWith<R1, E1, B, R2, E2>(sb: Stream<R1, E1, B>, b: Stream<R2, E2, boolean>, __tsplusTrace?: string): <R, E, A>(sa: Stream<R, E, A>) => Stream<R | R1 | R2, E | E1 | E2, A | B>;
 /**
  * Intersperse stream with provided element
  */
@@ -657,12 +657,12 @@ export declare function intersperse<R, E, A, A1>(stream: Stream<R, E, A>, middle
  * @tsplus pipeable fncts.io.Stream interruptWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function interruptWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function interruptWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.Stream interruptWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function interruptWhenFuture<E1>(future: Future<E1, unknown>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R, E1 | E, A>;
+export declare function interruptWhenFuture<E1>(future: Future<E1, unknown>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R, E | E1, A>;
 /**
  * Transforms the elements of this stream using the supplied function.
  * @tsplus pipeable fncts.io.Stream map
@@ -681,7 +681,7 @@ export declare function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [S,
  * @tsplus pipeable fncts.io.Stream mapAccumIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapAccumIO<A, R1, E1, S, B>(s: S, f: (s: S, a: A) => IO<R1, E1, readonly [B, S]>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function mapAccumIO<A, R1, E1, S, B>(s: S, f: (s: S, a: A) => IO<R1, E1, readonly [B, S]>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Transforms the chunks emitted by this stream.
  * @tsplus pipeable fncts.io.Stream mapChunks
@@ -693,7 +693,7 @@ export declare function mapChunks<A, A1>(f: (chunk: Conc<A>) => Conc<A1>, __tspl
  * @tsplus pipeable fncts.io.Stream mapChunksIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapChunksIO<A, R1, E1, B>(f: (chunk: Conc<A>) => IO<R1, E1, Conc<B>>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function mapChunksIO<A, R1, E1, B>(f: (chunk: Conc<A>) => IO<R1, E1, Conc<B>>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Maps each element to an iterable, and flattens the iterables into the
  * output of this stream.
@@ -714,14 +714,14 @@ export declare function mapConcatChunk<A, B>(f: (a: A) => Conc<B>, __tsplusTrace
  * @tsplus pipeable fncts.io.Stream mapConcatChunkIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapConcatChunkIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, Conc<B>>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function mapConcatChunkIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, Conc<B>>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Effectfully maps each element to an iterable, and flattens the iterables into
  * the output of this stream.
  * @tsplus pipeable fncts.io.Stream mapConcatIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapConcatIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, Iterable<B>>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function mapConcatIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, Iterable<B>>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Transforms the errors emitted by this stream using `f`.
  * @tsplus pipeable fncts.io.Stream mapError
@@ -739,7 +739,7 @@ export declare function mapErrorCause<E, E1>(f: (e: Cause<E>) => Cause<E1>, __ts
  * @tsplus pipeable fncts.io.Stream mapIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Maps over elements of the stream with the specified effectful function,
  * executing up to `n` invocations of `f` concurrently. Transformed elements
@@ -748,12 +748,12 @@ export declare function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplus
  * @tsplus pipeable fncts.io.Stream mapIOConcurrently
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapIOConcurrently<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function mapIOConcurrently<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Stream mapIOConcurrentlyUnordered
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapIOConcurrentlyUnordered<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>): <R, E>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function mapIOConcurrentlyUnordered<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>): <R, E>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Merges this stream and the specified stream together.
  *
@@ -762,42 +762,42 @@ export declare function mapIOConcurrentlyUnordered<A, R1, E1, B>(n: number, f: (
  * @tsplus pipeable fncts.io.Stream merge
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function merge<R1, E1, B>(that: Stream<R1, E1, B>, strategy?: TerminationStrategy, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | A>;
+export declare function merge<R1, E1, B>(that: Stream<R1, E1, B>, strategy?: TerminationStrategy, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, A | B>;
 /**
  * Merges this stream and the specified stream together. New produced stream
  * will terminate when either stream terminates.
  * @tsplus pipeable fncts.io.Stream mergeHaltEither
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeHaltEither<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | A>;
+export declare function mergeHaltEither<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, A | B>;
 /**
  * Merges this stream and the specified stream together. New produced stream
  * will terminate when this stream terminates.
  * @tsplus pipeable fncts.io.Stream mergeHaltLeft
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeHaltLeft<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | A>;
+export declare function mergeHaltLeft<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, A | B>;
 /**
  * Merges this stream and the specified stream together. New produced stream
  * will terminate when the specified stream terminates.
  * @tsplus pipeable fncts.io.Stream mergeHaltRight
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeHaltRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | A>;
+export declare function mergeHaltRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, A | B>;
 /**
  * Merges this stream and the specified stream together, discarding the values
  * from the right stream.
  * @tsplus pipeable fncts.io.Stream mergeLeft
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeLeft<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function mergeLeft<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * Merges this stream and the specified stream together, discarding the values
  * from the left stream.
  * @tsplus pipeable fncts.io.Stream mergeRight
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function mergeRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Maps each element of this stream to another stream and returns the
  * non-deterministic merge of those streams, executing up to `n` inner streams
@@ -806,7 +806,7 @@ export declare function mergeRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusT
  * @tsplus pipeable fncts.io.Stream mergeMap
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeMap<A, R1, E1, B>(f: (a: A) => Stream<R1, E1, B>, n: number, bufferSize?: number, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function mergeMap<A, R1, E1, B>(f: (a: A) => Stream<R1, E1, B>, n: number, bufferSize?: number, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Maps over elements of the stream with the specified effectful function,
  * executing up to `n` invocations of `f` concurrently. The element order
@@ -814,18 +814,18 @@ export declare function mergeMap<A, R1, E1, B>(f: (a: A) => Stream<R1, E1, B>, n
  * @tsplus pipeable fncts.io.Stream mergeMapIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, n: number, bufferSize?: number, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function mergeMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, n: number, bufferSize?: number, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Stream mergeEither
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeEither<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, import("@fncts/base/data/Either.js").Either<A, B>>;
+export declare function mergeEither<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, Either<A, B>>;
 export type TerminationStrategy = "Left" | "Right" | "Both" | "Either";
 /**
  * @tsplus pipeable fncts.io.Stream mergeWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeWith<A, R1, E1, A1, B, C>(sb: Stream<R1, E1, A1>, l: (a: A) => B, r: (b: A1) => C, strategy?: TerminationStrategy, __tsplusTrace?: string): <R, E>(sa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | C>;
+export declare function mergeWith<A, R1, E1, A1, B, C>(sb: Stream<R1, E1, A1>, l: (a: A) => B, r: (b: A1) => C, strategy?: TerminationStrategy, __tsplusTrace?: string): <R, E>(sa: Stream<R, E, A>) => Stream<R | R1, E | E1, B | C>;
 /**
  * Runs the specified effect if this stream fails, providing the error to the effect if it exists.
  *
@@ -833,7 +833,7 @@ export declare function mergeWith<A, R1, E1, A1, B, C>(sb: Stream<R1, E1, A1>, l
  * @tsplus pipeable fncts.io.Stream onError
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function onError<E, R1>(cleanup: (e: Cause<E>) => IO<R1, never, any>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E, A>;
+export declare function onError<E, R1>(cleanup: (e: Cause<E>) => IO<R1, never, any>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R | R1, E, A>;
 /**
  * Switches to the provided stream in case this one fails with a typed error.
  *
@@ -841,7 +841,7 @@ export declare function onError<E, R1>(cleanup: (e: Cause<E>) => IO<R1, never, a
  * @tsplus pipeable fncts.io.Stream orElse
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function orElse<R1, E1, A1>(that: Lazy<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1, A1 | A>;
+export declare function orElse<R1, E1, A1>(that: Lazy<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R | R1, E1, A | A1>;
 /**
  * Switches to the provided stream in case this one fails with a typed error.
  *
@@ -849,7 +849,7 @@ export declare function orElse<R1, E1, A1>(that: Lazy<Stream<R1, E1, A1>>, __tsp
  * @tsplus pipeable fncts.io.Stream orElseEither
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function orElseEither<R1, E1, A1>(that: Lazy<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1, import("@fncts/base/data/Either.js").Either<A, A1>>;
+export declare function orElseEither<R1, E1, A1>(that: Lazy<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R | R1, E1, Either<A, A1>>;
 /**
  * Fails with given error in case this one fails with a typed error.
  *
@@ -869,17 +869,17 @@ export declare function orElseOptional<R, E, A, R1, E1, A1>(stream: Stream<R, Ma
  * @tsplus pipeable fncts.io.Stream orElseSucceed
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function orElseSucceed<A1>(a: Lazy<A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, never, A1 | A>;
+export declare function orElseSucceed<A1>(a: Lazy<A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, never, A | A1>;
 /**
  * @tsplus pipeable fncts.io.Stream pipeThrough
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function pipeThrough<A, R1, E1, L, Z>(sa: Sink<R1, E1, A, L, Z>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R1 | R, E1 | E, L>;
+export declare function pipeThrough<A, R1, E1, L, Z>(sa: Sink<R1, E1, A, L, Z>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R | R1, E | E1, L>;
 /**
  * @tsplus pipeable fncts.io.Stream pipeThroughChannelOrFail
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function pipeThroughChannelOrFail<A, R1, E1, B>(channel: Channel<R1, never, Conc<A>, any, E1, Conc<B>, any>): <R, E>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function pipeThroughChannelOrFail<A, R1, E1, B>(channel: Channel<R1, never, Conc<A>, any, E1, Conc<B>, any>): <R, E>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Provides the stream with its required environment, which eliminates
  * its dependency on `R`.
@@ -891,12 +891,12 @@ export declare function provideEnvironment<R>(r: Environment<R>, __tsplusTrace?:
  * @tsplus pipeable fncts.io.Stream provideLayer
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function provideLayer<RIn, ROut, E1>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <E, A>(self: Stream<ROut, E, A>) => Stream<RIn, E1 | E, A>;
+export declare function provideLayer<RIn, ROut, E1>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <E, A>(self: Stream<ROut, E, A>) => Stream<RIn, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.Stream provideSomeLayer
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<RIn | Exclude<R, ROut>, E1 | E, A>;
+export declare function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<RIn | Exclude<R, ROut>, E | E1, A>;
 /**
  * Re-chunks the elements of the stream into chunks of
  * `n` elements each.
@@ -940,7 +940,7 @@ export declare function repeatIOChunkMaybe<R, E, A>(fa: IO<R, Maybe<E>, Conc<A>>
  * @tsplus pipeable fncts.io.Stream run
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function run<A, R2, E2, Z>(sink: Sink<R2, E2, A, unknown, Z>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => import("../IO.js").IO<R2 | R, E2 | E, Z>;
+export declare function run<A, R2, E2, Z>(sink: Sink<R2, E2, A, unknown, Z>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => IO<R | R2, E | E2, Z>;
 /**
  * Runs the stream and collects all of its elements to a chunk.
  * @tsplus getter fncts.io.Stream runCollect
@@ -957,41 +957,41 @@ export declare function runDrain<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace
  * @tsplus pipeable fncts.io.Stream runForeachScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runForeachScoped<A, R2, E2>(f: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R2 | R, E2 | E, void>;
+export declare function runForeachScoped<A, R2, E2>(f: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => IO<R | R2 | Scope, E | E2, void>;
 /**
  * Like `into`, but provides the result as a `Managed` to allow for scope
  * composition.
  * @tsplus pipeable fncts.io.Stream runIntoElementsScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoElementsScoped_<E, A, R1, E1>(queue: PQueue<R1, unknown, never, never, Exit<Maybe<E | E1>, A>, unknown>, __tsplusTrace?: string): <R>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R1 | R, E | E1, void>;
+export declare function runIntoElementsScoped_<E, A, R1, E1>(queue: PQueue<R1, unknown, never, never, Exit<Maybe<E | E1>, A>, unknown>, __tsplusTrace?: string): <R>(stream: Stream<R, E, A>) => IO<R | R1 | Scope, E | E1, void>;
 /**
  * Like `Stream#into`, but provides the result as a `Managed` to allow for scope
  * composition.
  * @tsplus pipeable fncts.io.Stream runIntoQueueScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(queue: PEnqueue<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | RA | R, EA | E1 | E, void>;
+export declare function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(queue: PEnqueue<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => IO<R | RA | Scope, E | EA | E1, void>;
 /**
  * Like runIntoQueue, but provides the result as a scoped IO
  * to allow for scope composition.
  * @tsplus pipeable fncts.io.Stream runIntoQueueElementsScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoQueueElementsScoped<E, A>(queue: Lazy<Queue.Enqueue<Exit<Maybe<E>, A>>>): <R>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, void>;
+export declare function runIntoQueueElementsScoped<E, A>(queue: Lazy<Queue.Enqueue<Exit<Maybe<E>, A>>>): <R>(self: Stream<R, E, A>) => IO<R | Scope, never, void>;
 /**
  * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
  * composition.
  * @tsplus pipeable fncts.io.Stream runIntoHubScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoHubScoped<RA, RB, EA, EB, E1, A, B>(hub: PHub<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | RA | R, EA | E1 | E, void>;
+export declare function runIntoHubScoped<RA, RB, EA, EB, E1, A, B>(hub: PHub<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => IO<R | RA | Scope, E | EA | E1, void>;
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
  * @tsplus pipeable fncts.io.Stream runScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runScoped<A, R2, E2, Z>(sink: Sink<R2, E2, A, unknown, Z>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R2 | R, E2 | E, Z>;
+export declare function runScoped<A, R2, E2, Z>(sink: Sink<R2, E2, A, unknown, Z>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => IO<R | R2 | Scope, E | E2, Z>;
 /**
  * Statefully maps over the elements of this stream to produce all intermediate results
  * of type `B` given an initial B.
@@ -1005,7 +1005,7 @@ export declare function scan<A, B>(b: B, f: (b: B, a: A) => B, __tsplusTrace?: s
  * @tsplus pipeable fncts.io.Stream scanIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scanIO<A, R1, E1, B>(b: B, f: (b: B, a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(sa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function scanIO<A, R1, E1, B>(b: B, f: (b: B, a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(sa: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * Statefully maps over the elements of this stream to produce all
  * intermediate results.
@@ -1019,12 +1019,12 @@ export declare function scanReduce<A extends B, B>(f: (b: B, a: A) => B, __tsplu
  * @tsplus pipeable fncts.io.Stream scanReduceIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scanReduceIO<A extends B, R1, E1, B>(f: (b: B, a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function scanReduceIO<A extends B, R1, E1, B>(f: (b: B, a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.Stream split
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function split<A>(predicate: Predicate<A>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => Stream<R, E, import("@fncts/base/collection/immutable/Conc.js").Conc<A>>;
+export declare function split<A>(predicate: Predicate<A>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Conc<A>>;
 /**
  * Creates a single-valued pure stream
  * @tsplus static fncts.io.StreamOps succeedNow
@@ -1047,7 +1047,7 @@ export declare function take(n: number, __tsplusTrace?: string): <R, E, A>(strea
  * @tsplus pipeable fncts.io.Stream takeUntilIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function takeUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function takeUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * Takes all elements of the stream until the specified predicate evaluates
  * to `true`.
@@ -1059,34 +1059,34 @@ export declare function takeUntil<A>(p: Predicate<A>, __tsplusTrace?: string): <
  * @tsplus pipeable fncts.io.Stream tap
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function tap<A, R1, E1>(f: (a: A) => IO<R1, E1, any>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function tap<A, R1, E1>(f: (a: A) => IO<R1, E1, any>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * Returns a stream that effectfully "peeks" at the failure and adds an effect
  * to consumption of every element of the stream
  * @tsplus pipeable fncts.io.Stream tapBoth
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function tapBoth<E, A, R1, E1, R2, E2>(f: (e: E) => IO<R1, E1, any>, g: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): <R>(self: Stream<R, E, A>) => Stream<R1 | R2 | R, E | E1 | E2, A>;
+export declare function tapBoth<E, A, R1, E1, R2, E2>(f: (e: E) => IO<R1, E1, any>, g: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): <R>(self: Stream<R, E, A>) => Stream<R | R1 | R2, E | E1 | E2, A>;
 /**
  * Returns a stream that effectfully "peeks" at the failure of the stream.
  * @tsplus pipeable fncts.io.Stream tapError
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function tapError<E, R1, E1>(f: (e: E) => IO<R1, E1, any>, __tsplusTrace?: string): <R, A>(self: Stream<R, E, A>) => Stream<R1 | R, E | E1, A>;
+export declare function tapError<E, R1, E1>(f: (e: E) => IO<R1, E1, any>, __tsplusTrace?: string): <R, A>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * Returns a stream that effectfully "peeks" at the cause of failure of the
  * stream.
  * @tsplus pipeable fncts.io.Stream tapErrorCause
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function tapErrorCause<E, R1, E1>(f: (cause: Cause<E>) => IO<R1, E1, any>, __tsplusTrace?: string): <R, A>(self: Stream<R, E, A>) => Stream<R1 | R, E | E1, A>;
+export declare function tapErrorCause<E, R1, E1>(f: (cause: Cause<E>) => IO<R1, E1, any>, __tsplusTrace?: string): <R, A>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * Sends all elements emitted by this stream to the specified sink in addition
  * to emitting them.
  * @tsplus pipeable fncts.io.Stream tapSink
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function tapSink<A, R1, E1>(sink: Sink<R1, E1, A, any, any>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function tapSink<A, R1, E1>(sink: Sink<R1, E1, A, any, any>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * Throttles the chunks of this stream according to the given bandwidth parameters using the token bucket
  * algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate
@@ -1104,14 +1104,14 @@ export declare function throttleEnforce<A>(costFn: (chunk: Conc<A>) => number, u
  * @tsplus pipeable fncts.io.Stream throttleEnforceIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function throttleEnforceIO<A, R1, E1>(costFn: (chunk: Conc<A>) => IO<R1, E1, number>, units: number, duration: number, burst?: number, __tsplusTrace?: string): <R, E>(sa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function throttleEnforceIO<A, R1, E1>(costFn: (chunk: Conc<A>) => IO<R1, E1, number>, units: number, duration: number, burst?: number, __tsplusTrace?: string): <R, E>(sa: Stream<R, E, A>) => Stream<R | R1, E | E1, A>;
 /**
  * Converts the stream to a managed hub of chunks. After the managed hub is used,
  * the hub will never again produce values and should be discarded.
  * @tsplus pipeable fncts.io.Stream toHub
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toHub(capacity: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Hub<Take<E, A>>>;
+export declare function toHub(capacity: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => IO<R | Scope, never, Hub<Take<E, A>>>;
 /**
  * Interpret the stream as a managed pull
  * @tsplus getter fncts.io.Stream toPull
@@ -1124,22 +1124,22 @@ export declare function toPull<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?:
  * @tsplus pipeable fncts.io.Stream toQueue
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueue(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<Take<E, A>>>;
+export declare function toQueue(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => IO<R | Scope, never, Queue.Dequeue<Take<E, A>>>;
 /**
  * @tsplus pipeable fncts.io.Stream toQueueDropping
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueDropping(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<Take<E, A>>>;
+export declare function toQueueDropping(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => IO<R | Scope, never, Queue.Dequeue<Take<E, A>>>;
 /**
  * @tsplus pipeable fncts.io.Stream toQueueOfElements
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueOfElements(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>>;
+export declare function toQueueOfElements(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => IO<R | Scope, never, Queue.Dequeue<Exit<Maybe<E>, A>>>;
 /**
  * @tsplus pipeable fncts.io.Stream toQueueSliding
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueSliding(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<Take<E, A>>>;
+export declare function toQueueSliding(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => IO<R | Scope, never, Queue.Dequeue<Take<E, A>>>;
 /**
  * Converts the stream into an unbounded managed queue. After the managed queue
  * is used, the queue will never again produce values and should be discarded.
@@ -1197,4 +1197,4 @@ export declare function zipWithIndex_<R, E, A>(self: Stream<R, E, A>, __tsplusTr
  * @tsplus pipeable fncts.io.Stream zipWithLatest
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function zipWithLatest<A, R1, E1, B, C>(fb: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, C>;
+export declare function zipWithLatest<A, R1, E1, B, C>(fb: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R | R1, E | E1, C>;