effect 2.3.8 → 2.4.1

package/dist/dts/Stream.d.ts

@@ -27,7 +27,7 @@ import type * as Emit from "./StreamEmit.js";
 import type * as HaltStrategy from "./StreamHaltStrategy.js";
 import type * as Take from "./Take.js";
 import type * as Tracer from "./Tracer.js";
-import type { Covariant, NoInfer } from "./Types.js";
+import type { Covariant, MergeRecord, NoInfer } from "./Types.js";
 import type * as Unify from "./Unify.js";
 /**
  * @since 2.0.0
@@ -154,7 +154,7 @@ export declare const accumulateChunks: <A, E, R>(self: Stream<A, E, R>) => Strea
  * @since 2.0.0
  * @category constructors
  */
-export declare const acquireRelease: <A, E, R, R2, _>(acquire: Effect.Effect<A, E, R>, release: (resource: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<_, never, R2>) => Stream<A, E, R | R2>;
+export declare const acquireRelease: <A, E, R, R2, X>(acquire: Effect.Effect<A, E, R>, release: (resource: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<X, never, R2>) => Stream<A, E, R | R2>;
 /**
  * Aggregates elements of this stream using the provided sink for as long as
  * the downstream operators on the stream are busy.
@@ -184,8 +184,8 @@ export declare const aggregate: {
  * @category utils
  */
 export declare const aggregateWithin: {
-    <B, A, A2, E2, R2, R3, C>(sink: Sink.Sink<B, A | A2, A2, E2, R2>, schedule: Schedule.Schedule<R3, Option.Option<B>, C>): <E, R>(self: Stream<A, E, R>) => Stream<B, E2 | E, R2 | R3 | R>;
-    <A, E, R, B, A2, E2, R2, R3, C>(self: Stream<A, E, R>, sink: Sink.Sink<B, A | A2, A2, E2, R2>, schedule: Schedule.Schedule<R3, Option.Option<B>, C>): Stream<B, E | E2, R | R2 | R3>;
+    <B, A, A2, E2, R2, C, R3>(sink: Sink.Sink<B, A | A2, A2, E2, R2>, schedule: Schedule.Schedule<C, Option.Option<B>, R3>): <E, R>(self: Stream<A, E, R>) => Stream<B, E2 | E, R2 | R3 | R>;
+    <A, E, R, B, A2, E2, R2, C, R3>(self: Stream<A, E, R>, sink: Sink.Sink<B, A | A2, A2, E2, R2>, schedule: Schedule.Schedule<C, Option.Option<B>, R3>): Stream<B, E | E2, R | R2 | R3>;
 };
 /**
  * Aggregates elements using the provided sink until it completes, or until
@@ -205,8 +205,8 @@ export declare const aggregateWithin: {
  * @category utils
  */
 export declare const aggregateWithinEither: {
-    <B, A, A2, E2, R2, R3, C>(sink: Sink.Sink<B, A | A2, A2, E2, R2>, schedule: Schedule.Schedule<R3, Option.Option<B>, C>): <E, R>(self: Stream<A, E, R>) => Stream<Either.Either<C, B>, E2 | E, R2 | R3 | R>;
-    <A, E, R, B, A2, E2, R2, R3, C>(self: Stream<A, E, R>, sink: Sink.Sink<B, A | A2, A2, E2, R2>, schedule: Schedule.Schedule<R3, Option.Option<B>, C>): Stream<Either.Either<C, B>, E | E2, R | R2 | R3>;
+    <B, A, A2, E2, R2, C, R3>(sink: Sink.Sink<B, A | A2, A2, E2, R2>, schedule: Schedule.Schedule<C, Option.Option<B>, R3>): <E, R>(self: Stream<A, E, R>) => Stream<Either.Either<B, C>, E2 | E, R2 | R3 | R>;
+    <A, E, R, B, A2, E2, R2, C, R3>(self: Stream<A, E, R>, sink: Sink.Sink<B, A | A2, A2, E2, R2>, schedule: Schedule.Schedule<C, Option.Option<B>, R3>): Stream<Either.Either<B, C>, E | E2, R | R2 | R3>;
 };
 /**
  * Maps the success values of this stream to the specified constant value.
@@ -216,14 +216,17 @@ export declare const aggregateWithinEither: {
  */
 export declare const as: {
     <B>(value: B): <A, E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
-    <R, E, A, B>(self: Stream<A, E, R>, value: B): Stream<B, E, R>;
+    <A, E, R, B>(self: Stream<A, E, R>, value: B): Stream<B, E, R>;
 };
-declare const _async: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => void, outputBuffer?: number) => Stream<A, E, R>;
+declare const _async: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<void, never, R> | void, outputBuffer?: number) => Stream<A, E, R>;
 export { 
 /**
  * Creates a stream from an asynchronous callback that can be called multiple
- * times. The optionality of the error type `E` can be used to signal the end
- * of the stream, by setting it to `None`.
+ * times. The optionality of the error type `E` in `Emit` can be used to
+ * signal the end of the stream by setting it to `None`.
+ *
+ * The registration function can optionally return an `Effect`, which will be
+ * executed if the `Fiber` executing this Effect is interrupted.
  *
  * @since 2.0.0
  * @category constructors
@@ -239,26 +242,6 @@ _async as async };
  * @category constructors
  */
 export declare const asyncEffect: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R>, outputBuffer?: number) => Stream<A, E, R>;
-/**
- * Creates a stream from an asynchronous callback that can be called multiple
- * times. The registration of the callback returns either a canceler or
- * synchronously returns a stream. The optionality of the error type `E` can
- * be used to signal the end of the stream, by setting it to `None`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export declare const asyncInterrupt: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => Either.Either<Effect.Effect<unknown, never, R>, Stream<A, E, R>>, outputBuffer?: number) => Stream<A, E, R>;
-/**
- * Creates a stream from an asynchronous callback that can be called multiple
- * times. The registration of the callback can possibly return the stream
- * synchronously. The optionality of the error type `E` can be used to signal
- * the end of the stream, by setting it to `None`.
- *
- * @since 2.0.0
- * @category constructors
- */
-export declare const asyncOption: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => Option.Option<Stream<A, E, R>>, outputBuffer?: number) => Stream<A, E, R>;
 /**
  * Creates a stream from an asynchronous callback that can be called multiple
  * times. The registration of the callback itself returns an a scoped
@@ -278,8 +261,8 @@ export declare const asyncScoped: <A, E = never, R = never>(register: (emit: Emi
  * @category sequencing
  */
 export declare const branchAfter: {
-    <A, A2, E2, R2>(n: number, f: (input: Chunk.Chunk<A>) => Stream<A2, E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <A, E, R, R2, E2, A2>(self: Stream<A, E, R>, n: number, f: (input: Chunk.Chunk<A>) => Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>;
+    <A, A2, E2, R2>(n: number, f: (input: Chunk.Chunk<A>) => Stream<A2, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, n: number, f: (input: Chunk.Chunk<A>) => Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Fan out the stream, producing a list of streams that have the same elements
@@ -383,8 +366,8 @@ export declare const bufferChunks: {
  * @category error handling
  */
 export declare const catchAll: {
-    <E, R2, E2, A2>(f: (error: E) => Stream<A2, E2, R2>): <R, A>(self: Stream<A, E, R>) => Stream<A2 | A, E2, R2 | R>;
-    <R, A, E, R2, E2, A2>(self: Stream<A, E, R>, f: (error: E) => Stream<A2, E2, R2>): Stream<A | A2, E2, R | R2>;
+    <E, A2, E2, R2>(f: (error: E) => Stream<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (error: E) => Stream<A2, E2, R2>): Stream<A | A2, E2, R | R2>;
 };
 /**
  * Switches over to the stream produced by the provided function in case this
@@ -395,8 +378,8 @@ export declare const catchAll: {
  * @category error handling
  */
 export declare const catchAllCause: {
-    <E, R2, E2, A2>(f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>): <R, A>(self: Stream<A, E, R>) => Stream<A2 | A, E2, R2 | R>;
-    <R, A, E, R2, E2, A2>(self: Stream<A, E, R>, f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>): Stream<A | A2, E2, R | R2>;
+    <E, A2, E2, R2>(f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>): Stream<A | A2, E2, R | R2>;
 };
 /**
  * Switches over to the stream produced by the provided function in case this
@@ -406,8 +389,8 @@ export declare const catchAllCause: {
  * @category error handling
  */
 export declare const catchSome: {
-    <E, R2, E2, A2>(pf: (error: E) => Option.Option<Stream<A2, E2, R2>>): <R, A>(self: Stream<A, E, R>) => Stream<A2 | A, E | E2, R2 | R>;
-    <R, A, E, R2, E2, A2>(self: Stream<A, E, R>, pf: (error: E) => Option.Option<Stream<A2, E2, R2>>): Stream<A | A2, E | E2, R | R2>;
+    <E, A2, E2, R2>(pf: (error: E) => Option.Option<Stream<A2, E2, R2>>): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A, E | E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, pf: (error: E) => Option.Option<Stream<A2, E2, R2>>): Stream<A | A2, E | E2, R | R2>;
 };
 /**
  * Switches over to the stream produced by the provided function in case this
@@ -419,14 +402,14 @@ export declare const catchSome: {
 export declare const catchTag: {
     <K extends E["_tag"] & string, E extends {
         _tag: string;
-    }, R1, E1, A1>(k: K, f: (e: Extract<E, {
+    }, A1, E1, R1>(k: K, f: (e: Extract<E, {
         _tag: K;
-    }>) => Stream<A1, E1, R1>): <R, A>(self: Stream<A, E, R>) => Stream<A1 | A, E1 | Exclude<E, {
+    }>) => Stream<A1, E1, R1>): <A, R>(self: Stream<A, E, R>) => Stream<A1 | A, E1 | Exclude<E, {
         _tag: K;
     }>, R1 | R>;
-    <R, E extends {
+    <A, E extends {
         _tag: string;
-    }, A, K extends E["_tag"] & string, R1, E1, A1>(self: Stream<A, E, R>, k: K, f: (e: Extract<E, {
+    }, R, K extends E["_tag"] & string, A1, E1, R1>(self: Stream<A, E, R>, k: K, f: (e: Extract<E, {
         _tag: K;
     }>) => Stream<A1, E1, R1>): Stream<A | A1, E1 | Exclude<E, {
         _tag: K;
@@ -446,7 +429,7 @@ export declare const catchTags: {
         [K in E["_tag"]]+?: (error: Extract<E, {
             _tag: K;
         }>) => Stream<any, any, any>;
-    }>(cases: Cases): <R, A>(self: Stream<A, E, R>) => Stream<A | {
+    }>(cases: Cases): <A, R>(self: Stream<A, E, R>) => Stream<A | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer A, infer _E, infer _R> ? A : never;
     }[keyof Cases], Exclude<E, {
         _tag: keyof Cases;
@@ -455,9 +438,9 @@ export declare const catchTags: {
     }[keyof Cases], R | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _A, infer _E, infer R> ? R : never;
     }[keyof Cases]>;
-    <R, E extends {
+    <A, E extends {
         _tag: string;
-    }, A, Cases extends {
+    }, R, Cases extends {
         [K in E["_tag"]]+?: (error: Extract<E, {
             _tag: K;
         }>) => Stream<any, any, any>;
@@ -480,8 +463,8 @@ export declare const catchTags: {
  * @category error handling
  */
 export declare const catchSomeCause: {
-    <E, R2, E2, A2>(pf: (cause: Cause.Cause<E>) => Option.Option<Stream<A2, E2, R2>>): <R, A>(self: Stream<A, E, R>) => Stream<A2 | A, E | E2, R2 | R>;
-    <R, A, E, R2, E2, A2>(self: Stream<A, E, R>, pf: (cause: Cause.Cause<E>) => Option.Option<Stream<A2, E2, R2>>): Stream<A | A2, E | E2, R | R2>;
+    <E, A2, E2, R2>(pf: (cause: Cause.Cause<E>) => Option.Option<Stream<A2, E2, R2>>): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A, E | E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, pf: (cause: Cause.Cause<E>) => Option.Option<Stream<A2, E2, R2>>): Stream<A | A2, E | E2, R | R2>;
 };
 /**
  * Returns a new stream that only emits elements that are not equal to the
@@ -501,7 +484,7 @@ export declare const changes: <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R
  * @category utils
  */
 export declare const changesWith: {
-    <A>(f: (x: A, y: A) => boolean): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A>(f: (x: A, y: A) => boolean): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     <A, E, R>(self: Stream<A, E, R>, f: (x: A, y: A) => boolean): Stream<A, E, R>;
 };
 /**
@@ -513,8 +496,8 @@ export declare const changesWith: {
  * @category utils
  */
 export declare const changesWithEffect: {
-    <A, R2, E2>(f: (x: A, y: A) => Effect.Effect<boolean, E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2>(self: Stream<A, E, R>, f: (x: A, y: A) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
+    <A, E2, R2>(f: (x: A, y: A) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: Stream<A, E, R>, f: (x: A, y: A) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Exposes the underlying chunks of the stream as a stream of chunks of
@@ -532,8 +515,8 @@ export declare const chunks: <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Ch
  * @category utils
  */
 export declare const chunksWith: {
-    <R, E, A, R2, E2, A2>(f: (stream: Stream<Chunk.Chunk<A>, E, R>) => Stream<Chunk.Chunk<A2>, E2, R2>): (self: Stream<A, E, R>) => Stream<A2, E | E2, R | R2>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, f: (stream: Stream<Chunk.Chunk<A>, E, R>) => Stream<Chunk.Chunk<A2>, E2, R2>): Stream<A2, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(f: (stream: Stream<Chunk.Chunk<A>, E, R>) => Stream<Chunk.Chunk<A2>, E2, R2>): (self: Stream<A, E, R>) => Stream<A2, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (stream: Stream<Chunk.Chunk<A>, E, R>) => Stream<Chunk.Chunk<A2>, E2, R2>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Combines the elements from this stream and the specified stream by
@@ -549,8 +532,8 @@ export declare const chunksWith: {
  * @category utils
  */
 export declare const combine: {
-    <R2, E2, A2, S, R3, E, A, R4, R5, A3>(that: Stream<A2, E2, R2>, s: S, f: (s: S, pullLeft: Effect.Effect<A, Option.Option<E>, R3>, pullRight: Effect.Effect<A2, Option.Option<E2>, R4>) => Effect.Effect<Exit.Exit<readonly [A3, S], Option.Option<E2 | E>>, never, R5>): <R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R3 | R4 | R5 | R>;
-    <R, R2, E2, A2, S, R3, E, A, R4, R5, A3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, s: S, f: (s: S, pullLeft: Effect.Effect<A, Option.Option<E>, R3>, pullRight: Effect.Effect<A2, Option.Option<E2>, R4>) => Effect.Effect<Exit.Exit<readonly [A3, S], Option.Option<E2 | E>>, never, R5>): Stream<A3, E2 | E, R | R2 | R3 | R4 | R5>;
+    <A2, E2, R2, S, R3, E, A, R4, R5, A3>(that: Stream<A2, E2, R2>, s: S, f: (s: S, pullLeft: Effect.Effect<A, Option.Option<E>, R3>, pullRight: Effect.Effect<A2, Option.Option<E2>, R4>) => Effect.Effect<Exit.Exit<readonly [A3, S], Option.Option<E2 | E>>, never, R5>): <R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R3 | R4 | R5 | R>;
+    <R, A2, E2, R2, S, R3, E, A, R4, R5, A3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, s: S, f: (s: S, pullLeft: Effect.Effect<A, Option.Option<E>, R3>, pullRight: Effect.Effect<A2, Option.Option<E2>, R4>) => Effect.Effect<Exit.Exit<readonly [A3, S], Option.Option<E2 | E>>, never, R5>): Stream<A3, E2 | E, R | R2 | R3 | R4 | R5>;
 };
 /**
  * Combines the chunks from this stream and the specified stream by repeatedly
@@ -563,8 +546,8 @@ export declare const combine: {
  * @category utils
  */
 export declare const combineChunks: {
-    <R2, E2, A2, S, R3, E, A, R4, R5, A3>(that: Stream<A2, E2, R2>, s: S, f: (s: S, pullLeft: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R3>, pullRight: Effect.Effect<Chunk.Chunk<A2>, Option.Option<E2>, R4>) => Effect.Effect<Exit.Exit<readonly [Chunk.Chunk<A3>, S], Option.Option<E2 | E>>, never, R5>): <R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R3 | R4 | R5 | R>;
-    <R, R2, E2, A2, S, R3, E, A, R4, R5, A3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, s: S, f: (s: S, pullLeft: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R3>, pullRight: Effect.Effect<Chunk.Chunk<A2>, Option.Option<E2>, R4>) => Effect.Effect<Exit.Exit<readonly [Chunk.Chunk<A3>, S], Option.Option<E2 | E>>, never, R5>): Stream<A3, E2 | E, R | R2 | R3 | R4 | R5>;
+    <A2, E2, R2, S, R3, E, A, R4, R5, A3>(that: Stream<A2, E2, R2>, s: S, f: (s: S, pullLeft: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R3>, pullRight: Effect.Effect<Chunk.Chunk<A2>, Option.Option<E2>, R4>) => Effect.Effect<Exit.Exit<readonly [Chunk.Chunk<A3>, S], Option.Option<E2 | E>>, never, R5>): <R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R3 | R4 | R5 | R>;
+    <R, A2, E2, R2, S, R3, E, A, R4, R5, A3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, s: S, f: (s: S, pullLeft: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R3>, pullRight: Effect.Effect<Chunk.Chunk<A2>, Option.Option<E2>, R4>) => Effect.Effect<Exit.Exit<readonly [Chunk.Chunk<A3>, S], Option.Option<E2 | E>>, never, R5>): Stream<A3, E2 | E, R | R2 | R3 | R4 | R5>;
 };
 /**
  * Concatenates the specified stream with this stream, resulting in a stream
@@ -575,8 +558,8 @@ export declare const combineChunks: {
  * @category utils
  */
 export declare const concat: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A | A2, E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A | A2, E | E2, R | R2>;
 };
 /**
  * Concatenates all of the streams in the chunk to one stream.
@@ -596,8 +579,8 @@ export declare const concatAll: <A, E, R>(streams: Chunk.Chunk<Stream<A, E, R>>)
  * @category utils
  */
 export declare const cross: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>;
 };
 /**
  * Composes this stream with the specified stream to create a cartesian
@@ -610,8 +593,8 @@ export declare const cross: {
  * @category utils
  */
 export declare const crossLeft: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Composes this stream with the specified stream to create a cartesian
@@ -625,8 +608,8 @@ export declare const crossLeft: {
  * @category utils
  */
 export declare const crossRight: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Composes this stream with the specified stream to create a cartesian
@@ -639,8 +622,8 @@ export declare const crossRight: {
  * @category utils
  */
 export declare const crossWith: {
-    <R2, E2, B, A, C>(that: Stream<B, E2, R2>, f: (a: A, b: B) => C): <R, E>(self: Stream<A, E, R>) => Stream<C, E2 | E, R2 | R>;
-    <R, E, R2, E2, B, A, C>(self: Stream<A, E, R>, that: Stream<B, E2, R2>, f: (a: A, b: B) => C): Stream<C, E | E2, R | R2>;
+    <B, E2, R2, A, C>(that: Stream<B, E2, R2>, f: (a: A, b: B) => C): <E, R>(self: Stream<A, E, R>) => Stream<C, E2 | E, R2 | R>;
+    <A, E, R, B, E2, R2, C>(self: Stream<A, E, R>, that: Stream<B, E2, R2>, f: (a: A, b: B) => C): Stream<C, E | E2, R | R2>;
 };
 /**
  * Delays the emission of values by holding new values for a set duration. If
@@ -694,8 +677,8 @@ export declare const distributedWith: {
         readonly size: N;
         readonly maximumLag: number;
         readonly decide: (a: A) => Effect.Effect<Predicate<number>>;
-    }): <R, E>(self: Stream<A, E, R>) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>, never, Scope.Scope | R>;
-    <R, E, N extends number, A>(self: Stream<A, E, R>, options: {
+    }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>, never, Scope.Scope | R>;
+    <A, E, R, N extends number>(self: Stream<A, E, R>, options: {
         readonly size: N;
         readonly maximumLag: number;
         readonly decide: (a: A) => Effect.Effect<Predicate<number>>;
@@ -713,14 +696,14 @@ export declare const distributedWith: {
  * @category utils
  */
 export declare const distributedWithDynamic: {
-    <E, A, _>(options: {
+    <A>(options: {
         readonly maximumLag: number;
-        readonly decide: (a: A) => Effect.Effect<Predicate<number>>;
-    }): <R>(self: Stream<A, E, R>) => Effect.Effect<Effect.Effect<[number, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>]>, never, Scope.Scope | R>;
-    <R, E, A, _>(self: Stream<A, E, R>, options: {
+        readonly decide: (a: A) => Effect.Effect<Predicate<number>, never, never>;
+    }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<Effect.Effect<[number, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>], never, never>, never, Scope.Scope | R>;
+    <A, E, R>(self: Stream<A, E, R>, options: {
         readonly maximumLag: number;
-        readonly decide: (a: A) => Effect.Effect<Predicate<number>>;
-    }): Effect.Effect<Effect.Effect<[number, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>]>, never, Scope.Scope | R>;
+        readonly decide: (a: A) => Effect.Effect<Predicate<number>, never, never>;
+    }): Effect.Effect<Effect.Effect<[number, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>], never, never>, never, Scope.Scope | R>;
 };
 /**
  * Converts this stream to a stream that executes its effects but emits no
@@ -739,8 +722,8 @@ export declare const drain: <A, E, R>(self: Stream<A, E, R>) => Stream<never, E,
  * @category utils
  */
 export declare const drainFork: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Drops the specified number of elements from this stream.
@@ -772,7 +755,7 @@ export declare const dropRight: {
  * @category utils
  */
 export declare const dropUntil: {
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
@@ -783,8 +766,8 @@ export declare const dropUntil: {
  * @category utils
  */
 export declare const dropUntilEffect: {
-    <A, R2, E2>(predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
+    <A, E2, R2>(predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Drops all elements of the stream for as long as the specified predicate
@@ -794,7 +777,7 @@ export declare const dropUntilEffect: {
  * @category utils
  */
 export declare const dropWhile: {
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
@@ -805,8 +788,8 @@ export declare const dropWhile: {
  * @category utils
  */
 export declare const dropWhileEffect: {
-    <A, R2, E2>(predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2>(self: Stream<A, E, R>, predicate: (a: A) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
+    <A, E2, R2>(predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: Stream<A, E, R>, predicate: (a: A) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Returns a stream whose failures and successes have been lifted into an
@@ -818,7 +801,7 @@ export declare const dropWhileEffect: {
  * @since 2.0.0
  * @category utils
  */
-export declare const either: <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<E, A>, never, R>;
+export declare const either: <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A, E>, never, R>;
 /**
  * The empty stream.
  *
@@ -833,8 +816,8 @@ export declare const empty: Stream<never>;
  * @category utils
  */
 export declare const ensuring: {
-    <R2, _>(finalizer: Effect.Effect<_, never, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
-    <R, E, A, R2, _>(self: Stream<A, E, R>, finalizer: Effect.Effect<_, never, R2>): Stream<A, E, R | R2>;
+    <X, R2>(finalizer: Effect.Effect<X, never, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
+    <A, E, R, X, R2>(self: Stream<A, E, R>, finalizer: Effect.Effect<X, never, R2>): Stream<A, E, R | R2>;
 };
 /**
  * Executes the provided finalizer after this stream's finalizers run.
@@ -843,8 +826,8 @@ export declare const ensuring: {
  * @category utils
  */
 export declare const ensuringWith: {
-    <E, R2>(finalizer: (exit: Exit.Exit<unknown, E>) => Effect.Effect<unknown, never, R2>): <R, A>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
-    <R, E, A, R2>(self: Stream<A, E, R>, finalizer: (exit: Exit.Exit<unknown, E>) => Effect.Effect<unknown, never, R2>): Stream<A, E, R | R2>;
+    <E, R2>(finalizer: (exit: Exit.Exit<unknown, E>) => Effect.Effect<unknown, never, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
+    <A, E, R, R2>(self: Stream<A, E, R>, finalizer: (exit: Exit.Exit<unknown, E>) => Effect.Effect<unknown, never, R2>): Stream<A, E, R | R2>;
 };
 /**
  * Accesses the whole context of the stream.
@@ -866,21 +849,21 @@ export declare const contextWith: <R, A>(f: (env: Context.Context<R>) => A) => S
  * @since 2.0.0
  * @category context
  */
-export declare const contextWithEffect: <R0, R, E, A>(f: (env: Context.Context<R0>) => Effect.Effect<A, E, R>) => Stream<A, E, R0 | R>;
+export declare const contextWithEffect: <R0, A, E, R>(f: (env: Context.Context<R0>) => Effect.Effect<A, E, R>) => Stream<A, E, R0 | R>;
 /**
  * Accesses the context of the stream in the context of a stream.
  *
  * @since 2.0.0
  * @category context
  */
-export declare const contextWithStream: <R0, R, E, A>(f: (env: Context.Context<R0>) => Stream<A, E, R>) => Stream<A, E, R0 | R>;
+export declare const contextWithStream: <R0, A, E, R>(f: (env: Context.Context<R0>) => Stream<A, E, R>) => Stream<A, E, R0 | R>;
 /**
  * Creates a stream that executes the specified effect but emits no elements.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const execute: <R, E, _>(effect: Effect.Effect<_, E, R>) => Stream<never, E, R>;
+export declare const execute: <X, E, R>(effect: Effect.Effect<X, E, R>) => Stream<never, E, R>;
 /**
  * Terminates with the specified error.
  *
@@ -916,9 +899,9 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => St
  * @category filtering
  */
 export declare const filter: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<A, E, R>) => Stream<B, E, R>;
-    <A, B extends A>(predicate: Predicate<B>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>;
-    <R, E, A, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>): Stream<B, E, R>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
+    <A, B extends A>(predicate: Predicate<B>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>): Stream<B, E, R>;
     <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
@@ -928,8 +911,8 @@ export declare const filter: {
  * @category filtering
  */
 export declare const filterEffect: {
-    <A, R2, E2>(f: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
+    <A, E2, R2>(f: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Performs a filter and map in a single step.
@@ -938,8 +921,8 @@ export declare const filterEffect: {
  * @category utils
  */
 export declare const filterMap: {
-    <A, B>(pf: (a: A) => Option.Option<B>): <R, E>(self: Stream<A, E, R>) => Stream<B, E, R>;
-    <R, E, A, B>(self: Stream<A, E, R>, pf: (a: A) => Option.Option<B>): Stream<B, E, R>;
+    <A, B>(pf: (a: A) => Option.Option<B>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
+    <A, E, R, B>(self: Stream<A, E, R>, pf: (a: A) => Option.Option<B>): Stream<B, E, R>;
 };
 /**
  * Performs an effectful filter and map in a single step.
@@ -948,8 +931,8 @@ export declare const filterMap: {
  * @category utils
  */
 export declare const filterMapEffect: {
-    <A, R2, E2, A2>(pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>): Stream<A2, E | E2, R | R2>;
+    <A, A2, E2, R2>(pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Transforms all elements of the stream for as long as the specified partial
@@ -959,8 +942,8 @@ export declare const filterMapEffect: {
  * @category utils
  */
 export declare const filterMapWhile: {
-    <A, A2>(pf: (a: A) => Option.Option<A2>): <R, E>(self: Stream<A, E, R>) => Stream<A2, E, R>;
-    <R, E, A, A2>(self: Stream<A, E, R>, pf: (a: A) => Option.Option<A2>): Stream<A2, E, R>;
+    <A, A2>(pf: (a: A) => Option.Option<A2>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E, R>;
+    <A, E, R, A2>(self: Stream<A, E, R>, pf: (a: A) => Option.Option<A2>): Stream<A2, E, R>;
 };
 /**
  * Effectfully transforms all elements of the stream for as long as the
@@ -970,8 +953,8 @@ export declare const filterMapWhile: {
  * @category utils
  */
 export declare const filterMapWhileEffect: {
-    <A, R2, E2, A2>(pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>): Stream<A2, E | E2, R | R2>;
+    <A, A2, E2, R2>(pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Creates a one-element stream that never fails and executes the finalizer
@@ -980,7 +963,7 @@ export declare const filterMapWhileEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const finalizer: <R, _>(finalizer: Effect.Effect<_, never, R>) => Stream<void, never, R>;
+export declare const finalizer: <R, X>(finalizer: Effect.Effect<X, never, R>) => Stream<void, never, R>;
 /**
  * Finds the first element emitted by this stream that satisfies the provided
  * predicate.
@@ -989,9 +972,9 @@ export declare const finalizer: <R, _>(finalizer: Effect.Effect<_, never, R>) =>
  * @category elements
  */
 export declare const find: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<A, E, R>) => Stream<B, E, R>;
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>;
-    <R, E, A, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>): Stream<B, E, R>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>): Stream<B, E, R>;
     <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
@@ -1002,8 +985,8 @@ export declare const find: {
  * @category elements
  */
 export declare const findEffect: {
-    <A, R2, E2>(predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
+    <A, E2, R2>(predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Returns a stream made of the concatenation in strict order of all the
@@ -1013,12 +996,12 @@ export declare const findEffect: {
  * @category sequencing
  */
 export declare const flatMap: {
-    <A, R2, E2, A2>(f: (a: A) => Stream<A2, E2, R2>, options?: {
+    <A, A2, E2, R2>(f: (a: A) => Stream<A2, E2, R2>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
         readonly switch?: boolean | undefined;
-    } | undefined): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, f: (a: A) => Stream<A2, E2, R2>, options?: {
+    } | undefined): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Stream<A2, E2, R2>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
         readonly switch?: boolean | undefined;
@@ -1035,11 +1018,11 @@ export declare const flatten: {
     (options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
-    } | undefined): <R, E, R2, E2, A>(self: Stream<Stream<A, E2, R2>, E, R>) => Stream<A, E | E2, R | R2>;
-    <R, E, R2, E2, A>(self: Stream<Stream<A, E2, R2>, E, R>, options?: {
+    } | undefined): <A, E2, R2, E, R>(self: Stream<Stream<A, E2, R2>, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E2, R2, E, R>(self: Stream<Stream<A, E2, R2>, E, R>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
-    } | undefined): Stream<A, E | E2, R | R2>;
+    } | undefined): Stream<A, E2 | E, R2 | R>;
 };
 /**
  * Submerges the chunks carried by this stream into the stream's structure,
@@ -1060,11 +1043,11 @@ export declare const flattenEffect: {
     (options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly unordered?: boolean | undefined;
-    } | undefined): <R, E, R2, E2, A>(self: Stream<Effect.Effect<A, E2, R2>, E, R>) => Stream<A, E | E2, R | R2>;
-    <R, E, R2, E2, A>(self: Stream<Effect.Effect<A, E2, R2>, E, R>, options?: {
+    } | undefined): <A, E2, R2, E, R>(self: Stream<Effect.Effect<A, E2, R2>, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E2, R2, E, R>(self: Stream<Effect.Effect<A, E2, R2>, E, R>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly unordered?: boolean | undefined;
-    } | undefined): Stream<A, E | E2, R | R2>;
+    } | undefined): Stream<A, E2 | E, R2 | R>;
 };
 /**
  * Unwraps `Exit` values that also signify end-of-stream by failing with `None`.
@@ -1078,7 +1061,7 @@ export declare const flattenEffect: {
  * @since 2.0.0
  * @category sequencing
  */
-export declare const flattenExitOption: <R, E, E2, A>(self: Stream<Exit.Exit<A, Option.Option<E2>>, E, R>) => Stream<A, E | E2, R>;
+export declare const flattenExitOption: <A, E2, E, R>(self: Stream<Exit.Exit<A, Option.Option<E2>>, E, R>) => Stream<A, E | E2, R>;
 /**
  * Submerges the iterables carried by this stream into the stream's structure,
  * while still preserving them.
@@ -1094,7 +1077,7 @@ export declare const flattenIterables: <A, E, R>(self: Stream<Iterable<A>, E, R>
  * @since 2.0.0
  * @category sequencing
  */
-export declare const flattenTake: <R, E, E2, A>(self: Stream<Take.Take<A, E2>, E, R>) => Stream<A, E | E2, R>;
+export declare const flattenTake: <A, E2, E, R>(self: Stream<Take.Take<A, E2>, E, R>) => Stream<A, E | E2, R>;
 /**
  * Repeats this stream forever.
  *
@@ -1268,7 +1251,7 @@ export declare const fromReadableStreamByob: <E>(evaluate: LazyArg<ReadableStrea
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromSchedule: <R, A>(schedule: Schedule.Schedule<R, unknown, A>) => Stream<A, never, R>;
+export declare const fromSchedule: <A, R>(schedule: Schedule.Schedule<A, unknown, R>) => Stream<A, never, R>;
 /**
  * Creates a pipeline that groups on adjacent keys, calculated by the
  * specified function.
@@ -1277,8 +1260,8 @@ export declare const fromSchedule: <R, A>(schedule: Schedule.Schedule<R, unknown
  * @category grouping
  */
 export declare const groupAdjacentBy: {
-    <A, K>(f: (a: A) => K): <R, E>(self: Stream<A, E, R>) => Stream<[K, Chunk.NonEmptyChunk<A>], E, R>;
-    <R, E, A, K>(self: Stream<A, E, R>, f: (a: A) => K): Stream<[K, Chunk.NonEmptyChunk<A>], E, R>;
+    <A, K>(f: (a: A) => K): <E, R>(self: Stream<A, E, R>) => Stream<[K, Chunk.NonEmptyChunk<A>], E, R>;
+    <A, E, R, K>(self: Stream<A, E, R>, f: (a: A) => K): Stream<[K, Chunk.NonEmptyChunk<A>], E, R>;
 };
 /**
  * More powerful version of `Stream.groupByKey`.
@@ -1287,12 +1270,12 @@ export declare const groupAdjacentBy: {
  * @category grouping
  */
 export declare const groupBy: {
-    <A, R2, E2, K, V>(f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>, options?: {
+    <A, K, V, E2, R2>(f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>, options?: {
         readonly bufferSize?: number | undefined;
-    } | undefined): <R, E>(self: Stream<A, E, R>) => GroupBy.GroupBy<R2 | R, E2 | E, K, V>;
-    <R, E, A, R2, E2, K, V>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>, options?: {
+    } | undefined): <E, R>(self: Stream<A, E, R>) => GroupBy.GroupBy<K, V, E2 | E, R2 | R>;
+    <A, E, R, K, V, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>, options?: {
         readonly bufferSize?: number | undefined;
-    } | undefined): GroupBy.GroupBy<R | R2, E | E2, K, V>;
+    } | undefined): GroupBy.GroupBy<K, V, E | E2, R | R2>;
 };
 /**
  * Partition a stream using a function and process each stream individually.
@@ -1334,10 +1317,10 @@ export declare const groupBy: {
 export declare const groupByKey: {
     <A, K>(f: (a: A) => K, options?: {
         readonly bufferSize?: number | undefined;
-    }): <R, E>(self: Stream<A, E, R>) => GroupBy.GroupBy<R, E, K, A>;
-    <R, E, A, K>(self: Stream<A, E, R>, f: (a: A) => K, options?: {
+    }): <E, R>(self: Stream<A, E, R>) => GroupBy.GroupBy<K, A, E, R>;
+    <A, E, R, K>(self: Stream<A, E, R>, f: (a: A) => K, options?: {
         readonly bufferSize?: number | undefined;
-    }): GroupBy.GroupBy<R, E, K, A>;
+    }): GroupBy.GroupBy<K, A, E, R>;
 };
 /**
  * Partitions the stream with specified `chunkSize`.
@@ -1388,8 +1371,8 @@ export declare const haltAfter: {
  * @category utils
  */
 export declare const haltWhen: {
-    <R2, E2, _>(effect: Effect.Effect<_, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, _>(self: Stream<A, E, R>, effect: Effect.Effect<_, E2, R2>): Stream<A, E | E2, R | R2>;
+    <X, E2, R2>(effect: Effect.Effect<X, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, X, E2, R2>(self: Stream<A, E, R>, effect: Effect.Effect<X, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Halts the evaluation of this stream when the provided promise resolves.
@@ -1400,8 +1383,8 @@ export declare const haltWhen: {
  * @category utils
  */
 export declare const haltWhenDeferred: {
-    <E2, _>(deferred: Deferred.Deferred<_, E2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R>;
-    <R, E, A, E2, _>(self: Stream<A, E, R>, deferred: Deferred.Deferred<_, E2>): Stream<A, E | E2, R>;
+    <X, E2>(deferred: Deferred.Deferred<X, E2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R>;
+    <A, E, R, X, E2>(self: Stream<A, E, R>, deferred: Deferred.Deferred<X, E2>): Stream<A, E | E2, R>;
 };
 /**
  * The identity pipeline, which does not modify streams in any way.
@@ -1420,8 +1403,8 @@ export declare const identity: <A, E = never, R = never>() => Stream<A, E, R>;
  * @category utils
  */
 export declare const interleave: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A | A2, E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A | A2, E | E2, R | R2>;
 };
 /**
  * Combines this stream and the specified stream deterministically using the
@@ -1436,8 +1419,8 @@ export declare const interleave: {
  * @category utils
  */
 export declare const interleaveWith: {
-    <R2, E2, A2, R3, E3>(that: Stream<A2, E2, R2>, decider: Stream<boolean, E3, R3>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E3 | E, R2 | R3 | R>;
-    <R, E, A, R2, E2, A2, R3, E3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, decider: Stream<boolean, E3, R3>): Stream<A | A2, E | E2 | E3, R | R2 | R3>;
+    <A2, E2, R2, E3, R3>(that: Stream<A2, E2, R2>, decider: Stream<boolean, E3, R3>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E3 | E, R2 | R3 | R>;
+    <A, E, R, A2, E2, R2, E3, R3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, decider: Stream<boolean, E3, R3>): Stream<A | A2, E | E2 | E3, R | R2 | R3>;
 };
 /**
  * Intersperse stream with provided `element`.
@@ -1447,7 +1430,7 @@ export declare const interleaveWith: {
  */
 export declare const intersperse: {
     <A2>(element: A2): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E, R>;
-    <R, E, A, A2>(self: Stream<A, E, R>, element: A2): Stream<A | A2, E, R>;
+    <A, E, R, A2>(self: Stream<A, E, R>, element: A2): Stream<A | A2, E, R>;
 };
 /**
  * Intersperse the specified element, also adding a prefix and a suffix.
@@ -1461,7 +1444,7 @@ export declare const intersperseAffixes: {
         readonly middle: A3;
         readonly end: A4;
     }): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A3 | A4 | A, E, R>;
-    <R, E, A, A2, A3, A4>(self: Stream<A, E, R>, options: {
+    <A, E, R, A2, A3, A4>(self: Stream<A, E, R>, options: {
         readonly start: A2;
         readonly middle: A3;
         readonly end: A4;
@@ -1491,8 +1474,8 @@ export declare const interruptAfter: {
  * @category utils
  */
 export declare const interruptWhen: {
-    <R2, E2, _>(effect: Effect.Effect<_, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, _>(self: Stream<A, E, R>, effect: Effect.Effect<_, E2, R2>): Stream<A, E | E2, R | R2>;
+    <X, E2, R2>(effect: Effect.Effect<X, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, X, E2, R2>(self: Stream<A, E, R>, effect: Effect.Effect<X, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Interrupts the evaluation of this stream when the provided promise
@@ -1505,8 +1488,8 @@ export declare const interruptWhen: {
  * @category utils
  */
 export declare const interruptWhenDeferred: {
-    <E2, _>(deferred: Deferred.Deferred<_, E2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R>;
-    <R, E, A, E2, _>(self: Stream<A, E, R>, deferred: Deferred.Deferred<_, E2>): Stream<A, E | E2, R>;
+    <X, E2>(deferred: Deferred.Deferred<X, E2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R>;
+    <A, E, R, X, E2>(self: Stream<A, E, R>, deferred: Deferred.Deferred<X, E2>): Stream<A, E | E2, R>;
 };
 /**
  * The infinite stream of iterative function application: a, f(a), f(f(a)),
@@ -1530,8 +1513,8 @@ export declare const make: <As extends Array<any>>(...as: As) => Stream<As[numbe
  * @category mapping
  */
 export declare const map: {
-    <A, B>(f: (a: A) => B): <R, E>(self: Stream<A, E, R>) => Stream<B, E, R>;
-    <R, E, A, B>(self: Stream<A, E, R>, f: (a: A) => B): Stream<B, E, R>;
+    <A, B>(f: (a: A) => B): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
+    <A, E, R, B>(self: Stream<A, E, R>, f: (a: A) => B): Stream<B, E, R>;
 };
 /**
  * Statefully maps over the elements of this stream to produce new elements.
@@ -1540,8 +1523,8 @@ export declare const map: {
  * @category mapping
  */
 export declare const mapAccum: {
-    <S, A, A2>(s: S, f: (s: S, a: A) => readonly [S, A2]): <R, E>(self: Stream<A, E, R>) => Stream<A2, E, R>;
-    <R, E, S, A, A2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => readonly [S, A2]): Stream<A2, E, R>;
+    <S, A, A2>(s: S, f: (s: S, a: A) => readonly [S, A2]): <E, R>(self: Stream<A, E, R>) => Stream<A2, E, R>;
+    <A, E, R, S, A2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => readonly [S, A2]): Stream<A2, E, R>;
 };
 /**
  * Statefully and effectfully maps over the elements of this stream to produce
@@ -1551,8 +1534,8 @@ export declare const mapAccum: {
  * @category mapping
  */
 export declare const mapAccumEffect: {
-    <S, A, A2, E2, R2>(s: S, f: (s: S, a: A) => Effect.Effect<readonly [S, A2], E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <R, E, A, S, A2, E2, R2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<readonly [S, A2], E2, R2>): Stream<A2, E | E2, R | R2>;
+    <S, A, A2, E2, R2>(s: S, f: (s: S, a: A) => Effect.Effect<readonly [S, A2], E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, S, A2, E2, R2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<readonly [S, A2], E2, R2>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Returns a stream whose failure and success channels have been mapped by the
@@ -1566,7 +1549,7 @@ export declare const mapBoth: {
         readonly onFailure: (e: E) => E2;
         readonly onSuccess: (a: A) => A2;
     }): <R>(self: Stream<A, E, R>) => Stream<A2, E2, R>;
-    <R, E, E2, A, A2>(self: Stream<A, E, R>, options: {
+    <A, E, R, E2, A2>(self: Stream<A, E, R>, options: {
         readonly onFailure: (e: E) => E2;
         readonly onSuccess: (a: A) => A2;
     }): Stream<A2, E2, R>;
@@ -1579,7 +1562,7 @@ export declare const mapBoth: {
  */
 export declare const mapChunks: {
     <A, B>(f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<B>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
-    <R, E, A, B>(self: Stream<A, E, R>, f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<B>): Stream<B, E, R>;
+    <A, E, R, B>(self: Stream<A, E, R>, f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<B>): Stream<B, E, R>;
 };
 /**
  * Effectfully transforms the chunks emitted by this stream.
@@ -1588,8 +1571,8 @@ export declare const mapChunks: {
  * @category mapping
  */
 export declare const mapChunksEffect: {
-    <A, R2, E2, B>(f: (chunk: Chunk.Chunk<A>) => Effect.Effect<Chunk.Chunk<B>, E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<B, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, B>(self: Stream<A, E, R>, f: (chunk: Chunk.Chunk<A>) => Effect.Effect<Chunk.Chunk<B>, E2, R2>): Stream<B, E | E2, R | R2>;
+    <A, B, E2, R2>(f: (chunk: Chunk.Chunk<A>) => Effect.Effect<Chunk.Chunk<B>, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<B, E2 | E, R2 | R>;
+    <A, E, R, B, E2, R2>(self: Stream<A, E, R>, f: (chunk: Chunk.Chunk<A>) => Effect.Effect<Chunk.Chunk<B>, E2, R2>): Stream<B, E | E2, R | R2>;
 };
 /**
  * Maps each element to an iterable, and flattens the iterables into the
@@ -1599,8 +1582,8 @@ export declare const mapChunksEffect: {
  * @category mapping
  */
 export declare const mapConcat: {
-    <A, A2>(f: (a: A) => Iterable<A2>): <R, E>(self: Stream<A, E, R>) => Stream<A2, E, R>;
-    <R, E, A, A2>(self: Stream<A, E, R>, f: (a: A) => Iterable<A2>): Stream<A2, E, R>;
+    <A, A2>(f: (a: A) => Iterable<A2>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E, R>;
+    <A, E, R, A2>(self: Stream<A, E, R>, f: (a: A) => Iterable<A2>): Stream<A2, E, R>;
 };
 /**
  * Maps each element to a chunk, and flattens the chunks into the output of
@@ -1610,8 +1593,8 @@ export declare const mapConcat: {
  * @category mapping
  */
 export declare const mapConcatChunk: {
-    <A, A2>(f: (a: A) => Chunk.Chunk<A2>): <R, E>(self: Stream<A, E, R>) => Stream<A2, E, R>;
-    <R, E, A, A2>(self: Stream<A, E, R>, f: (a: A) => Chunk.Chunk<A2>): Stream<A2, E, R>;
+    <A, A2>(f: (a: A) => Chunk.Chunk<A2>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E, R>;
+    <A, E, R, A2>(self: Stream<A, E, R>, f: (a: A) => Chunk.Chunk<A2>): Stream<A2, E, R>;
 };
 /**
  * Effectfully maps each element to a chunk, and flattens the chunks into the
@@ -1621,8 +1604,8 @@ export declare const mapConcatChunk: {
  * @category mapping
  */
 export declare const mapConcatChunkEffect: {
-    <A, R2, E2, A2>(f: (a: A) => Effect.Effect<Chunk.Chunk<A2>, E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<Chunk.Chunk<A2>, E2, R2>): Stream<A2, E | E2, R | R2>;
+    <A, A2, E2, R2>(f: (a: A) => Effect.Effect<Chunk.Chunk<A2>, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<Chunk.Chunk<A2>, E2, R2>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Effectfully maps each element to an iterable, and flattens the iterables
@@ -1632,8 +1615,8 @@ export declare const mapConcatChunkEffect: {
  * @category mapping
  */
 export declare const mapConcatEffect: {
-    <A, R2, E2, A2>(f: (a: A) => Effect.Effect<Iterable<A2>, E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<Iterable<A2>, E2, R2>): Stream<A2, E | E2, R | R2>;
+    <A, A2, E2, R2>(f: (a: A) => Effect.Effect<Iterable<A2>, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<Iterable<A2>, E2, R2>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Maps over elements of the stream with the specified effectful function.
@@ -1642,19 +1625,19 @@ export declare const mapConcatEffect: {
  * @category mapping
  */
 export declare const mapEffect: {
-    <A, R2, E2, A2>(f: (a: A) => Effect.Effect<A2, E2, R2>, options?: {
+    <A, A2, E2, R2>(f: (a: A) => Effect.Effect<A2, E2, R2>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly unordered?: boolean | undefined;
-    } | undefined): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <A, R2, E2, A2, K>(f: (a: A) => Effect.Effect<A2, E2, R2>, options: {
+    } | undefined): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, A2, E2, R2, K>(f: (a: A) => Effect.Effect<A2, E2, R2>, options: {
         readonly key: (a: A) => K;
         readonly bufferSize?: number | undefined;
-    }): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<A2, E2, R2>, options?: {
+    }): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<A2, E2, R2>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly unordered?: boolean | undefined;
     } | undefined): Stream<A2, E | E2, R | R2>;
-    <R, E, A, R2, E2, A2, K>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<A2, E2, R2>, options: {
+    <A, E, R, A2, E2, R2, K>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<A2, E2, R2>, options: {
         readonly key: (a: A) => K;
         readonly bufferSize?: number | undefined;
     }): Stream<A2, E | E2, R | R2>;
@@ -1666,8 +1649,8 @@ export declare const mapEffect: {
  * @category mapping
  */
 export declare const mapError: {
-    <E, E2>(f: (error: E) => E2): <R, A>(self: Stream<A, E, R>) => Stream<A, E2, R>;
-    <R, A, E, E2>(self: Stream<A, E, R>, f: (error: E) => E2): Stream<A, E2, R>;
+    <E, E2>(f: (error: E) => E2): <A, R>(self: Stream<A, E, R>) => Stream<A, E2, R>;
+    <A, E, R, E2>(self: Stream<A, E, R>, f: (error: E) => E2): Stream<A, E2, R>;
 };
 /**
  * Transforms the full causes of failures emitted by this stream.
@@ -1676,8 +1659,8 @@ export declare const mapError: {
  * @category mapping
  */
 export declare const mapErrorCause: {
-    <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(self: Stream<A, E, R>) => Stream<A, E2, R>;
-    <R, A, E, E2>(self: Stream<A, E, R>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Stream<A, E2, R>;
+    <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E2, R>;
+    <A, E, R, E2>(self: Stream<A, E, R>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Stream<A, E2, R>;
 };
 /**
  * Merges this stream and the specified stream together.
@@ -1689,10 +1672,10 @@ export declare const mapErrorCause: {
  * @category utils
  */
 export declare const merge: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>, options?: {
+    <A2, E2, R2>(that: Stream<A2, E2, R2>, options?: {
         readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined;
     } | undefined): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, options?: {
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, options?: {
         readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined;
     } | undefined): Stream<A | A2, E | E2, R | R2>;
 };
@@ -1725,12 +1708,12 @@ export declare const mergeAll: {
  * @category utils
  */
 export declare const mergeWith: {
-    <R2, E2, A2, A, A3, A4>(other: Stream<A2, E2, R2>, options: {
+    <A2, E2, R2, A, A3, A4>(other: Stream<A2, E2, R2>, options: {
         readonly onSelf: (a: A) => A3;
         readonly onOther: (a2: A2) => A4;
         readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined;
-    }): <R, E>(self: Stream<A, E, R>) => Stream<A3 | A4, E2 | E, R2 | R>;
-    <R, E, R2, E2, A2, A, A3, A4>(self: Stream<A, E, R>, other: Stream<A2, E2, R2>, options: {
+    }): <E, R>(self: Stream<A, E, R>) => Stream<A3 | A4, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2, A3, A4>(self: Stream<A, E, R>, other: Stream<A2, E2, R2>, options: {
         readonly onSelf: (a: A) => A3;
         readonly onOther: (a2: A2) => A4;
         readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined;
@@ -1744,8 +1727,8 @@ export declare const mergeWith: {
  * @category utils
  */
 export declare const mergeEither: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A, A2>, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<Either.Either<A, A2>, E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A2, A>, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<Either.Either<A2, A>, E | E2, R | R2>;
 };
 /**
  * Merges this stream and the specified stream together, discarding the values
@@ -1755,8 +1738,8 @@ export declare const mergeEither: {
  * @category utils
  */
 export declare const mergeLeft: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Merges this stream and the specified stream together, discarding the values
@@ -1766,8 +1749,8 @@ export declare const mergeLeft: {
  * @category utils
  */
 export declare const mergeRight: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Returns a combined string resulting from concatenating each of the values
@@ -1776,7 +1759,7 @@ export declare const mergeRight: {
  * @since 2.0.0
  * @category utils
  */
-export declare const mkString: <R, E>(self: Stream<string, E, R>) => Effect.Effect<string, E, R>;
+export declare const mkString: <E, R>(self: Stream<string, E, R>) => Effect.Effect<string, E, R>;
 /**
  * The stream that never produces any value or fails with any error.
  *
@@ -1795,8 +1778,8 @@ export declare const never: Stream<never>;
  * @category utils
  */
 export declare const onError: {
-    <E, R2, _>(cleanup: (cause: Cause.Cause<E>) => Effect.Effect<_, never, R2>): <R, A>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
-    <R, A, E, R2, _>(self: Stream<A, E, R>, cleanup: (cause: Cause.Cause<E>) => Effect.Effect<_, never, R2>): Stream<A, E, R | R2>;
+    <E, X, R2>(cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
+    <A, E, R, X, R2>(self: Stream<A, E, R>, cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>): Stream<A, E, R | R2>;
 };
 /**
  * Runs the specified effect if this stream ends.
@@ -1805,8 +1788,8 @@ export declare const onError: {
  * @category utils
  */
 export declare const onDone: {
-    <R2, _>(cleanup: () => Effect.Effect<_, never, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
-    <R, E, A, R2, _>(self: Stream<A, E, R>, cleanup: () => Effect.Effect<_, never, R2>): Stream<A, E, R | R2>;
+    <X, R2>(cleanup: () => Effect.Effect<X, never, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
+    <A, E, R, X, R2>(self: Stream<A, E, R>, cleanup: () => Effect.Effect<X, never, R2>): Stream<A, E, R | R2>;
 };
 /**
  * Translates any failure into a stream termination, making the stream
@@ -1824,8 +1807,8 @@ export declare const orDie: <A, E, R>(self: Stream<A, E, R>) => Stream<A, never,
  * @category error handling
  */
 export declare const orDieWith: {
-    <E>(f: (e: E) => unknown): <R, A>(self: Stream<A, E, R>) => Stream<A, never, R>;
-    <R, A, E>(self: Stream<A, E, R>, f: (e: E) => unknown): Stream<A, never, R>;
+    <E>(f: (e: E) => unknown): <A, R>(self: Stream<A, E, R>) => Stream<A, never, R>;
+    <A, E, R>(self: Stream<A, E, R>, f: (e: E) => unknown): Stream<A, never, R>;
 };
 /**
  * Switches to the provided stream in case this one fails with a typed error.
@@ -1836,8 +1819,8 @@ export declare const orDieWith: {
  * @category error handling
  */
 export declare const orElse: {
-    <R2, E2, A2>(that: LazyArg<Stream<A2, E2, R2>>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: LazyArg<Stream<A2, E2, R2>>): Stream<A | A2, E2, R | R2>;
+    <A2, E2, R2>(that: LazyArg<Stream<A2, E2, R2>>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: LazyArg<Stream<A2, E2, R2>>): Stream<A | A2, E2, R | R2>;
 };
 /**
  * Switches to the provided stream in case this one fails with a typed error.
@@ -1848,8 +1831,8 @@ export declare const orElse: {
  * @category error handling
  */
 export declare const orElseEither: {
-    <R2, E2, A2>(that: LazyArg<Stream<A2, E2, R2>>): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A, A2>, E2, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: LazyArg<Stream<A2, E2, R2>>): Stream<Either.Either<A, A2>, E2, R | R2>;
+    <A2, E2, R2>(that: LazyArg<Stream<A2, E2, R2>>): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A2, A>, E2, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: LazyArg<Stream<A2, E2, R2>>): Stream<Either.Either<A2, A>, E2, R | R2>;
 };
 /**
  * Fails with given error in case this one fails with a typed error.
@@ -1861,7 +1844,7 @@ export declare const orElseEither: {
  */
 export declare const orElseFail: {
     <E2>(error: LazyArg<E2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2, R>;
-    <R, E, A, E2>(self: Stream<A, E, R>, error: LazyArg<E2>): Stream<A, E2, R>;
+    <A, E, R, E2>(self: Stream<A, E, R>, error: LazyArg<E2>): Stream<A, E2, R>;
 };
 /**
  * Produces the specified element if this stream is empty.
@@ -1871,7 +1854,7 @@ export declare const orElseFail: {
  */
 export declare const orElseIfEmpty: {
     <A2>(element: LazyArg<A2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E, R>;
-    <R, E, A, A2>(self: Stream<A, E, R>, element: LazyArg<A2>): Stream<A | A2, E, R>;
+    <A, E, R, A2>(self: Stream<A, E, R>, element: LazyArg<A2>): Stream<A | A2, E, R>;
 };
 /**
  * Produces the specified chunk if this stream is empty.
@@ -1881,7 +1864,7 @@ export declare const orElseIfEmpty: {
  */
 export declare const orElseIfEmptyChunk: {
     <A2>(chunk: LazyArg<Chunk.Chunk<A2>>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E, R>;
-    <R, E, A, A2>(self: Stream<A, E, R>, chunk: LazyArg<Chunk.Chunk<A2>>): Stream<A | A2, E, R>;
+    <A, E, R, A2>(self: Stream<A, E, R>, chunk: LazyArg<Chunk.Chunk<A2>>): Stream<A | A2, E, R>;
 };
 /**
  * Switches to the provided stream in case this one is empty.
@@ -1890,8 +1873,8 @@ export declare const orElseIfEmptyChunk: {
  * @category error handling
  */
 export declare const orElseIfEmptyStream: {
-    <R2, E2, A2>(stream: LazyArg<Stream<A2, E2, R2>>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, stream: LazyArg<Stream<A2, E2, R2>>): Stream<A | A2, E | E2, R | R2>;
+    <A2, E2, R2>(stream: LazyArg<Stream<A2, E2, R2>>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, stream: LazyArg<Stream<A2, E2, R2>>): Stream<A | A2, E | E2, R | R2>;
 };
 /**
  * Succeeds with the specified value if this one fails with a typed error.
@@ -1901,7 +1884,7 @@ export declare const orElseIfEmptyStream: {
  */
 export declare const orElseSucceed: {
     <A2>(value: LazyArg<A2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, never, R>;
-    <R, E, A, A2>(self: Stream<A, E, R>, value: LazyArg<A2>): Stream<A | A2, never, R>;
+    <A, E, R, A2>(self: Stream<A, E, R>, value: LazyArg<A2>): Stream<A | A2, never, R>;
 };
 /**
  * Like `Stream.unfold`, but allows the emission of values to end one step further
@@ -1929,7 +1912,7 @@ export declare const paginateChunk: <S, A>(s: S, f: (s: S) => readonly [Chunk.Ch
  * @since 2.0.0
  * @category constructors
  */
-export declare const paginateChunkEffect: <S, R, E, A>(s: S, f: (s: S) => Effect.Effect<readonly [Chunk.Chunk<A>, Option.Option<S>], E, R>) => Stream<A, E, R>;
+export declare const paginateChunkEffect: <S, A, E, R>(s: S, f: (s: S) => Effect.Effect<readonly [Chunk.Chunk<A>, Option.Option<S>], E, R>) => Stream<A, E, R>;
 /**
  * Like `Stream.unfoldEffect` but allows the emission of values to end one step
  * further than the unfolding of the state. This is useful for embedding
@@ -1938,7 +1921,7 @@ export declare const paginateChunkEffect: <S, R, E, A>(s: S, f: (s: S) => Effect
  * @since 2.0.0
  * @category constructors
  */
-export declare const paginateEffect: <S, R, E, A>(s: S, f: (s: S) => Effect.Effect<readonly [A, Option.Option<S>], E, R>) => Stream<A, E, R>;
+export declare const paginateEffect: <S, A, E, R>(s: S, f: (s: S) => Effect.Effect<readonly [A, Option.Option<S>], E, R>) => Stream<A, E, R>;
 /**
  * Partition a stream using a predicate. The first stream will contain all
  * element evaluated to true and the second one will contain all element
@@ -1951,16 +1934,16 @@ export declare const paginateEffect: <S, R, E, A>(s: S, f: (s: S) => Effect.Effe
 export declare const partition: {
     <C extends A, B extends A, A = C>(refinement: Refinement<NoInfer<A>, B>, options?: {
         bufferSize?: number | undefined;
-    } | undefined): <R, E>(self: Stream<C, E, R>) => Effect.Effect<[excluded: Stream<Exclude<C, B>, E>, satisfying: Stream<B, E>], E, Scope.Scope | R>;
+    } | undefined): <E, R>(self: Stream<C, E, R>) => Effect.Effect<[excluded: Stream<Exclude<C, B>, E, never>, satisfying: Stream<B, E, never>], E, R | Scope.Scope>;
     <A>(predicate: Predicate<A>, options?: {
         bufferSize?: number | undefined;
-    } | undefined): <R, E>(self: Stream<A, E, R>) => Effect.Effect<[excluded: Stream<A, E>, satisfying: Stream<A, E>], E, Scope.Scope | R>;
-    <R, E, C extends A, B extends A, A = C>(self: Stream<C, E, R>, refinement: Refinement<A, B>, options?: {
+    } | undefined): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[excluded: Stream<A, E, never>, satisfying: Stream<A, E, never>], E, Scope.Scope | R>;
+    <C extends A, E, R, B extends A, A = C>(self: Stream<C, E, R>, refinement: Refinement<A, B>, options?: {
         bufferSize?: number | undefined;
-    } | undefined): Effect.Effect<[excluded: Stream<Exclude<C, B>, E>, satisfying: Stream<B, E>], E, Scope.Scope | R>;
+    } | undefined): Effect.Effect<[excluded: Stream<Exclude<C, B>, E, never>, satisfying: Stream<B, E, never>], E, R | Scope.Scope>;
     <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>, options?: {
         bufferSize?: number | undefined;
-    } | undefined): Effect.Effect<[excluded: Stream<A, E>, satisfying: Stream<A, E>], E, Scope.Scope | R>;
+    } | undefined): Effect.Effect<[excluded: Stream<A, E, never>, satisfying: Stream<A, E, never>], E, R | Scope.Scope>;
 };
 /**
  * Split a stream by an effectful predicate. The faster stream may advance by
@@ -1970,12 +1953,12 @@ export declare const partition: {
  * @category utils
  */
 export declare const partitionEither: {
-    <A, R2, E2, A2, A3>(predicate: (a: NoInfer<A>) => Effect.Effect<Either.Either<A2, A3>, E2, R2>, options?: {
+    <A, A3, A2, E2, R2>(predicate: (a: NoInfer<A>) => Effect.Effect<Either.Either<A3, A2>, E2, R2>, options?: {
         readonly bufferSize?: number | undefined;
-    } | undefined): <R, E>(self: Stream<A, E, R>) => Effect.Effect<[left: Stream<A2, E2 | E>, right: Stream<A3, E2 | E>], E2 | E, Scope.Scope | R2 | R>;
-    <R, E, A, R2, E2, A2, A3>(self: Stream<A, E, R>, predicate: (a: A) => Effect.Effect<Either.Either<A2, A3>, E2, R2>, options?: {
+    } | undefined): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[left: Stream<A2, E2 | E, never>, right: Stream<A3, E2 | E, never>], E2 | E, Scope.Scope | R2 | R>;
+    <A, E, R, A3, A2, E2, R2>(self: Stream<A, E, R>, predicate: (a: A) => Effect.Effect<Either.Either<A3, A2>, E2, R2>, options?: {
         readonly bufferSize?: number | undefined;
-    } | undefined): Effect.Effect<[left: Stream<A2, E | E2>, right: Stream<A3, E | E2>], E | E2, Scope.Scope | R | R2>;
+    } | undefined): Effect.Effect<[left: Stream<A2, E | E2, never>, right: Stream<A3, E | E2, never>], E | E2, Scope.Scope | R | R2>;
 };
 /**
  * Peels off enough material from the stream to construct a `Z` using the
@@ -2031,7 +2014,7 @@ export declare const pipeThroughChannelOrFail: {
  */
 export declare const prepend: {
     <B>(values: Chunk.Chunk<B>): <A, E, R>(self: Stream<A, E, R>) => Stream<B | A, E, R>;
-    <R, E, A, B>(self: Stream<A, E, R>, values: Chunk.Chunk<B>): Stream<A | B, E, R>;
+    <A, E, R, B>(self: Stream<A, E, R>, values: Chunk.Chunk<B>): Stream<A | B, E, R>;
 };
 /**
  * Provides the stream with its required context, which eliminates its
@@ -2063,7 +2046,7 @@ export declare const provideLayer: {
  */
 export declare const provideService: {
     <T extends Context.Tag<any, any>>(tag: T, resource: Context.Tag.Service<T>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
-    <R, E, A, T extends Context.Tag<any, any>>(self: Stream<A, E, R>, tag: T, resource: Context.Tag.Service<T>): Stream<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
+    <A, E, R, T extends Context.Tag<any, any>>(self: Stream<A, E, R>, tag: T, resource: Context.Tag.Service<T>): Stream<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
 };
 /**
  * Provides the stream with the single service it requires. If the stream
@@ -2073,8 +2056,8 @@ export declare const provideService: {
  * @category context
  */
 export declare const provideServiceEffect: {
-    <T extends Context.Tag<any, any>, R2, E2>(tag: T, effect: Effect.Effect<Context.Tag.Service<T>, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, Context.Tag.Identifier<T>>>;
-    <R, E, A, T extends Context.Tag<any, any>, R2, E2>(self: Stream<A, E, R>, tag: T, effect: Effect.Effect<Context.Tag.Service<T>, E2, R2>): Stream<A, E | E2, R2 | Exclude<R, Context.Tag.Identifier<T>>>;
+    <T extends Context.Tag<any, any>, E2, R2>(tag: T, effect: Effect.Effect<Context.Tag.Service<T>, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, Context.Tag.Identifier<T>>>;
+    <A, E, R, T extends Context.Tag<any, any>, E2, R2>(self: Stream<A, E, R>, tag: T, effect: Effect.Effect<Context.Tag.Service<T>, E2, R2>): Stream<A, E | E2, R2 | Exclude<R, Context.Tag.Identifier<T>>>;
 };
 /**
  * Provides the stream with the single service it requires. If the stream
@@ -2084,8 +2067,8 @@ export declare const provideServiceEffect: {
  * @category context
  */
 export declare const provideServiceStream: {
-    <T extends Context.Tag<any, any>, R2, E2>(tag: T, stream: Stream<Context.Tag.Service<T>, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, Context.Tag.Identifier<T>>>;
-    <R, E, A, T extends Context.Tag<any, any>, R2, E2>(self: Stream<A, E, R>, tag: T, stream: Stream<Context.Tag.Service<T>, E2, R2>): Stream<A, E | E2, R2 | Exclude<R, Context.Tag.Identifier<T>>>;
+    <T extends Context.Tag<any, any>, E2, R2>(tag: T, stream: Stream<Context.Tag.Service<T>, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, Context.Tag.Identifier<T>>>;
+    <A, E, R, T extends Context.Tag<any, any>, E2, R2>(self: Stream<A, E, R>, tag: T, stream: Stream<Context.Tag.Service<T>, E2, R2>): Stream<A, E | E2, R2 | Exclude<R, Context.Tag.Identifier<T>>>;
 };
 /**
  * Transforms the context being provided to the stream with the specified
@@ -2107,7 +2090,7 @@ export declare const mapInputContext: {
  */
 export declare const provideSomeLayer: {
     <RIn, E2, ROut>(layer: Layer.Layer<ROut, E2, RIn>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, RIn | Exclude<R, ROut>>;
-    <R, E, A, RIn, E2, ROut>(self: Stream<A, E, R>, layer: Layer.Layer<ROut, E2, RIn>): Stream<A, E | E2, RIn | Exclude<R, ROut>>;
+    <A, E, R, RIn, E2, ROut>(self: Stream<A, E, R>, layer: Layer.Layer<ROut, E2, RIn>): Stream<A, E | E2, RIn | Exclude<R, ROut>>;
 };
 /**
  * Constructs a stream from a range of integers, including both endpoints.
@@ -2134,8 +2117,8 @@ export declare const rechunk: {
  * @category error handling
  */
 export declare const refineOrDie: {
-    <E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: Stream<A, E, R>) => Stream<A, E2, R>;
-    <R, A, E, E2>(self: Stream<A, E, R>, pf: (error: E) => Option.Option<E2>): Stream<A, E2, R>;
+    <E, E2>(pf: (error: E) => Option.Option<E2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E2, R>;
+    <A, E, R, E2>(self: Stream<A, E, R>, pf: (error: E) => Option.Option<E2>): Stream<A, E2, R>;
 };
 /**
  * Keeps some of the errors, and terminates the fiber with the rest, using the
@@ -2145,8 +2128,8 @@ export declare const refineOrDie: {
  * @category error handling
  */
 export declare const refineOrDieWith: {
-    <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <R, A>(self: Stream<A, E, R>) => Stream<A, E2, R>;
-    <R, A, E, E2>(self: Stream<A, E, R>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): Stream<A, E2, R>;
+    <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <A, R>(self: Stream<A, E, R>) => Stream<A, E2, R>;
+    <A, E, R, E2>(self: Stream<A, E, R>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): Stream<A, E2, R>;
 };
 /**
  * Repeats the entire stream using the specified schedule. The stream will
@@ -2156,8 +2139,8 @@ export declare const refineOrDieWith: {
  * @category utils
  */
 export declare const repeat: {
-    <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
-    <R, E, A, R2, B>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<A, E, R | R2>;
+    <B, R2>(schedule: Schedule.Schedule<B, unknown, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
+    <A, E, R, B, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<B, unknown, R2>): Stream<A, E, R | R2>;
 };
 /**
  * Creates a stream from an effect producing a value of type `A` which repeats
@@ -2198,7 +2181,7 @@ export declare const repeatEffectOption: <A, E, R>(effect: Effect.Effect<A, Opti
  * @since 2.0.0
  * @category constructors
  */
-export declare const repeatEffectWithSchedule: <R, E, A, A0 extends A, R2, _>(effect: Effect.Effect<A, E, R>, schedule: Schedule.Schedule<R2, A0, _>) => Stream<A, E, R | R2>;
+export declare const repeatEffectWithSchedule: <A, E, R, X, A0 extends A, R2>(effect: Effect.Effect<A, E, R>, schedule: Schedule.Schedule<X, A0, R2>) => Stream<A, E, R | R2>;
 /**
  * Repeats the entire stream using the specified schedule. The stream will
  * execute normally, and then repeat again according to the provided schedule.
@@ -2208,8 +2191,8 @@ export declare const repeatEffectWithSchedule: <R, E, A, A0 extends A, R2, _>(ef
  * @category utils
  */
 export declare const repeatEither: {
-    <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<B, A>, E, R2 | R>;
-    <R, E, A, R2, B>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<Either.Either<B, A>, E, R | R2>;
+    <B, R2>(schedule: Schedule.Schedule<B, unknown, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A, B>, E, R2 | R>;
+    <A, E, R, B, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<B, unknown, R2>): Stream<Either.Either<A, B>, E, R | R2>;
 };
 /**
  * Repeats each element of the stream using the provided schedule. Repetitions
@@ -2222,8 +2205,8 @@ export declare const repeatEither: {
  * @category utils
  */
 export declare const repeatElements: {
-    <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
-    <R, E, A, R2, B>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<A, E, R | R2>;
+    <B, R2>(schedule: Schedule.Schedule<B, unknown, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
+    <A, E, R, B, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<B, unknown, R2>): Stream<A, E, R | R2>;
 };
 /**
  * Repeats each element of the stream using the provided schedule. When the
@@ -2241,11 +2224,11 @@ export declare const repeatElements: {
  * @category utils
  */
 export declare const repeatElementsWith: {
-    <R2, B, A, C>(schedule: Schedule.Schedule<R2, unknown, B>, options: {
+    <B, R2, A, C>(schedule: Schedule.Schedule<B, unknown, R2>, options: {
         readonly onElement: (a: A) => C;
         readonly onSchedule: (b: B) => C;
-    }): <R, E>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>;
-    <R, E, R2, B, A, C>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, unknown, B>, options: {
+    }): <E, R>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>;
+    <A, E, R, B, R2, C>(self: Stream<A, E, R>, schedule: Schedule.Schedule<B, unknown, R2>, options: {
         readonly onElement: (a: A) => C;
         readonly onSchedule: (b: B) => C;
     }): Stream<C, E, R | R2>;
@@ -2267,11 +2250,11 @@ export declare const repeatValue: <A>(value: A) => Stream<A>;
  * @category utils
  */
 export declare const repeatWith: {
-    <R2, B, A, C>(schedule: Schedule.Schedule<R2, unknown, B>, options: {
+    <B, R2, A, C>(schedule: Schedule.Schedule<B, unknown, R2>, options: {
         readonly onElement: (a: A) => C;
         readonly onSchedule: (b: B) => C;
-    }): <R, E>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>;
-    <R, E, R2, B, A, C>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, unknown, B>, options: {
+    }): <E, R>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>;
+    <A, E, R, B, R2, C>(self: Stream<A, E, R>, schedule: Schedule.Schedule<B, unknown, R2>, options: {
         readonly onElement: (a: A) => C;
         readonly onSchedule: (b: B) => C;
     }): Stream<C, E, R | R2>;
@@ -2290,8 +2273,8 @@ export declare const repeatWith: {
  * @category utils
  */
 export declare const retry: {
-    <R2, E, E0 extends E, _>(schedule: Schedule.Schedule<R2, E0, _>): <R, A>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
-    <R, A, R2, E, E0 extends E, _>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, E0, _>): Stream<A, E, R | R2>;
+    <E0 extends E, R2, E, X>(schedule: Schedule.Schedule<X, E0, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
+    <A, E, R, X, E0 extends E, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<X, E0, R2>): Stream<A, E, R | R2>;
 };
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
@@ -2332,8 +2315,8 @@ export declare const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect
  * @category destructors
  */
 export declare const runFold: {
-    <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>;
-    <R, E, S, A>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, R>;
+    <S, A>(s: S, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>;
+    <A, E, R, S>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, R>;
 };
 /**
  * Executes an effectful fold over the stream of values.
@@ -2342,8 +2325,8 @@ export declare const runFold: {
  * @category destructors
  */
 export declare const runFoldEffect: {
-    <S, A, R2, E2>(s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R>;
-    <R, E, S, A, R2, E2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, R | R2>;
+    <S, A, E2, R2>(s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R>;
+    <A, E, R, S, E2, R2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, R | R2>;
 };
 /**
  * Executes a pure fold over the stream of values. Returns a scoped value that
@@ -2353,8 +2336,8 @@ export declare const runFoldEffect: {
  * @category destructors
  */
 export declare const runFoldScoped: {
-    <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E, Scope.Scope | R>;
-    <R, E, S, A>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, Scope.Scope | R>;
+    <S, A>(s: S, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, Scope.Scope | R>;
+    <A, E, R, S>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, Scope.Scope | R>;
 };
 /**
  * Executes an effectful fold over the stream of values. Returns a scoped
@@ -2364,8 +2347,8 @@ export declare const runFoldScoped: {
  * @category destructors
  */
 export declare const runFoldScopedEffect: {
-    <S, A, R2, E2>(s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Scope.Scope | R2 | R>;
-    <R, E, S, A, R2, E2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, Scope.Scope | R | R2>;
+    <S, A, E2, R2>(s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Scope.Scope | R2 | R>;
+    <A, E, R, S, E2, R2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, Scope.Scope | R | R2>;
 };
 /**
  * Reduces the elements in the stream to a value of type `S`. Stops the fold
@@ -2375,8 +2358,8 @@ export declare const runFoldScopedEffect: {
  * @category destructors
  */
 export declare const runFoldWhile: {
-    <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>;
-    <R, E, S, A>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<S, E, R>;
+    <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>;
+    <A, E, R, S>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<S, E, R>;
 };
 /**
  * Executes an effectful fold over the stream of values. Stops the fold early
@@ -2386,8 +2369,8 @@ export declare const runFoldWhile: {
  * @category destructors
  */
 export declare const runFoldWhileEffect: {
-    <S, A, R2, E2>(s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R>;
-    <R, E, S, A, R2, E2>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, R | R2>;
+    <S, A, E2, R2>(s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R>;
+    <A, E, R, S, E2, R2>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, R | R2>;
 };
 /**
  * Executes a pure fold over the stream of values. Returns a scoped value that
@@ -2398,8 +2381,8 @@ export declare const runFoldWhileEffect: {
  * @category destructors
  */
 export declare const runFoldWhileScoped: {
-    <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E, Scope.Scope | R>;
-    <R, E, S, A>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<S, E, Scope.Scope | R>;
+    <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, Scope.Scope | R>;
+    <A, E, R, S>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<S, E, Scope.Scope | R>;
 };
 /**
  * Executes an effectful fold over the stream of values. Returns a scoped
@@ -2410,8 +2393,8 @@ export declare const runFoldWhileScoped: {
  * @category destructors
  */
 export declare const runFoldWhileScopedEffect: {
-    <S, A, R2, E2>(s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Scope.Scope | R2 | R>;
-    <R, E, S, A, R2, E2>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, Scope.Scope | R | R2>;
+    <S, A, E2, R2>(s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R | Scope.Scope>;
+    <A, E, R, S, E2, R2>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, Scope.Scope | R | R2>;
 };
 /**
  * Consumes all elements of the stream, passing them to the specified
@@ -2421,8 +2404,8 @@ export declare const runFoldWhileScopedEffect: {
  * @category destructors
  */
 export declare const runForEach: {
-    <A, R2, E2, _>(f: (a: A) => Effect.Effect<_, E2, R2>): <R, E>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, _>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<_, E2, R2>): Effect.Effect<void, E | E2, R | R2>;
+    <A, X, E2, R2>(f: (a: A) => Effect.Effect<X, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>;
+    <A, E, R, X, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<X, E2, R2>): Effect.Effect<void, E | E2, R | R2>;
 };
 /**
  * Consumes all elements of the stream, passing them to the specified
@@ -2432,8 +2415,8 @@ export declare const runForEach: {
  * @category destructors
  */
 export declare const runForEachChunk: {
-    <A, R2, E2, _>(f: (a: Chunk.Chunk<A>) => Effect.Effect<_, E2, R2>): <R, E>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, _>(self: Stream<A, E, R>, f: (a: Chunk.Chunk<A>) => Effect.Effect<_, E2, R2>): Effect.Effect<void, E | E2, R | R2>;
+    <A, X, E2, R2>(f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>;
+    <A, E, R, X, E2, R2>(self: Stream<A, E, R>, f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>): Effect.Effect<void, E | E2, R | R2>;
 };
 /**
  * Like `Stream.runForEachChunk`, but returns a scoped effect so the
@@ -2443,8 +2426,8 @@ export declare const runForEachChunk: {
  * @category destructors
  */
 export declare const runForEachChunkScoped: {
-    <A, R2, E2, _>(f: (a: Chunk.Chunk<A>) => Effect.Effect<_, E2, R2>): <R, E>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>;
-    <R, E, A, R2, E2, _>(self: Stream<A, E, R>, f: (a: Chunk.Chunk<A>) => Effect.Effect<_, E2, R2>): Effect.Effect<void, E | E2, Scope.Scope | R | R2>;
+    <A, X, E2, R2>(f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>;
+    <A, E, R, X, E2, R2>(self: Stream<A, E, R>, f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>): Effect.Effect<void, E | E2, Scope.Scope | R | R2>;
 };
 /**
  * Like `Stream.forEach`, but returns a scoped effect so the finalization
@@ -2454,8 +2437,8 @@ export declare const runForEachChunkScoped: {
  * @category destructors
  */
 export declare const runForEachScoped: {
-    <A, R2, E2, _>(f: (a: A) => Effect.Effect<_, E2, R2>): <R, E>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>;
-    <R, E, A, R2, E2, _>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<_, E2, R2>): Effect.Effect<void, E | E2, Scope.Scope | R | R2>;
+    <A, X, E2, R2>(f: (a: A) => Effect.Effect<X, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>;
+    <A, E, R, X, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<X, E2, R2>): Effect.Effect<void, E | E2, Scope.Scope | R | R2>;
 };
 /**
  * Consumes elements of the stream, passing them to the specified callback,
@@ -2465,8 +2448,8 @@ export declare const runForEachScoped: {
  * @category destructors
  */
 export declare const runForEachWhile: {
-    <A, R2, E2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <R, E>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>;
-    <R, E, A, R2, E2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Effect.Effect<void, E | E2, R | R2>;
+    <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Effect.Effect<void, E | E2, R | R2>;
 };
 /**
  * Like `Stream.runForEachWhile`, but returns a scoped effect so the
@@ -2476,8 +2459,8 @@ export declare const runForEachWhile: {
  * @category destructors
  */
 export declare const runForEachWhileScoped: {
-    <A, R2, E2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <R, E>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>;
-    <R, E, A, R2, E2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Effect.Effect<void, E | E2, Scope.Scope | R | R2>;
+    <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>;
+    <A, E, R, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Effect.Effect<void, E | E2, Scope.Scope | R | R2>;
 };
 /**
  * Runs the stream to completion and yields the first value emitted by it,
@@ -2564,7 +2547,7 @@ export declare const runScoped: {
  * @since 2.0.0
  * @category destructors
  */
-export declare const runSum: <R, E>(self: Stream<number, E, R>) => Effect.Effect<number, E, R>;
+export declare const runSum: <E, R>(self: Stream<number, E, R>) => Effect.Effect<number, E, R>;
 /**
  * Statefully maps over the elements of this stream to produce all
  * intermediate results of type `S` given an initial S.
@@ -2573,8 +2556,8 @@ export declare const runSum: <R, E>(self: Stream<number, E, R>) => Effect.Effect
  * @category utils
  */
 export declare const scan: {
-    <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<A, E, R>) => Stream<S, E, R>;
-    <R, E, S, A>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Stream<S, E, R>;
+    <S, A>(s: S, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Stream<S, E, R>;
+    <A, E, R, S>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Stream<S, E, R>;
 };
 /**
  * Statefully and effectfully maps over the elements of this stream to produce
@@ -2584,8 +2567,8 @@ export declare const scan: {
  * @category utils
  */
 export declare const scanEffect: {
-    <S, A, R2, E2>(s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<S, E2 | E, R2 | R>;
-    <R, E, S, A, R2, E2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Stream<S, E | E2, R | R2>;
+    <S, A, E2, R2>(s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<S, E2 | E, R2 | R>;
+    <A, E, R, S, E2, R2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Stream<S, E | E2, R | R2>;
 };
 /**
  * Statefully maps over the elements of this stream to produce all
@@ -2597,8 +2580,8 @@ export declare const scanEffect: {
  * @category utils
  */
 export declare const scanReduce: {
-    <A2, A>(f: (a2: A2 | A, a: A) => A2): <R, E>(self: Stream<A, E, R>) => Stream<A2 | A, E, R>;
-    <R, E, A2, A>(self: Stream<A, E, R>, f: (a2: A2 | A, a: A) => A2): Stream<A2 | A, E, R>;
+    <A2, A>(f: (a2: A2 | A, a: A) => A2): <E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E, R>;
+    <A, E, R, A2>(self: Stream<A, E, R>, f: (a2: A | A2, a: A) => A2): Stream<A | A2, E, R>;
 };
 /**
  * Statefully and effectfully maps over the elements of this stream to produce
@@ -2609,7 +2592,10 @@ export declare const scanReduce: {
  * @since 2.0.0
  * @category utils
  */
-export declare const scanReduceEffect: (<A2, A, R2, E2>(f: (a2: A2 | A, a: A) => Effect.Effect<A2 | A, E2, R2>) => <R, E>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>) & (<R_1, E_1, A2_1, A_1, R2_1, E2_1>(self: Stream<A_1, E_1, R_1>, f: (a2: A2_1 | A_1, a: A_1) => Effect.Effect<A2_1 | A_1, E2_1, R2_1>) => Stream<A2_1 | A_1, E_1 | E2_1, R_1 | R2_1>);
+export declare const scanReduceEffect: {
+    <A2, A, E2, R2>(f: (a2: A2 | A, a: A) => Effect.Effect<A2 | A, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (a2: A | A2, a: A) => Effect.Effect<A | A2, E2, R2>): Stream<A | A2, E | E2, R | R2>;
+};
 /**
  * Schedules the output of the stream using the provided `schedule`.
  *
@@ -2617,8 +2603,8 @@ export declare const scanReduceEffect: (<A2, A, R2, E2>(f: (a2: A2 | A, a: A) =>
  * @category utils
  */
 export declare const schedule: {
-    <R2, A, A0 extends A, _>(schedule: Schedule.Schedule<R2, A0, _>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
-    <R, E, R2, A, A0 extends A, _>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, A0, _>): Stream<A, E, R | R2>;
+    <X, A0 extends A, R2, A>(schedule: Schedule.Schedule<X, A0, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>;
+    <A, E, R, X, A0 extends A, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<X, A0, R2>): Stream<A, E, R | R2>;
 };
 /**
  * Schedules the output of the stream using the provided `schedule` and emits
@@ -2629,11 +2615,11 @@ export declare const schedule: {
  * @category utils
  */
 export declare const scheduleWith: {
-    <R2, A, A0 extends A, B, C>(schedule: Schedule.Schedule<R2, A0, B>, options: {
+    <B, A0 extends A, R2, A, C>(schedule: Schedule.Schedule<B, A0, R2>, options: {
         readonly onElement: (a: A) => C;
         readonly onSchedule: (b: B) => C;
-    }): <R, E>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>;
-    <R, E, R2, A, A0 extends A, B, C>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, A0, B>, options: {
+    }): <E, R>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>;
+    <A, E, R, B, A0 extends A, R2, C>(self: Stream<A, E, R>, schedule: Schedule.Schedule<B, A0, R2>, options: {
         readonly onElement: (a: A) => C;
         readonly onSchedule: (b: B) => C;
     }): Stream<C, E, R | R2>;
@@ -2692,7 +2678,7 @@ export declare const some: <A, E, R>(self: Stream<Option.Option<A>, E, R>) => St
  */
 export declare const someOrElse: {
     <A2>(fallback: LazyArg<A2>): <A, E, R>(self: Stream<Option.Option<A>, E, R>) => Stream<A2 | A, E, R>;
-    <R, E, A, A2>(self: Stream<Option.Option<A>, E, R>, fallback: LazyArg<A2>): Stream<A | A2, E, R>;
+    <A, E, R, A2>(self: Stream<Option.Option<A>, E, R>, fallback: LazyArg<A2>): Stream<A | A2, E, R>;
 };
 /**
  * Extracts the optional value, or fails with the given error 'e'.
@@ -2702,7 +2688,7 @@ export declare const someOrElse: {
  */
 export declare const someOrFail: {
     <E2>(error: LazyArg<E2>): <A, E, R>(self: Stream<Option.Option<A>, E, R>) => Stream<A, E2 | E, R>;
-    <R, E, A, E2>(self: Stream<Option.Option<A>, E, R>, error: LazyArg<E2>): Stream<A, E | E2, R>;
+    <A, E, R, E2>(self: Stream<Option.Option<A>, E, R>, error: LazyArg<E2>): Stream<A, E | E2, R>;
 };
 /**
  * Splits elements based on a predicate.
@@ -2723,7 +2709,7 @@ export declare const someOrFail: {
  * @category utils
  */
 export declare const split: {
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>;
     <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<Chunk.Chunk<A>, E, R>;
 };
 /**
@@ -2733,7 +2719,7 @@ export declare const split: {
  * @category utils
  */
 export declare const splitOnChunk: {
-    <A>(delimiter: Chunk.Chunk<A>): <R, E>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>;
+    <A>(delimiter: Chunk.Chunk<A>): <E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>;
     <A, E, R>(self: Stream<A, E, R>, delimiter: Chunk.Chunk<A>): Stream<Chunk.Chunk<A>, E, R>;
 };
 /**
@@ -2743,7 +2729,7 @@ export declare const splitOnChunk: {
  * @since 2.0.0
  * @category combinators
  */
-export declare const splitLines: <R, E>(self: Stream<string, E, R>) => Stream<string, E, R>;
+export declare const splitLines: <E, R>(self: Stream<string, E, R>) => Stream<string, E, R>;
 /**
  * Creates a single-valued pure stream.
  *
@@ -2793,7 +2779,7 @@ export declare const takeRight: {
  * @category utils
  */
 export declare const takeUntil: {
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
@@ -2804,8 +2790,8 @@ export declare const takeUntil: {
  * @category utils
  */
 export declare const takeUntilEffect: {
-    <A, R2, E2>(predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2>(self: Stream<A, E, R>, predicate: (a: A) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
+    <A, E2, R2>(predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: Stream<A, E, R>, predicate: (a: A) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Takes all elements of the stream for as long as the specified predicate
@@ -2815,9 +2801,9 @@ export declare const takeUntilEffect: {
  * @category utils
  */
 export declare const takeWhile: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<A, E, R>) => Stream<B, E, R>;
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>;
-    <R, E, A, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>): Stream<B, E, R>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>): Stream<B, E, R>;
     <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
@@ -2827,8 +2813,8 @@ export declare const takeWhile: {
  * @category sequencing
  */
 export declare const tap: {
-    <A, R2, E2, _>(f: (a: NoInfer<A>) => Effect.Effect<_, E2, R2>): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, _>(self: Stream<A, E, R>, f: (a: NoInfer<A>) => Effect.Effect<_, E2, R2>): Stream<A, E | E2, R | R2>;
+    <A, X, E2, R2>(f: (a: NoInfer<A>) => Effect.Effect<X, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, X, E2, R2>(self: Stream<A, E, R>, f: (a: NoInfer<A>) => Effect.Effect<X, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Returns a stream that effectfully "peeks" at the failure or success of
@@ -2838,11 +2824,11 @@ export declare const tap: {
  * @category sequencing
  */
 export declare const tapBoth: {
-    <E, R2, E2, X1, A, R3, E3, X2>(options: {
+    <E, X1, E2, R2, A, X2, E3, R3>(options: {
         readonly onFailure: (e: NoInfer<E>) => Effect.Effect<X1, E2, R2>;
         readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<X2, E3, R3>;
     }): <R>(self: Stream<A, E, R>) => Stream<A, E | E2 | E3, R2 | R3 | R>;
-    <R, E, A, R2, E2, X1, R3, E3, X2>(self: Stream<A, E, R>, options: {
+    <A, E, R, X1, E2, R2, X2, E3, R3>(self: Stream<A, E, R>, options: {
         readonly onFailure: (e: NoInfer<E>) => Effect.Effect<X1, E2, R2>;
         readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<X2, E3, R3>;
     }): Stream<A, E | E2 | E3, R | R2 | R3>;
@@ -2854,8 +2840,8 @@ export declare const tapBoth: {
  * @category sequencing
  */
 export declare const tapError: {
-    <E, R2, E2, _>(f: (error: NoInfer<E>) => Effect.Effect<_, E2, R2>): <R, A>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>;
-    <R, A, E, R2, E2, _>(self: Stream<A, E, R>, f: (error: E) => Effect.Effect<_, E2, R2>): Stream<A, E | E2, R | R2>;
+    <E, X, E2, R2>(f: (error: NoInfer<E>) => Effect.Effect<X, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>;
+    <A, E, R, X, E2, R2>(self: Stream<A, E, R>, f: (error: E) => Effect.Effect<X, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Returns a stream that effectfully "peeks" at the cause of failure of the
@@ -2865,8 +2851,8 @@ export declare const tapError: {
  * @category utils
  */
 export declare const tapErrorCause: {
-    <E, R2, E2, _>(f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<_, E2, R2>): <R, A>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>;
-    <R, A, E, R2, E2, _>(self: Stream<A, E, R>, f: (cause: Cause.Cause<E>) => Effect.Effect<_, E2, R2>): Stream<A, E | E2, R | R2>;
+    <E, X, E2, R2>(f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<X, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>;
+    <A, E, R, X, E2, R2>(self: Stream<A, E, R>, f: (cause: Cause.Cause<E>) => Effect.Effect<X, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Sends all elements emitted by this stream to the specified sink in addition
@@ -2902,7 +2888,7 @@ export declare const throttle: {
         readonly duration: Duration.DurationInput;
         readonly burst?: number | undefined;
         readonly strategy?: "enforce" | "shape" | undefined;
-    }): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    }): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     <A, E, R>(self: Stream<A, E, R>, options: {
         readonly cost: (chunk: Chunk.Chunk<A>) => number;
         readonly units: number;
@@ -2928,14 +2914,14 @@ export declare const throttle: {
  * @category utils
  */
 export declare const throttleEffect: {
-    <A, R2, E2>(options: {
+    <A, E2, R2>(options: {
         readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<number, E2, R2>;
         readonly units: number;
         readonly duration: Duration.DurationInput;
         readonly burst?: number | undefined;
         readonly strategy?: "enforce" | "shape" | undefined;
-    }): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2>(self: Stream<A, E, R>, options: {
+    }): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: Stream<A, E, R>, options: {
         readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<number, E2, R2>;
         readonly units: number;
         readonly duration: Duration.DurationInput;
@@ -2969,7 +2955,7 @@ export declare const timeout: {
  */
 export declare const timeoutFail: {
     <E2>(error: LazyArg<E2>, duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R>;
-    <R, E, A, E2>(self: Stream<A, E, R>, error: LazyArg<E2>, duration: Duration.DurationInput): Stream<A, E | E2, R>;
+    <A, E, R, E2>(self: Stream<A, E, R>, error: LazyArg<E2>, duration: Duration.DurationInput): Stream<A, E | E2, R>;
 };
 /**
  * Fails the stream with given cause if it does not produce a value after d
@@ -2980,7 +2966,7 @@ export declare const timeoutFail: {
  */
 export declare const timeoutFailCause: {
     <E2>(cause: LazyArg<Cause.Cause<E2>>, duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R>;
-    <R, E, A, E2>(self: Stream<A, E, R>, cause: LazyArg<Cause.Cause<E2>>, duration: Duration.DurationInput): Stream<A, E | E2, R>;
+    <A, E, R, E2>(self: Stream<A, E, R>, cause: LazyArg<Cause.Cause<E2>>, duration: Duration.DurationInput): Stream<A, E | E2, R>;
 };
 /**
  * Switches the stream if it does not produce a value after the specified
@@ -2990,8 +2976,8 @@ export declare const timeoutFailCause: {
  * @category utils
  */
 export declare const timeoutTo: {
-    <R2, E2, A2>(duration: Duration.DurationInput, that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, duration: Duration.DurationInput, that: Stream<A2, E2, R2>): Stream<A | A2, E | E2, R | R2>;
+    <A2, E2, R2>(duration: Duration.DurationInput, that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, duration: Duration.DurationInput, that: Stream<A2, E2, R2>): Stream<A | A2, E | E2, R | R2>;
 };
 /**
  * Converts the stream to a scoped `PubSub` of chunks. After the scope is closed,
@@ -3094,7 +3080,7 @@ export declare const unfoldChunk: <S, A>(s: S, f: (s: S) => Option.Option<readon
  * @since 2.0.0
  * @category constructors
  */
-export declare const unfoldChunkEffect: <R, E, A, S>(s: S, f: (s: S) => Effect.Effect<Option.Option<readonly [Chunk.Chunk<A>, S]>, E, R>) => Stream<A, E, R>;
+export declare const unfoldChunkEffect: <S, A, E, R>(s: S, f: (s: S) => Effect.Effect<Option.Option<readonly [Chunk.Chunk<A>, S]>, E, R>) => Stream<A, E, R>;
 /**
  * Creates a stream by effectfully peeling off the "layers" of a value of type
  * `S`.
@@ -3102,7 +3088,7 @@ export declare const unfoldChunkEffect: <R, E, A, S>(s: S, f: (s: S) => Effect.E
  * @since 2.0.0
  * @category constructors
  */
-export declare const unfoldEffect: <S, R, E, A>(s: S, f: (s: S) => Effect.Effect<Option.Option<readonly [A, S]>, E, R>) => Stream<A, E, R>;
+export declare const unfoldEffect: <S, A, E, R>(s: S, f: (s: S) => Effect.Effect<Option.Option<readonly [A, S]>, E, R>) => Stream<A, E, R>;
 /**
  * A stream that contains a single `Unit` value.
  *
@@ -3116,21 +3102,24 @@ export declare const unit: Stream<void>;
  * @since 2.0.0
  * @category constructors
  */
-export declare const unwrap: <R, E, R2, E2, A>(effect: Effect.Effect<Stream<A, E2, R2>, E, R>) => Stream<A, E | E2, R | R2>;
+export declare const unwrap: <A, E2, R2, E, R>(effect: Effect.Effect<Stream<A, E2, R2>, E, R>) => Stream<A, E | E2, R | R2>;
 /**
  * Creates a stream produced from a scoped `Effect`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const unwrapScoped: <R, E, R2, E2, A>(effect: Effect.Effect<Stream<A, E2, R2>, E, R>) => Stream<A, E | E2, R2 | Exclude<R, Scope.Scope>>;
+export declare const unwrapScoped: <A, E2, R2, E, R>(effect: Effect.Effect<Stream<A, E2, R2>, E, R>) => Stream<A, E | E2, R2 | Exclude<R, Scope.Scope>>;
 /**
  * Updates the specified service within the context of the `Stream`.
  *
  * @since 2.0.0
  * @category context
  */
-export declare const updateService: (<T extends Context.Tag<any, any>>(tag: T, f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>) => <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, T | R>) & (<R_1, E_1, A_1, T_1 extends Context.Tag<any, any>>(self: Stream<A_1, E_1, R_1>, tag: T_1, f: (service: Context.Tag.Service<T_1>) => Context.Tag.Service<T_1>) => Stream<A_1, E_1, R_1 | T_1>);
+export declare const updateService: {
+    <T extends Context.Tag<any, any>>(tag: T, f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, T | R>;
+    <A, E, R, T extends Context.Tag<any, any>>(self: Stream<A, E, R>, tag: T, f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>): Stream<A, E, R | T>;
+};
 /**
  * Returns the specified stream if the given condition is satisfied, otherwise
  * returns an empty stream.
@@ -3149,7 +3138,7 @@ export declare const when: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const whenCase: <A, R, E, A2>(evaluate: LazyArg<A>, pf: (a: A) => Option.Option<Stream<A2, E, R>>) => Stream<A2, E, R>;
+export declare const whenCase: <A, A2, E, R>(evaluate: LazyArg<A>, pf: (a: A) => Option.Option<Stream<A2, E, R>>) => Stream<A2, E, R>;
 /**
  * Returns the stream when the given partial function is defined for the given
  * effectful value, otherwise returns an empty stream.
@@ -3158,8 +3147,8 @@ export declare const whenCase: <A, R, E, A2>(evaluate: LazyArg<A>, pf: (a: A) =>
  * @category utils
  */
 export declare const whenCaseEffect: {
-    <A, R2, E2, A2>(pf: (a: A) => Option.Option<Stream<A2, E2, R2>>): <R, E>(self: Effect.Effect<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Effect.Effect<A, E, R>, pf: (a: A) => Option.Option<Stream<A2, E2, R2>>): Stream<A2, E | E2, R | R2>;
+    <A, A2, E2, R2>(pf: (a: A) => Option.Option<Stream<A2, E2, R2>>): <E, R>(self: Effect.Effect<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Effect.Effect<A, E, R>, pf: (a: A) => Option.Option<Stream<A2, E2, R2>>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Returns the stream if the given effectful condition is satisfied, otherwise
@@ -3169,8 +3158,8 @@ export declare const whenCaseEffect: {
  * @category utils
  */
 export declare const whenEffect: {
-    <R2, E2>(effect: Effect.Effect<boolean, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2>(self: Stream<A, E, R>, effect: Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
+    <E2, R2>(effect: Effect.Effect<boolean, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, E2, R2>(self: Stream<A, E, R>, effect: Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Wraps the stream with a new span for tracing.
@@ -3204,8 +3193,8 @@ export declare const withSpan: {
  * @category zipping
  */
 export declare const zip: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>;
 };
 /**
  * Zips this stream with another point-wise and emits tuples of elements from
@@ -3217,8 +3206,8 @@ export declare const zip: {
  * @category zipping
  */
 export declare const zipFlatten: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <R, E, A extends ReadonlyArray<any>>(self: Stream<A, E, R>) => Stream<[...A, A2], E2 | E, R2 | R>;
-    <R, E, A extends ReadonlyArray<any>, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[...A, A2], E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A extends ReadonlyArray<any>, E, R>(self: Stream<A, E, R>) => Stream<[...A, A2], E2 | E, R2 | R>;
+    <A extends ReadonlyArray<any>, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[...A, A2], E | E2, R | R2>;
 };
 /**
  * Zips this stream with another point-wise, creating a new stream of pairs of
@@ -3231,12 +3220,12 @@ export declare const zipFlatten: {
  * @category zipping
  */
 export declare const zipAll: {
-    <R2, E2, A2, A>(options: {
+    <A2, E2, R2, A>(options: {
         readonly other: Stream<A2, E2, R2>;
         readonly defaultSelf: A;
         readonly defaultOther: A2;
-    }): <R, E>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>;
-    <R, E, R2, E2, A2, A>(self: Stream<A, E, R>, options: {
+    }): <E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, options: {
         readonly other: Stream<A2, E2, R2>;
         readonly defaultSelf: A;
         readonly defaultOther: A2;
@@ -3253,8 +3242,8 @@ export declare const zipAll: {
  * @category zipping
  */
 export declare const zipAllLeft: {
-    <R2, E2, A2, A>(that: Stream<A2, E2, R2>, defaultLeft: A): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, R2, E2, A2, A>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, defaultLeft: A): Stream<A, E | E2, R | R2>;
+    <A2, E2, R2, A>(that: Stream<A2, E2, R2>, defaultLeft: A): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, defaultLeft: A): Stream<A, E | E2, R | R2>;
 };
 /**
  * Zips this stream with another point-wise, and keeps only elements from the
@@ -3267,8 +3256,8 @@ export declare const zipAllLeft: {
  * @category zipping
  */
 export declare const zipAllRight: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>, defaultRight: A2): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, defaultRight: A2): Stream<A2, E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>, defaultRight: A2): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, defaultRight: A2): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Zips this stream that is sorted by distinct keys and the specified stream
@@ -3285,13 +3274,13 @@ export declare const zipAllRight: {
  * @category zipping
  */
 export declare const zipAllSortedByKey: {
-    <R2, E2, A2, A, K>(options: {
+    <A2, E2, R2, A, K>(options: {
         readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly defaultSelf: A;
         readonly defaultOther: A2;
         readonly order: Order.Order<K>;
-    }): <R, E>(self: Stream<readonly [K, A], E, R>) => Stream<[K, [A, A2]], E2 | E, R2 | R>;
-    <R, E, R2, E2, A2, A, K>(self: Stream<readonly [K, A], E, R>, options: {
+    }): <E, R>(self: Stream<readonly [K, A], E, R>) => Stream<[K, [A, A2]], E2 | E, R2 | R>;
+    <K, A, E, R, A2, E2, R2>(self: Stream<readonly [K, A], E, R>, options: {
         readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly defaultSelf: A;
         readonly defaultOther: A2;
@@ -3312,12 +3301,12 @@ export declare const zipAllSortedByKey: {
  * @category zipping
  */
 export declare const zipAllSortedByKeyLeft: {
-    <R2, E2, A2, A, K>(options: {
+    <A2, E2, R2, A, K>(options: {
         readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly defaultSelf: A;
         readonly order: Order.Order<K>;
-    }): <R, E>(self: Stream<readonly [K, A], E, R>) => Stream<[K, A], E2 | E, R2 | R>;
-    <R, E, R2, E2, A2, A, K>(self: Stream<readonly [K, A], E, R>, options: {
+    }): <E, R>(self: Stream<readonly [K, A], E, R>) => Stream<[K, A], E2 | E, R2 | R>;
+    <K, A, E, R, A2, E2, R2>(self: Stream<readonly [K, A], E, R>, options: {
         readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly defaultSelf: A;
         readonly order: Order.Order<K>;
@@ -3337,12 +3326,12 @@ export declare const zipAllSortedByKeyLeft: {
  * @category zipping
  */
 export declare const zipAllSortedByKeyRight: {
-    <R2, E2, A2, K>(options: {
+    <K, A2, E2, R2>(options: {
         readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly defaultOther: A2;
         readonly order: Order.Order<K>;
     }): <A, E, R>(self: Stream<readonly [K, A], E, R>) => Stream<[K, A2], E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2, K>(self: Stream<readonly [K, A], E, R>, options: {
+    <A, E, R, K, A2, E2, R2>(self: Stream<readonly [K, A], E, R>, options: {
         readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly defaultOther: A2;
         readonly order: Order.Order<K>;
@@ -3363,14 +3352,14 @@ export declare const zipAllSortedByKeyRight: {
  * @category zipping
  */
 export declare const zipAllSortedByKeyWith: {
-    <R2, E2, A, A3, A2, K>(options: {
+    <K, A2, E2, R2, A, A3>(options: {
         readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly onSelf: (a: A) => A3;
         readonly onOther: (a2: A2) => A3;
         readonly onBoth: (a: A, a2: A2) => A3;
         readonly order: Order.Order<K>;
-    }): <R, E>(self: Stream<readonly [K, A], E, R>) => Stream<[K, A3], E2 | E, R2 | R>;
-    <R, E, R2, E2, A, A3, A2, K>(self: Stream<readonly [K, A], E, R>, options: {
+    }): <E, R>(self: Stream<readonly [K, A], E, R>) => Stream<[K, A3], E2 | E, R2 | R>;
+    <K, A, E, R, A2, E2, R2, A3>(self: Stream<readonly [K, A], E, R>, options: {
         readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly onSelf: (a: A) => A3;
         readonly onOther: (a2: A2) => A3;
@@ -3389,13 +3378,13 @@ export declare const zipAllSortedByKeyWith: {
  * @category zipping
  */
 export declare const zipAllWith: {
-    <R2, E2, A2, A, A3>(options: {
+    <A2, E2, R2, A, A3>(options: {
         readonly other: Stream<A2, E2, R2>;
         readonly onSelf: (a: A) => A3;
         readonly onOther: (a2: A2) => A3;
         readonly onBoth: (a: A, a2: A2) => A3;
-    }): <R, E>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>;
-    <R, E, R2, E2, A2, A, A3>(self: Stream<A, E, R>, options: {
+    }): <E, R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2, A3>(self: Stream<A, E, R>, options: {
         readonly other: Stream<A2, E2, R2>;
         readonly onSelf: (a: A) => A3;
         readonly onOther: (a2: A2) => A3;
@@ -3415,8 +3404,8 @@ export declare const zipAllWith: {
  * @category zipping
  */
 export declare const zipLatest: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>;
 };
 /**
  * Zips the two streams so that when a value is emitted by either of the two
@@ -3431,8 +3420,8 @@ export declare const zipLatest: {
  * @category zipping
  */
 export declare const zipLatestWith: {
-    <R2, E2, A2, A, A3>(that: Stream<A2, E2, R2>, f: (a: A, a2: A2) => A3): <R, E>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>;
-    <R, E, R2, E2, A2, A, A3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, f: (a: A, a2: A2) => A3): Stream<A3, E | E2, R | R2>;
+    <A2, E2, R2, A, A3>(that: Stream<A2, E2, R2>, f: (a: A, a2: A2) => A3): <E, R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2, A3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, f: (a: A, a2: A2) => A3): Stream<A3, E | E2, R | R2>;
 };
 /**
  * Zips this stream with another point-wise, but keeps only the outputs of
@@ -3444,8 +3433,8 @@ export declare const zipLatestWith: {
  * @category zipping
  */
 export declare const zipLeft: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Zips this stream with another point-wise, but keeps only the outputs of the
@@ -3457,8 +3446,8 @@ export declare const zipLeft: {
  * @category zipping
  */
 export declare const zipRight: {
-    <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>;
+    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Zips this stream with another point-wise and applies the function to the
@@ -3470,8 +3459,8 @@ export declare const zipRight: {
  * @category zipping
  */
 export declare const zipWith: {
-    <R2, E2, A2, A, A3>(that: Stream<A2, E2, R2>, f: (a: A, a2: A2) => A3): <R, E>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>;
-    <R, E, R2, E2, A2, A, A3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, f: (a: A, a2: A2) => A3): Stream<A3, E | E2, R | R2>;
+    <A2, E2, R2, A, A3>(that: Stream<A2, E2, R2>, f: (a: A, a2: A2) => A3): <E, R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2, A3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, f: (a: A, a2: A2) => A3): Stream<A3, E | E2, R | R2>;
 };
 /**
  * Zips this stream with another point-wise and applies the function to the
@@ -3483,8 +3472,8 @@ export declare const zipWith: {
  * @category zipping
  */
 export declare const zipWithChunks: {
-    <R2, E2, A2, A, A3>(that: Stream<A2, E2, R2>, f: (left: Chunk.Chunk<A>, right: Chunk.Chunk<A2>) => readonly [Chunk.Chunk<A3>, Either.Either<Chunk.Chunk<A>, Chunk.Chunk<A2>>]): <R, E>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>;
-    <R, E, R2, E2, A2, A, A3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, f: (left: Chunk.Chunk<A>, right: Chunk.Chunk<A2>) => readonly [Chunk.Chunk<A3>, Either.Either<Chunk.Chunk<A>, Chunk.Chunk<A2>>]): Stream<A3, E | E2, R | R2>;
+    <A2, E2, R2, A, A3>(that: Stream<A2, E2, R2>, f: (left: Chunk.Chunk<A>, right: Chunk.Chunk<A2>) => readonly [Chunk.Chunk<A3>, Either.Either<Chunk.Chunk<A2>, Chunk.Chunk<A>>]): <E, R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2, A3>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, f: (left: Chunk.Chunk<A>, right: Chunk.Chunk<A2>) => readonly [Chunk.Chunk<A3>, Either.Either<Chunk.Chunk<A2>, Chunk.Chunk<A>>]): Stream<A3, E | E2, R | R2>;
 };
 /**
  * Zips each element with the next element if present.
@@ -3527,16 +3516,16 @@ export declare const Do: Stream<{}>;
  * @category do notation
  */
 export declare const bind: {
-    <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => Stream<A, E2, R2>, options?: {
+    <N extends string, K, A, E2, R2>(tag: Exclude<N, keyof K>, f: (_: K) => Stream<A, E2, R2>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
-    } | undefined): <R, E>(self: Stream<K, E, R>) => Stream<Effect.MergeRecord<K, {
+    } | undefined): <E, R>(self: Stream<K, E, R>) => Stream<MergeRecord<K, {
         [k in N]: A;
     }>, E2 | E, R2 | R>;
-    <R, E, N extends string, K, R2, E2, A>(self: Stream<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => Stream<A, E2, R2>, options?: {
+    <K, E, R, N extends string, A, E2, R2>(self: Stream<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => Stream<A, E2, R2>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
-    } | undefined): Stream<Effect.MergeRecord<K, {
+    } | undefined): Stream<MergeRecord<K, {
         [k in N]: A;
     }>, E | E2, R | R2>;
 };
@@ -3547,16 +3536,16 @@ export declare const bind: {
  * @category do notation
  */
 export declare const bindEffect: {
-    <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => Effect.Effect<A, E2, R2>, options?: {
+    <N extends string, K, A, E2, R2>(tag: Exclude<N, keyof K>, f: (_: K) => Effect.Effect<A, E2, R2>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
-    } | undefined): <R, E>(self: Stream<K, E, R>) => Stream<Effect.MergeRecord<K, {
+    } | undefined): <E, R>(self: Stream<K, E, R>) => Stream<MergeRecord<K, {
         [k in N]: A;
     }>, E2 | E, R2 | R>;
-    <R, E, N extends string, K, R2, E2, A>(self: Stream<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => Effect.Effect<A, E2, R2>, options?: {
+    <K, E, R, N extends string, A, E2, R2>(self: Stream<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => Effect.Effect<A, E2, R2>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly unordered?: boolean | undefined;
-    } | undefined): Stream<Effect.MergeRecord<K, {
+    } | undefined): Stream<MergeRecord<K, {
         [k in N]: A;
     }>, E | E2, R | R2>;
 };
@@ -3566,13 +3555,13 @@ export declare const bindEffect: {
  */
 export declare const bindTo: {
     <N extends string>(tag: N): <A, E, R>(self: Stream<A, E, R>) => Stream<Record<N, A>, E, R>;
-    <R, E, A, N extends string>(self: Stream<A, E, R>, tag: N): Stream<Record<N, A>, E, R>;
+    <A, E, R, N extends string>(self: Stream<A, E, R>, tag: N): Stream<Record<N, A>, E, R>;
 };
 declare const let_: {
-    <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <R, E>(self: Stream<K, E, R>) => Stream<Effect.MergeRecord<K, {
+    <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <E, R>(self: Stream<K, E, R>) => Stream<MergeRecord<K, {
         [k in N]: A;
     }>, E, R>;
-    <R, E, K, N extends string, A>(self: Stream<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => A): Stream<Effect.MergeRecord<K, {
+    <K, E, R, N extends string, A>(self: Stream<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => A): Stream<MergeRecord<K, {
         [k in N]: A;
     }>, E, R>;
 };
@@ -3591,8 +3580,8 @@ let_ as let };
  * @category encoding
  */
 export declare const decodeText: {
-    (encoding?: string | undefined): <R, E>(self: Stream<Uint8Array, E, R>) => Stream<string, E, R>;
-    <R, E>(self: Stream<Uint8Array, E, R>, encoding?: string | undefined): Stream<string, E, R>;
+    (encoding?: string | undefined): <E, R>(self: Stream<Uint8Array, E, R>) => Stream<string, E, R>;
+    <E, R>(self: Stream<Uint8Array, E, R>, encoding?: string | undefined): Stream<string, E, R>;
 };
 /**
  * Encode a stream of strings into a stream of Uint8Array chunks using the specified encoding.
@@ -3600,5 +3589,5 @@ export declare const decodeText: {
  * @since 2.0.0
  * @category encoding
  */
-export declare const encodeText: <R, E>(self: Stream<string, E, R>) => Stream<Uint8Array, E, R>;
+export declare const encodeText: <E, R>(self: Stream<string, E, R>) => Stream<Uint8Array, E, R>;
 //# sourceMappingURL=Stream.d.ts.map