effect 2.2.5 → 2.3.0

package/dist/dts/Stream.d.ts

@@ -40,7 +40,7 @@ export declare const StreamTypeId: unique symbol;
  */
 export type StreamTypeId = typeof StreamTypeId;
 /**
- * A `Stream<R, E, A>` is a description of a program that, when evaluated, may
+ * A `Stream<A, E, R>` is a description of a program that, when evaluated, may
  * emit zero or more values of type `A`, may fail with errors of type `E`, and
  * uses an context of type `R`. One way to think of `Stream` is as a
  * `Effect` program that could emit multiple values.
@@ -59,7 +59,7 @@ export type StreamTypeId = typeof StreamTypeId;
  * @since 2.0.0
  * @category models
  */
-export interface Stream<out R, out E, out A> extends Stream.Variance<R, E, A>, Pipeable {
+export interface Stream<out A, out E = never, out R = never> extends Stream.Variance<A, E, R>, Pipeable {
     [Unify.typeSymbol]?: unknown;
     [Unify.unifySymbol]?: StreamUnify<this>;
     [Unify.ignoreSymbol]?: StreamUnifyIgnore;
@@ -71,7 +71,7 @@ export interface Stream<out R, out E, out A> extends Stream.Variance<R, E, A>, P
 export interface StreamUnify<A extends {
     [Unify.typeSymbol]?: any;
 }> extends Effect.EffectUnify<A> {
-    Stream?: () => A[Unify.typeSymbol] extends Stream<infer R0, infer E0, infer A0> | infer _ ? Stream<R0, E0, A0> : never;
+    Stream?: () => A[Unify.typeSymbol] extends Stream<infer A0, infer E0, infer R0> | infer _ ? Stream<A0, E0, R0> : never;
 }
 /**
  * @category models
@@ -85,7 +85,7 @@ export interface StreamUnifyIgnore extends Effect.EffectUnifyIgnore {
  * @category models
  */
 declare module "./Effect.js" {
-    interface Effect<R, E, A> extends Stream<R, E, A> {
+    interface Effect<A, E, R> extends Stream<A, E, R> {
     }
     interface EffectUnifyIgnore {
         Stream?: true;
@@ -96,7 +96,7 @@ declare module "./Effect.js" {
  * @since 2.0.0
  */
 export interface StreamTypeLambda extends TypeLambda {
-    readonly type: Stream<this["Out2"], this["Out1"], this["Target"]>;
+    readonly type: Stream<this["Target"], this["Out1"], this["Out2"]>;
 }
 /**
  * @since 2.0.0
@@ -106,11 +106,11 @@ export declare namespace Stream {
      * @since 2.0.0
      * @category models
      */
-    interface Variance<out R, out E, out A> {
+    interface Variance<out A, out E, out R> {
         readonly [StreamTypeId]: {
-            _R: Covariant<R>;
-            _E: Covariant<E>;
             _A: Covariant<A>;
+            _E: Covariant<E>;
+            _R: Covariant<R>;
         };
     }
     /**
@@ -139,14 +139,14 @@ export declare const DefaultChunkSize: number;
  * @since 2.0.0
  * @category utils
  */
-export declare const accumulate: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
+export declare const accumulate: <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>;
 /**
  * Re-chunks the elements of the stream by accumulating each underlying chunk.
  *
  * @since 2.0.0
  * @category utils
  */
-export declare const accumulateChunks: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+export declare const accumulateChunks: <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
 /**
  * Creates a stream from a single value that will get cleaned up after the
  * stream is consumed.
@@ -154,7 +154,7 @@ export declare const accumulateChunks: <R, E, A>(self: Stream<R, E, A>) => Strea
  * @since 2.0.0
  * @category constructors
  */
-export declare const acquireRelease: <R, E, A, R2, _>(acquire: Effect.Effect<R, E, A>, release: (resource: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R2, never, _>) => Stream<R | R2, E, A>;
+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>;
 /**
  * Aggregates elements of this stream using the provided sink for as long as
  * the downstream operators on the stream are busy.
@@ -172,8 +172,8 @@ export declare const acquireRelease: <R, E, A, R2, _>(acquire: Effect.Effect<R,
  * @category utils
  */
 export declare const aggregate: {
-    <R2, E2, A, A2, B>(sink: Sink.Sink<R2, E2, A | A2, A2, B>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, B>;
-    <R, E, R2, E2, A, A2, B>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A | A2, A2, B>): Stream<R | R2, E | E2, B>;
+    <B, A, A2, E2, R2>(sink: Sink.Sink<B, A | A2, A2, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<B, E2 | E, R2 | R>;
+    <A, E, R, B, A2, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<B, A | A2, A2, E2, R2>): Stream<B, E | E2, R | R2>;
 };
 /**
  * Like `aggregateWithinEither`, but only returns the `Right` results.
@@ -184,8 +184,8 @@ export declare const aggregate: {
  * @category utils
  */
 export declare const aggregateWithin: {
-    <R2, E2, A, A2, B, R3, C>(sink: Sink.Sink<R2, E2, A | A2, A2, B>, schedule: Schedule.Schedule<R3, Option.Option<B>, C>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R3 | R, E2 | E, B>;
-    <R, E, R2, E2, A, A2, B, R3, C>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A | A2, A2, B>, schedule: Schedule.Schedule<R3, Option.Option<B>, C>): Stream<R | R2 | R3, E | E2, B>;
+    <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>;
 };
 /**
  * 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: {
-    <R2, E2, A, A2, B, R3, C>(sink: Sink.Sink<R2, E2, A | A2, A2, B>, schedule: Schedule.Schedule<R3, Option.Option<B>, C>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R3 | R, E2 | E, Either.Either<C, B>>;
-    <R, E, R2, E2, A, A2, B, R3, C>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A | A2, A2, B>, schedule: Schedule.Schedule<R3, Option.Option<B>, C>): Stream<R | R2 | R3, E | E2, Either.Either<C, B>>;
+    <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>;
 };
 /**
  * Maps the success values of this stream to the specified constant value.
@@ -215,10 +215,10 @@ export declare const aggregateWithinEither: {
  * @category mapping
  */
 export declare const as: {
-    <B>(value: B): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, B>;
-    <R, E, A, B>(self: Stream<R, E, A>, value: B): Stream<R, E, B>;
+    <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>;
 };
-declare const _async: <R, E, A>(register: (emit: Emit.Emit<R, E, A, void>) => void, outputBuffer?: number) => Stream<R, E, A>;
+declare const _async: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => void, outputBuffer?: number) => Stream<A, E, R>;
 export { 
 /**
  * Creates a stream from an asynchronous callback that can be called multiple
@@ -238,7 +238,7 @@ _async as async };
  * @since 2.0.0
  * @category constructors
  */
-export declare const asyncEffect: <R, E, A>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<R, E, unknown>, outputBuffer?: number) => Stream<R, E, A>;
+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
@@ -248,7 +248,7 @@ export declare const asyncEffect: <R, E, A>(register: (emit: Emit.Emit<R, E, A,
  * @since 2.0.0
  * @category constructors
  */
-export declare const asyncInterrupt: <R, E, A>(register: (emit: Emit.Emit<R, E, A, void>) => Either.Either<Effect.Effect<R, never, unknown>, Stream<R, E, A>>, outputBuffer?: number) => Stream<R, E, A>;
+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
@@ -258,7 +258,7 @@ export declare const asyncInterrupt: <R, E, A>(register: (emit: Emit.Emit<R, E,
  * @since 2.0.0
  * @category constructors
  */
-export declare const asyncOption: <R, E, A>(register: (emit: Emit.Emit<R, E, A, void>) => Option.Option<Stream<R, E, A>>, outputBuffer?: number) => Stream<R, E, A>;
+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
@@ -268,7 +268,7 @@ export declare const asyncOption: <R, E, A>(register: (emit: Emit.Emit<R, E, A,
  * @since 2.0.0
  * @category constructors
  */
-export declare const asyncScoped: <R, E, A>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<R | Scope.Scope, E, unknown>, outputBuffer?: number) => Stream<Exclude<R, Scope.Scope>, E, A>;
+export declare const asyncScoped: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R | Scope.Scope>, outputBuffer?: number) => Stream<A, E, Exclude<R, Scope.Scope>>;
 /**
  * Returns a `Stream` that first collects `n` elements from the input `Stream`,
  * and then creates a new `Stream` using the specified function, and sends all
@@ -278,8 +278,8 @@ export declare const asyncScoped: <R, E, A>(register: (emit: Emit.Emit<R, E, A,
  * @category sequencing
  */
 export declare const branchAfter: {
-    <A, R2, E2, A2>(n: number, f: (input: Chunk.Chunk<A>) => Stream<R2, E2, A2>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, n: number, f: (input: Chunk.Chunk<A>) => Stream<R2, E2, A2>): Stream<R | R2, E | E2, A2>;
+    <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>;
 };
 /**
  * Fan out the stream, producing a list of streams that have the same elements
@@ -290,8 +290,8 @@ export declare const branchAfter: {
  * @category utils
  */
 export declare const broadcast: {
-    <N extends number>(n: N, maximumLag: number): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Stream<never, E, A>, N>>;
-    <R, E, A, N extends number>(self: Stream<R, E, A>, n: N, maximumLag: number): Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Stream<never, E, A>, N>>;
+    <N extends number>(n: N, maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream.DynamicTuple<Stream<A, E>, N>, never, Scope.Scope | R>;
+    <A, E, R, N extends number>(self: Stream<A, E, R>, n: N, maximumLag: number): Effect.Effect<Stream.DynamicTuple<Stream<A, E>, N>, never, Scope.Scope | R>;
 };
 /**
  * Fan out the stream, producing a dynamic number of streams that have the
@@ -302,8 +302,8 @@ export declare const broadcast: {
  * @category utils
  */
 export declare const broadcastDynamic: {
-    (maximumLag: number): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Stream<never, E, A>>;
-    <R, E, A>(self: Stream<R, E, A>, maximumLag: number): Effect.Effect<Scope.Scope | R, never, Stream<never, E, A>>;
+    (maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream<A, E>, never, Scope.Scope | R>;
+    <A, E, R>(self: Stream<A, E, R>, maximumLag: number): Effect.Effect<Stream<A, E>, never, Scope.Scope | R>;
 };
 /**
  * Converts the stream to a scoped list of queues. Every value will be
@@ -316,8 +316,8 @@ export declare const broadcastDynamic: {
  * @category utils
  */
 export declare const broadcastedQueues: {
-    <N extends number>(n: N, maximumLag: number): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Queue.Dequeue<Take.Take<E, A>>, N>>;
-    <R, E, A, N extends number>(self: Stream<R, E, A>, n: N, maximumLag: number): Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Queue.Dequeue<Take.Take<E, A>>, N>>;
+    <N extends number>(n: N, maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, R | Scope.Scope>;
+    <A, E, R, N extends number>(self: Stream<A, E, R>, n: N, maximumLag: number): Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R>;
 };
 /**
  * Converts the stream to a scoped dynamic amount of queues. Every chunk will
@@ -330,8 +330,8 @@ export declare const broadcastedQueues: {
  * @category utils
  */
 export declare const broadcastedQueuesDynamic: {
-    (maximumLag: number): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Effect.Effect<Scope.Scope, never, Queue.Dequeue<Take.Take<E, A>>>>;
-    <R, E, A>(self: Stream<R, E, A>, maximumLag: number): Effect.Effect<Scope.Scope | R, never, Effect.Effect<Scope.Scope, never, Queue.Dequeue<Take.Take<E, A>>>>;
+    (maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, R | Scope.Scope>;
+    <A, E, R>(self: Stream<A, E, R>, maximumLag: number): Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R>;
 };
 /**
  * Allows a faster producer to progress independently of a slower consumer by
@@ -349,13 +349,13 @@ export declare const buffer: {
     } | {
         readonly capacity: number;
         readonly strategy?: "dropping" | "sliding" | "suspend" | undefined;
-    }): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, options: {
+    }): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, options: {
         readonly capacity: "unbounded";
     } | {
         readonly capacity: number;
         readonly strategy?: "dropping" | "sliding" | "suspend" | undefined;
-    }): Stream<R, E, A>;
+    }): Stream<A, E, R>;
 };
 /**
  * Allows a faster producer to progress independently of a slower consumer by
@@ -369,11 +369,11 @@ export declare const bufferChunks: {
     (options: {
         readonly capacity: number;
         readonly strategy?: "dropping" | "sliding" | "suspend" | undefined;
-    }): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, options: {
+    }): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, options: {
         readonly capacity: number;
         readonly strategy?: "dropping" | "sliding" | "suspend" | undefined;
-    }): Stream<R, E, A>;
+    }): Stream<A, E, R>;
 };
 /**
  * Switches over to the stream produced by the provided function in case this
@@ -383,8 +383,8 @@ export declare const bufferChunks: {
  * @category error handling
  */
 export declare const catchAll: {
-    <E, R2, E2, A2>(f: (error: E) => Stream<R2, E2, A2>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2, A2 | A>;
-    <R, A, E, R2, E2, A2>(self: Stream<R, E, A>, f: (error: E) => Stream<R2, E2, A2>): Stream<R | R2, E2, A | A2>;
+    <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>;
 };
 /**
  * Switches over to the stream produced by the provided function in case this
@@ -395,8 +395,8 @@ export declare const catchAll: {
  * @category error handling
  */
 export declare const catchAllCause: {
-    <E, R2, E2, A2>(f: (cause: Cause.Cause<E>) => Stream<R2, E2, A2>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2, A2 | A>;
-    <R, A, E, R2, E2, A2>(self: Stream<R, E, A>, f: (cause: Cause.Cause<E>) => Stream<R2, E2, A2>): Stream<R | R2, E2, A | A2>;
+    <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>;
 };
 /**
  * Switches over to the stream produced by the provided function in case this
@@ -406,8 +406,8 @@ export declare const catchAllCause: {
  * @category error handling
  */
 export declare const catchSome: {
-    <E, R2, E2, A2>(pf: (error: E) => Option.Option<Stream<R2, E2, A2>>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A2 | A>;
-    <R, A, E, R2, E2, A2>(self: Stream<R, E, A>, pf: (error: E) => Option.Option<Stream<R2, E2, A2>>): Stream<R | R2, E | E2, A | A2>;
+    <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>;
 };
 /**
  * Switches over to the stream produced by the provided function in case this
@@ -421,16 +421,16 @@ export declare const catchTag: {
         _tag: string;
     }, R1, E1, A1>(k: K, f: (e: Extract<E, {
         _tag: K;
-    }>) => Stream<R1, E1, A1>): <R, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | Exclude<E, {
+    }>) => Stream<A1, E1, R1>): <R, A>(self: Stream<A, E, R>) => Stream<A1 | A, E1 | Exclude<E, {
         _tag: K;
-    }>, A1 | A>;
+    }>, R1 | R>;
     <R, E extends {
         _tag: string;
-    }, A, K extends E["_tag"] & string, R1, E1, A1>(self: Stream<R, E, A>, k: K, f: (e: Extract<E, {
+    }, A, K extends E["_tag"] & string, R1, E1, A1>(self: Stream<A, E, R>, k: K, f: (e: Extract<E, {
         _tag: K;
-    }>) => Stream<R1, E1, A1>): Stream<R | R1, E1 | Exclude<E, {
+    }>) => Stream<A1, E1, R1>): Stream<A | A1, E1 | Exclude<E, {
         _tag: K;
-    }>, A | A1>;
+    }>, R | R1>;
 };
 /**
  * Switches over to the stream produced by one of the provided functions, in
@@ -443,32 +443,32 @@ export declare const catchTags: {
     <E extends {
         _tag: string;
     }, Cases extends {
-        [K in E["_tag"]]+?: ((error: Extract<E, {
+        [K in E["_tag"]]+?: (error: Extract<E, {
             _tag: K;
-        }>) => Stream<any, any, any>) | undefined;
-    }>(cases: Cases): <R, A>(self: Stream<R, E, A>) => Stream<R | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer R, infer _E, infer _A> ? R : never;
+        }>) => Stream<any, any, any>;
+    }>(cases: Cases): <R, A>(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;
     }> | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer E, infer _A> ? E : never;
-    }[keyof Cases], A | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer _E, infer A> ? A : never;
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _A, infer E, infer _R> ? E : never;
+    }[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 {
         _tag: string;
     }, A, Cases extends {
-        [K in E["_tag"]]+?: ((error: Extract<E, {
+        [K in E["_tag"]]+?: (error: Extract<E, {
             _tag: K;
-        }>) => Stream<any, any, any>) | undefined;
-    }>(self: Stream<R, E, A>, cases: Cases): Stream<R | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer R, infer _E, infer _A> ? R : never;
+        }>) => Stream<any, any, any>;
+    }>(self: Stream<A, E, R>, cases: Cases): Stream<A | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer _E, infer A> ? A : never;
     }[keyof Cases], Exclude<E, {
         _tag: keyof Cases;
     }> | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer E, infer _A> ? E : never;
-    }[keyof Cases], A | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer _E, infer A> ? A : never;
+    }[keyof Cases], R | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer R, infer _E, infer _A> ? R : never;
     }[keyof Cases]>;
 };
 /**
@@ -480,8 +480,8 @@ export declare const catchTags: {
  * @category error handling
  */
 export declare const catchSomeCause: {
-    <E, R2, E2, A2>(pf: (cause: Cause.Cause<E>) => Option.Option<Stream<R2, E2, A2>>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A2 | A>;
-    <R, A, E, R2, E2, A2>(self: Stream<R, E, A>, pf: (cause: Cause.Cause<E>) => Option.Option<Stream<R2, E2, A2>>): Stream<R | R2, E | E2, A | A2>;
+    <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>;
 };
 /**
  * Returns a new stream that only emits elements that are not equal to the
@@ -491,7 +491,7 @@ export declare const catchSomeCause: {
  * @since 2.0.0
  * @category utils
  */
-export declare const changes: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+export declare const changes: <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
 /**
  * Returns a new stream that only emits elements that are not equal to the
  * previous element emitted, using the specified function to determine whether
@@ -501,8 +501,8 @@ export declare const changes: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A
  * @category utils
  */
 export declare const changesWith: {
-    <A>(f: (x: A, y: A) => boolean): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, f: (x: A, y: A) => boolean): Stream<R, E, A>;
+    <A>(f: (x: A, y: A) => boolean): <R, E>(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>;
 };
 /**
  * Returns a new stream that only emits elements that are not equal to the
@@ -513,8 +513,8 @@ export declare const changesWith: {
  * @category utils
  */
 export declare const changesWithEffect: {
-    <A, R2, E2>(f: (x: A, y: A) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2>(self: Stream<R, E, A>, f: (x: A, y: A) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Exposes the underlying chunks of the stream as a stream of chunks of
@@ -523,7 +523,7 @@ export declare const changesWithEffect: {
  * @since 2.0.0
  * @category utils
  */
-export declare const chunks: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
+export declare const chunks: <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>;
 /**
  * Performs the specified stream transformation with the chunk structure of
  * the stream exposed.
@@ -531,7 +531,10 @@ export declare const chunks: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Ch
  * @since 2.0.0
  * @category utils
  */
-export declare const chunksWith: <R, E, A, R2, E2, A2>(f: (stream: Stream<R, E, Chunk.Chunk<A>>) => Stream<R2, E2, Chunk.Chunk<A2>>) => (self: Stream<R, E, A>) => Stream<R | R2, E | E2, A2>;
+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>;
+};
 /**
  * Combines the elements from this stream and the specified stream by
  * repeatedly applying the function `f` to extract an element using both sides
@@ -546,8 +549,8 @@ export declare const chunksWith: <R, E, A, R2, E2, A2>(f: (stream: Stream<R, E,
  * @category utils
  */
 export declare const combine: {
-    <R2, E2, A2, S, R3, E, A, R4, R5, A3>(that: Stream<R2, E2, A2>, s: S, f: (s: S, pullLeft: Effect.Effect<R3, Option.Option<E>, A>, pullRight: Effect.Effect<R4, Option.Option<E2>, A2>) => Effect.Effect<R5, never, Exit.Exit<Option.Option<E2 | E>, readonly [A3, S]>>): <R>(self: Stream<R, E, A>) => Stream<R2 | R3 | R4 | R5 | R, E2 | E, A3>;
-    <R, R2, E2, A2, S, R3, E, A, R4, R5, A3>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, s: S, f: (s: S, pullLeft: Effect.Effect<R3, Option.Option<E>, A>, pullRight: Effect.Effect<R4, Option.Option<E2>, A2>) => Effect.Effect<R5, never, Exit.Exit<Option.Option<E2 | E>, readonly [A3, S]>>): Stream<R | R2 | R3 | R4 | R5, E2 | E, A3>;
+    <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>;
 };
 /**
  * Combines the chunks from this stream and the specified stream by repeatedly
@@ -560,8 +563,8 @@ export declare const combine: {
  * @category utils
  */
 export declare const combineChunks: {
-    <R2, E2, A2, S, R3, E, A, R4, R5, A3>(that: Stream<R2, E2, A2>, s: S, f: (s: S, pullLeft: Effect.Effect<R3, Option.Option<E>, Chunk.Chunk<A>>, pullRight: Effect.Effect<R4, Option.Option<E2>, Chunk.Chunk<A2>>) => Effect.Effect<R5, never, Exit.Exit<Option.Option<E2 | E>, readonly [Chunk.Chunk<A3>, S]>>): <R>(self: Stream<R, E, A>) => Stream<R2 | R3 | R4 | R5 | R, E2 | E, A3>;
-    <R, R2, E2, A2, S, R3, E, A, R4, R5, A3>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, s: S, f: (s: S, pullLeft: Effect.Effect<R3, Option.Option<E>, Chunk.Chunk<A>>, pullRight: Effect.Effect<R4, Option.Option<E2>, Chunk.Chunk<A2>>) => Effect.Effect<R5, never, Exit.Exit<Option.Option<E2 | E>, readonly [Chunk.Chunk<A3>, S]>>): Stream<R | R2 | R3 | R4 | R5, E2 | E, A3>;
+    <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>;
 };
 /**
  * Concatenates the specified stream with this stream, resulting in a stream
@@ -572,8 +575,8 @@ export declare const combineChunks: {
  * @category utils
  */
 export declare const concat: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A | A2>;
+    <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>;
 };
 /**
  * Concatenates all of the streams in the chunk to one stream.
@@ -581,7 +584,7 @@ export declare const concat: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const concatAll: <R, E, A>(streams: Chunk.Chunk<Stream<R, E, A>>) => Stream<R, E, A>;
+export declare const concatAll: <A, E, R>(streams: Chunk.Chunk<Stream<A, E, R>>) => Stream<A, E, R>;
 /**
  * Composes this stream with the specified stream to create a cartesian
  * product of elements. The `that` stream would be run multiple times, for
@@ -593,8 +596,8 @@ export declare const concatAll: <R, E, A>(streams: Chunk.Chunk<Stream<R, E, A>>)
  * @category utils
  */
 export declare const cross: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, [A, A2]>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, [A, A2]>;
+    <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>;
 };
 /**
  * Composes this stream with the specified stream to create a cartesian
@@ -607,8 +610,8 @@ export declare const cross: {
  * @category utils
  */
 export declare const crossLeft: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Composes this stream with the specified stream to create a cartesian
@@ -622,8 +625,8 @@ export declare const crossLeft: {
  * @category utils
  */
 export declare const crossRight: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A2>;
+    <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>;
 };
 /**
  * Composes this stream with the specified stream to create a cartesian
@@ -636,8 +639,8 @@ export declare const crossRight: {
  * @category utils
  */
 export declare const crossWith: {
-    <R2, E2, B, A, C>(that: Stream<R2, E2, B>, f: (a: A, b: B) => C): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, C>;
-    <R, E, R2, E2, B, A, C>(self: Stream<R, E, A>, that: Stream<R2, E2, B>, f: (a: A, b: B) => C): Stream<R | R2, E | E2, C>;
+    <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>;
 };
 /**
  * Delays the emission of values by holding new values for a set duration. If
@@ -654,8 +657,8 @@ export declare const crossWith: {
  * @category utils
  */
 export declare const debounce: {
-    (duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, duration: Duration.DurationInput): Stream<R, E, A>;
+    (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>;
 };
 /**
  * The stream that dies with the specified defect.
@@ -663,21 +666,21 @@ export declare const debounce: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const die: (defect: unknown) => Stream<never, never, never>;
+export declare const die: (defect: unknown) => Stream<never>;
 /**
  * The stream that dies with the specified lazily evaluated defect.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const dieSync: (evaluate: LazyArg<unknown>) => Stream<never, never, never>;
+export declare const dieSync: (evaluate: LazyArg<unknown>) => Stream<never>;
 /**
  * The stream that dies with an exception described by `message`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const dieMessage: (message: string) => Stream<never, never, never>;
+export declare const dieMessage: (message: string) => Stream<never>;
 /**
  * More powerful version of `Stream.broadcast`. Allows to provide a function
  * that determines what queues should receive which elements. The decide
@@ -690,13 +693,13 @@ export declare const distributedWith: {
     <N extends number, A>(options: {
         readonly size: N;
         readonly maximumLag: number;
-        readonly decide: (a: A) => Effect.Effect<never, never, Predicate<number>>;
-    }): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>, N>>;
-    <R, E, N extends number, A>(self: Stream<R, E, A>, options: {
+        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: {
         readonly size: N;
         readonly maximumLag: number;
-        readonly decide: (a: A) => Effect.Effect<never, never, Predicate<number>>;
-    }): Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>, N>>;
+        readonly decide: (a: A) => Effect.Effect<Predicate<number>>;
+    }): Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>, never, Scope.Scope | R>;
 };
 /**
  * More powerful version of `Stream.distributedWith`. This returns a function
@@ -712,12 +715,12 @@ export declare const distributedWith: {
 export declare const distributedWithDynamic: {
     <E, A, _>(options: {
         readonly maximumLag: number;
-        readonly decide: (a: A) => Effect.Effect<never, never, Predicate<number>>;
-    }): <R>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Effect.Effect<never, never, [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>>;
-    <R, E, A, _>(self: Stream<R, E, A>, options: {
+        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 maximumLag: number;
-        readonly decide: (a: A) => Effect.Effect<never, never, Predicate<number>>;
-    }): Effect.Effect<Scope.Scope | R, never, Effect.Effect<never, never, [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>>;
+        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>;
 };
 /**
  * Converts this stream to a stream that executes its effects but emits no
@@ -726,7 +729,7 @@ export declare const distributedWithDynamic: {
  * @since 2.0.0
  * @category utils
  */
-export declare const drain: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, never>;
+export declare const drain: <A, E, R>(self: Stream<A, E, R>) => Stream<never, E, R>;
 /**
  * Drains the provided stream in the background for as long as this stream is
  * running. If this stream ends before `other`, `other` will be interrupted.
@@ -736,8 +739,8 @@ export declare const drain: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, nev
  * @category utils
  */
 export declare const drainFork: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Drops the specified number of elements from this stream.
@@ -746,8 +749,8 @@ export declare const drainFork: {
  * @category utils
  */
 export declare const drop: {
-    (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>;
+    (n: number): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, n: number): Stream<A, E, R>;
 };
 /**
  * Drops the last specified number of elements from this stream.
@@ -758,8 +761,8 @@ export declare const drop: {
  * @category utils
  */
 export declare const dropRight: {
-    (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>;
+    (n: number): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, n: number): Stream<A, E, R>;
 };
 /**
  * Drops all elements of the stream until the specified predicate evaluates to
@@ -769,8 +772,8 @@ export declare const dropRight: {
  * @category utils
  */
 export declare const dropUntil: {
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
+    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
  * Drops all elements of the stream until the specified effectful predicate
@@ -780,8 +783,8 @@ export declare const dropUntil: {
  * @category utils
  */
 export declare const dropUntilEffect: {
-    <A, R2, E2>(predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2>(self: Stream<R, E, A>, predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Drops all elements of the stream for as long as the specified predicate
@@ -791,8 +794,8 @@ export declare const dropUntilEffect: {
  * @category utils
  */
 export declare const dropWhile: {
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
+    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
  * Drops all elements of the stream for as long as the specified predicate
@@ -802,8 +805,8 @@ export declare const dropWhile: {
  * @category utils
  */
 export declare const dropWhileEffect: {
-    <A, R2, E2>(predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2>(self: Stream<R, E, A>, predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Returns a stream whose failures and successes have been lifted into an
@@ -815,14 +818,14 @@ export declare const dropWhileEffect: {
  * @since 2.0.0
  * @category utils
  */
-export declare const either: <R, E, A>(self: Stream<R, E, A>) => Stream<R, never, Either.Either<E, A>>;
+export declare const either: <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<E, A>, never, R>;
 /**
  * The empty stream.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const empty: Stream<never, never, never>;
+export declare const empty: Stream<never>;
 /**
  * Executes the provided finalizer after this stream's finalizers run.
  *
@@ -830,8 +833,8 @@ export declare const empty: Stream<never, never, never>;
  * @category utils
  */
 export declare const ensuring: {
-    <R2, _>(finalizer: Effect.Effect<R2, never, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
-    <R, E, A, R2, _>(self: Stream<R, E, A>, finalizer: Effect.Effect<R2, never, _>): Stream<R | R2, E, A>;
+    <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>;
 };
 /**
  * Executes the provided finalizer after this stream's finalizers run.
@@ -840,8 +843,8 @@ export declare const ensuring: {
  * @category utils
  */
 export declare const ensuringWith: {
-    <E, R2>(finalizer: (exit: Exit.Exit<E, unknown>) => Effect.Effect<R2, never, unknown>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
-    <R, E, A, R2>(self: Stream<R, E, A>, finalizer: (exit: Exit.Exit<E, unknown>) => Effect.Effect<R2, never, unknown>): Stream<R | R2, E, A>;
+    <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>;
 };
 /**
  * Accesses the whole context of the stream.
@@ -849,63 +852,63 @@ export declare const ensuringWith: {
  * @since 2.0.0
  * @category context
  */
-export declare const context: <R>() => Stream<R, never, Context.Context<R>>;
+export declare const context: <R>() => Stream<Context.Context<R>, never, R>;
 /**
  * Accesses the context of the stream.
  *
  * @since 2.0.0
  * @category context
  */
-export declare const contextWith: <R, A>(f: (env: Context.Context<R>) => A) => Stream<R, never, A>;
+export declare const contextWith: <R, A>(f: (env: Context.Context<R>) => A) => Stream<A, never, R>;
 /**
  * Accesses the context of the stream in the context of an effect.
  *
  * @since 2.0.0
  * @category context
  */
-export declare const contextWithEffect: <R0, R, E, A>(f: (env: Context.Context<R0>) => Effect.Effect<R, E, A>) => Stream<R0 | R, E, A>;
+export declare const contextWithEffect: <R0, R, E, A>(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<R, E, A>) => Stream<R0 | R, E, A>;
+export declare const contextWithStream: <R0, R, E, A>(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<R, E, _>) => Stream<R, E, never>;
+export declare const execute: <R, E, _>(effect: Effect.Effect<_, E, R>) => Stream<never, E, R>;
 /**
  * Terminates with the specified error.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fail: <E>(error: E) => Stream<never, E, never>;
+export declare const fail: <E>(error: E) => Stream<never, E>;
 /**
  * Terminates with the specified lazily evaluated error.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const failSync: <E>(evaluate: LazyArg<E>) => Stream<never, E, never>;
+export declare const failSync: <E>(evaluate: LazyArg<E>) => Stream<never, E>;
 /**
  * The stream that always fails with the specified `Cause`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const failCause: <E>(cause: Cause.Cause<E>) => Stream<never, E, never>;
+export declare const failCause: <E>(cause: Cause.Cause<E>) => Stream<never, E>;
 /**
  * The stream that always fails with the specified lazily evaluated `Cause`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Stream<never, E, never>;
+export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Stream<never, E>;
 /**
  * Filters the elements emitted by this stream using the provided function.
  *
@@ -913,10 +916,10 @@ 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<R, E, A>) => Stream<R, E, B>;
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>;
-    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
+    <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, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
  * Effectfully filters the elements emitted by this stream.
@@ -925,8 +928,8 @@ export declare const filter: {
  * @category filtering
  */
 export declare const filterEffect: {
-    <A, R2, E2>(f: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2>(self: Stream<R, E, A>, f: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Performs a filter and map in a single step.
@@ -935,8 +938,8 @@ export declare const filterEffect: {
  * @category utils
  */
 export declare const filterMap: {
-    <A, B>(pf: (a: A) => Option.Option<B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
-    <R, E, A, B>(self: Stream<R, E, A>, pf: (a: A) => Option.Option<B>): Stream<R, E, B>;
+    <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>;
 };
 /**
  * Performs an effectful filter and map in a single step.
@@ -945,8 +948,8 @@ export declare const filterMap: {
  * @category utils
  */
 export declare const filterMapEffect: {
-    <A, R2, E2, A2>(pf: (a: A) => Option.Option<Effect.Effect<R2, E2, A2>>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, pf: (a: A) => Option.Option<Effect.Effect<R2, E2, A2>>): Stream<R | R2, E | E2, A2>;
+    <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>;
 };
 /**
  * Transforms all elements of the stream for as long as the specified partial
@@ -956,8 +959,8 @@ export declare const filterMapEffect: {
  * @category utils
  */
 export declare const filterMapWhile: {
-    <A, A2>(pf: (a: A) => Option.Option<A2>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2>;
-    <R, E, A, A2>(self: Stream<R, E, A>, pf: (a: A) => Option.Option<A2>): Stream<R, E, A2>;
+    <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>;
 };
 /**
  * Effectfully transforms all elements of the stream for as long as the
@@ -967,8 +970,8 @@ export declare const filterMapWhile: {
  * @category utils
  */
 export declare const filterMapWhileEffect: {
-    <A, R2, E2, A2>(pf: (a: A) => Option.Option<Effect.Effect<R2, E2, A2>>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, pf: (a: A) => Option.Option<Effect.Effect<R2, E2, A2>>): Stream<R | R2, E | E2, A2>;
+    <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>;
 };
 /**
  * Creates a one-element stream that never fails and executes the finalizer
@@ -977,7 +980,7 @@ export declare const filterMapWhileEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const finalizer: <R, _>(finalizer: Effect.Effect<R, never, _>) => Stream<R, never, void>;
+export declare const finalizer: <R, _>(finalizer: Effect.Effect<_, never, R>) => Stream<void, never, R>;
 /**
  * Finds the first element emitted by this stream that satisfies the provided
  * predicate.
@@ -986,10 +989,10 @@ export declare const finalizer: <R, _>(finalizer: Effect.Effect<R, never, _>) =>
  * @category elements
  */
 export declare const find: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>;
-    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
+    <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, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
  * Finds the first element emitted by this stream that satisfies the provided
@@ -999,8 +1002,8 @@ export declare const find: {
  * @category elements
  */
 export declare const findEffect: {
-    <A, R2, E2>(predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2>(self: Stream<R, E, A>, predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Returns a stream made of the concatenation in strict order of all the
@@ -1010,16 +1013,16 @@ export declare const findEffect: {
  * @category sequencing
  */
 export declare const flatMap: {
-    <A, R2, E2, A2>(f: (a: A) => Stream<R2, E2, A2>, options?: {
+    <A, R2, E2, A2>(f: (a: A) => Stream<A2, E2, R2>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
         readonly switch?: boolean | undefined;
-    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, f: (a: A) => Stream<R2, E2, A2>, options?: {
+    } | 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?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
         readonly switch?: boolean | undefined;
-    }): Stream<R | R2, E | E2, A2>;
+    } | undefined): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Flattens this stream-of-streams into a stream made of the concatenation in
@@ -1032,11 +1035,11 @@ export declare const flatten: {
     (options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
-    }): <R, E, R2, E2, A>(self: Stream<R, E, Stream<R2, E2, A>>) => Stream<R | R2, E | E2, A>;
-    <R, E, R2, E2, A>(self: Stream<R, E, Stream<R2, E2, A>>, options?: {
+    } | 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?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
-    }): Stream<R | R2, E | E2, A>;
+    } | undefined): Stream<A, E | E2, R | R2>;
 };
 /**
  * Submerges the chunks carried by this stream into the stream's structure,
@@ -1045,7 +1048,7 @@ export declare const flatten: {
  * @since 2.0.0
  * @category sequencing
  */
-export declare const flattenChunks: <R, E, A>(self: Stream<R, E, Chunk.Chunk<A>>) => Stream<R, E, A>;
+export declare const flattenChunks: <A, E, R>(self: Stream<Chunk.Chunk<A>, E, R>) => Stream<A, E, R>;
 /**
  * Flattens `Effect` values into the stream's structure, preserving all
  * information about the effect.
@@ -1057,11 +1060,11 @@ export declare const flattenEffect: {
     (options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly unordered?: boolean | undefined;
-    }): <R, E, R2, E2, A>(self: Stream<R, E, Effect.Effect<R2, E2, A>>) => Stream<R | R2, E | E2, A>;
-    <R, E, R2, E2, A>(self: Stream<R, E, Effect.Effect<R2, E2, A>>, options?: {
+    } | 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?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly unordered?: boolean | undefined;
-    }): Stream<R | R2, E | E2, A>;
+    } | undefined): Stream<A, E | E2, R | R2>;
 };
 /**
  * Unwraps `Exit` values that also signify end-of-stream by failing with `None`.
@@ -1075,7 +1078,7 @@ export declare const flattenEffect: {
  * @since 2.0.0
  * @category sequencing
  */
-export declare const flattenExitOption: <R, E, E2, A>(self: Stream<R, E, Exit.Exit<Option.Option<E2>, A>>) => Stream<R, E | E2, A>;
+export declare const flattenExitOption: <R, E, E2, A>(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.
@@ -1083,7 +1086,7 @@ export declare const flattenExitOption: <R, E, E2, A>(self: Stream<R, E, Exit.Ex
  * @since 2.0.0
  * @category sequencing
  */
-export declare const flattenIterables: <R, E, A>(self: Stream<R, E, Iterable<A>>) => Stream<R, E, A>;
+export declare const flattenIterables: <A, E, R>(self: Stream<Iterable<A>, E, R>) => Stream<A, E, R>;
 /**
  * Unwraps `Exit` values and flatten chunks that also signify end-of-stream
  * by failing with `None`.
@@ -1091,42 +1094,42 @@ export declare const flattenIterables: <R, E, A>(self: Stream<R, E, Iterable<A>>
  * @since 2.0.0
  * @category sequencing
  */
-export declare const flattenTake: <R, E, E2, A>(self: Stream<R, E, Take.Take<E2, A>>) => Stream<R, E | E2, A>;
+export declare const flattenTake: <R, E, E2, A>(self: Stream<Take.Take<A, E2>, E, R>) => Stream<A, E | E2, R>;
 /**
  * Repeats this stream forever.
  *
  * @since 2.0.0
  * @category utils
  */
-export declare const forever: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+export declare const forever: <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
 /**
  * Creates a stream from an `AsyncIterable`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromAsyncIterable: <E, A>(iterable: AsyncIterable<A>, onError: (e: unknown) => E) => Stream<never, E, A>;
+export declare const fromAsyncIterable: <A, E>(iterable: AsyncIterable<A>, onError: (e: unknown) => E) => Stream<A, E>;
 /**
  * Creates a stream from a `Channel`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromChannel: <R, E, A>(channel: Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>) => Stream<R, E, A>;
+export declare const fromChannel: <A, E, R>(channel: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown, R>) => Stream<A, E, R>;
 /**
  * Creates a channel from a `Stream`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const toChannel: <R, E, A>(stream: Stream<R, E, A>) => Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>;
+export declare const toChannel: <A, E, R>(stream: Stream<A, E, R>) => Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown, R>;
 /**
  * Creates a stream from a `Chunk` of values.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromChunk: <A>(chunk: Chunk.Chunk<A>) => Stream<never, never, A>;
+export declare const fromChunk: <A>(chunk: Chunk.Chunk<A>) => Stream<A>;
 /**
  * Creates a stream from a subscription to a `PubSub`.
  *
@@ -1138,11 +1141,11 @@ export declare const fromChunkPubSub: {
     <A>(pubsub: PubSub.PubSub<Chunk.Chunk<A>>, options: {
         readonly scoped: true;
         readonly shutdown?: boolean | undefined;
-    }): Effect.Effect<Scope.Scope, never, Stream<never, never, A>>;
+    }): Effect.Effect<Stream<A>, never, Scope.Scope>;
     <A>(pubsub: PubSub.PubSub<Chunk.Chunk<A>>, options?: {
         readonly scoped?: false | undefined;
         readonly shutdown?: boolean | undefined;
-    }): Stream<never, never, A>;
+    } | undefined): Stream<A>;
 };
 /**
  * Creates a stream from a `Queue` of values.
@@ -1153,14 +1156,14 @@ export declare const fromChunkPubSub: {
  */
 export declare const fromChunkQueue: <A>(queue: Queue.Dequeue<Chunk.Chunk<A>>, options?: {
     readonly shutdown?: boolean | undefined;
-}) => Stream<never, never, A>;
+}) => Stream<A>;
 /**
  * Creates a stream from an arbitrary number of chunks.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromChunks: <A>(...chunks: Array<Chunk.Chunk<A>>) => Stream<never, never, A>;
+export declare const fromChunks: <A>(...chunks: Array<Chunk.Chunk<A>>) => Stream<A>;
 /**
  * Either emits the success value of this effect or terminates the stream
  * with the failure value of this effect.
@@ -1168,7 +1171,7 @@ export declare const fromChunks: <A>(...chunks: Array<Chunk.Chunk<A>>) => Stream
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream<R, E, A>;
+export declare const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Stream<A, E, R>;
 /**
  * Creates a stream from an effect producing a value of type `A` or an empty
  * `Stream`.
@@ -1176,7 +1179,7 @@ export declare const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => St
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromEffectOption: <R, E, A>(effect: Effect.Effect<R, Option.Option<E>, A>) => Stream<R, E, A>;
+export declare const fromEffectOption: <A, E, R>(effect: Effect.Effect<A, Option.Option<E>, R>) => Stream<A, E, R>;
 /**
  * Creates a stream from a subscription to a `PubSub`.
  *
@@ -1189,12 +1192,12 @@ export declare const fromPubSub: {
         readonly scoped: true;
         readonly maxChunkSize?: number | undefined;
         readonly shutdown?: boolean | undefined;
-    }): Effect.Effect<Scope.Scope, never, Stream<never, never, A>>;
+    }): Effect.Effect<Stream<A>, never, Scope.Scope>;
     <A>(pubsub: PubSub.PubSub<A>, options?: {
         readonly scoped?: false | undefined;
         readonly maxChunkSize?: number | undefined;
         readonly shutdown?: boolean | undefined;
-    }): Stream<never, never, A>;
+    } | undefined): Stream<A>;
 };
 /**
  * Creates a new `Stream` from an iterable collection of values.
@@ -1202,21 +1205,21 @@ export declare const fromPubSub: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromIterable: <A>(iterable: Iterable<A>) => Stream<never, never, A>;
+export declare const fromIterable: <A>(iterable: Iterable<A>) => Stream<A>;
 /**
  * Creates a stream from an effect producing a value of type `Iterable<A>`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromIterableEffect: <R, E, A>(effect: Effect.Effect<R, E, Iterable<A>>) => Stream<R, E, A>;
+export declare const fromIterableEffect: <A, E, R>(effect: Effect.Effect<Iterable<A>, E, R>) => Stream<A, E, R>;
 /**
  * Creates a stream from an iterator
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromIteratorSucceed: <A>(iterator: IterableIterator<A>, maxChunkSize?: number) => Stream<never, never, A>;
+export declare const fromIteratorSucceed: <A>(iterator: IterableIterator<A>, maxChunkSize?: number) => Stream<A>;
 /**
  * Creates a stream from an effect that pulls elements from another stream.
  *
@@ -1225,7 +1228,7 @@ export declare const fromIteratorSucceed: <A>(iterator: IterableIterator<A>, max
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromPull: <R, R2, E, A>(effect: Effect.Effect<Scope.Scope | R, never, Effect.Effect<R2, Option.Option<E>, Chunk.Chunk<A>>>) => Stream<Exclude<R, Scope.Scope> | R2, E, A>;
+export declare const fromPull: <R, R2, E, A>(effect: Effect.Effect<Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R2>, never, Scope.Scope | R>) => Stream<A, E, R2 | Exclude<R, Scope.Scope>>;
 /**
  * Creates a stream from a queue of values
  *
@@ -1237,7 +1240,7 @@ export declare const fromPull: <R, R2, E, A>(effect: Effect.Effect<Scope.Scope |
 export declare const fromQueue: <A>(queue: Queue.Dequeue<A>, options?: {
     readonly maxChunkSize?: number | undefined;
     readonly shutdown?: boolean | undefined;
-}) => Stream<never, never, A>;
+}) => Stream<A>;
 /**
  * Creates a stream from a `ReadableStream`.
  *
@@ -1246,7 +1249,7 @@ export declare const fromQueue: <A>(queue: Queue.Dequeue<A>, options?: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromReadableStream: <A, E>(evaluate: LazyArg<ReadableStream<A>>, onError: (error: unknown) => E) => Stream<never, E, A>;
+export declare const fromReadableStream: <A, E>(evaluate: LazyArg<ReadableStream<A>>, onError: (error: unknown) => E) => Stream<A, E>;
 /**
  * Creates a stream from a `ReadableStreamBYOBReader`.
  *
@@ -1256,7 +1259,7 @@ export declare const fromReadableStream: <A, E>(evaluate: LazyArg<ReadableStream
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromReadableStreamByob: <E>(evaluate: LazyArg<ReadableStream<Uint8Array>>, onError: (error: unknown) => E, allocSize?: number) => Stream<never, E, Uint8Array>;
+export declare const fromReadableStreamByob: <E>(evaluate: LazyArg<ReadableStream<Uint8Array>>, onError: (error: unknown) => E, allocSize?: number) => Stream<Uint8Array, E>;
 /**
  * Creates a stream from a `Schedule` that does not require any further
  * input. The stream will emit an element for each value output from the
@@ -1265,7 +1268,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<R, never, A>;
+export declare const fromSchedule: <R, A>(schedule: Schedule.Schedule<R, unknown, A>) => Stream<A, never, R>;
 /**
  * Creates a pipeline that groups on adjacent keys, calculated by the
  * specified function.
@@ -1274,8 +1277,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<R, E, A>) => Stream<R, E, [K, Chunk.NonEmptyChunk<A>]>;
-    <R, E, A, K>(self: Stream<R, E, A>, f: (a: A) => K): Stream<R, E, [K, Chunk.NonEmptyChunk<A>]>;
+    <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>;
 };
 /**
  * More powerful version of `Stream.groupByKey`.
@@ -1284,12 +1287,12 @@ export declare const groupAdjacentBy: {
  * @category grouping
  */
 export declare const groupBy: {
-    <A, R2, E2, K, V>(f: (a: A) => Effect.Effect<R2, E2, readonly [K, V]>, options?: {
+    <A, R2, E2, K, V>(f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>, options?: {
         readonly bufferSize?: number | undefined;
-    }): <R, E>(self: Stream<R, E, A>) => GroupBy.GroupBy<R2 | R, E2 | E, K, V>;
-    <R, E, A, R2, E2, K, V>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, readonly [K, V]>, options?: {
+    } | 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?: {
         readonly bufferSize?: number | undefined;
-    }): GroupBy.GroupBy<R | R2, E | E2, K, V>;
+    } | undefined): GroupBy.GroupBy<R | R2, E | E2, K, V>;
 };
 /**
  * Partition a stream using a function and process each stream individually.
@@ -1331,8 +1334,8 @@ export declare const groupBy: {
 export declare const groupByKey: {
     <A, K>(f: (a: A) => K, options?: {
         readonly bufferSize?: number | undefined;
-    }): <R, E>(self: Stream<R, E, A>) => GroupBy.GroupBy<R, E, K, A>;
-    <R, E, A, K>(self: Stream<R, E, A>, f: (a: A) => K, options?: {
+    }): <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?: {
         readonly bufferSize?: number | undefined;
     }): GroupBy.GroupBy<R, E, K, A>;
 };
@@ -1343,8 +1346,8 @@ export declare const groupByKey: {
  * @category utils
  */
 export declare const grouped: {
-    (chunkSize: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
-    <R, E, A>(self: Stream<R, E, A>, chunkSize: number): Stream<R, E, Chunk.Chunk<A>>;
+    (chunkSize: number): <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, chunkSize: number): Stream<Chunk.Chunk<A>, E, R>;
 };
 /**
  * Partitions the stream with the specified `chunkSize` or until the specified
@@ -1354,8 +1357,8 @@ export declare const grouped: {
  * @category utils
  */
 export declare const groupedWithin: {
-    (chunkSize: number, duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
-    <R, E, A>(self: Stream<R, E, A>, chunkSize: number, duration: Duration.DurationInput): Stream<R, E, Chunk.Chunk<A>>;
+    (chunkSize: number, duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, chunkSize: number, duration: Duration.DurationInput): Stream<Chunk.Chunk<A>, E, R>;
 };
 /**
  * Specialized version of haltWhen which halts the evaluation of this stream
@@ -1368,8 +1371,8 @@ export declare const groupedWithin: {
  * @category utils
  */
 export declare const haltAfter: {
-    (duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, duration: Duration.DurationInput): Stream<R, E, A>;
+    (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>;
 };
 /**
  * Halts the evaluation of this stream when the provided effect completes. The
@@ -1385,8 +1388,8 @@ export declare const haltAfter: {
  * @category utils
  */
 export declare const haltWhen: {
-    <R2, E2, _>(effect: Effect.Effect<R2, E2, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, effect: Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Halts the evaluation of this stream when the provided promise resolves.
@@ -1397,8 +1400,8 @@ export declare const haltWhen: {
  * @category utils
  */
 export declare const haltWhenDeferred: {
-    <E2, _>(deferred: Deferred.Deferred<E2, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, A>;
-    <R, E, A, E2, _>(self: Stream<R, E, A>, deferred: Deferred.Deferred<E2, _>): Stream<R, E | E2, A>;
+    <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>;
 };
 /**
  * The identity pipeline, which does not modify streams in any way.
@@ -1406,7 +1409,7 @@ export declare const haltWhenDeferred: {
  * @since 2.0.0
  * @category utils
  */
-export declare const identity: <R, E, A>() => Stream<R, E, A>;
+export declare const identity: <A, E = never, R = never>() => Stream<A, E, R>;
 /**
  * Interleaves this stream and the specified stream deterministically by
  * alternating pulling values from this stream and the specified stream. When
@@ -1417,8 +1420,8 @@ export declare const identity: <R, E, A>() => Stream<R, E, A>;
  * @category utils
  */
 export declare const interleave: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A | A2>;
+    <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>;
 };
 /**
  * Combines this stream and the specified stream deterministically using the
@@ -1433,8 +1436,8 @@ export declare const interleave: {
  * @category utils
  */
 export declare const interleaveWith: {
-    <R2, E2, A2, R3, E3>(that: Stream<R2, E2, A2>, decider: Stream<R3, E3, boolean>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R3 | R, E2 | E3 | E, A2 | A>;
-    <R, E, A, R2, E2, A2, R3, E3>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, decider: Stream<R3, E3, boolean>): Stream<R | R2 | R3, E | E2 | E3, A | A2>;
+    <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>;
 };
 /**
  * Intersperse stream with provided `element`.
@@ -1443,8 +1446,8 @@ export declare const interleaveWith: {
  * @category utils
  */
 export declare const intersperse: {
-    <A2>(element: A2): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A2 | A>;
-    <R, E, A, A2>(self: Stream<R, E, A>, element: A2): Stream<R, E, A | A2>;
+    <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>;
 };
 /**
  * Intersperse the specified element, also adding a prefix and a suffix.
@@ -1457,12 +1460,12 @@ export declare const intersperseAffixes: {
         readonly start: A2;
         readonly middle: A3;
         readonly end: A4;
-    }): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A2 | A3 | A4 | A>;
-    <R, E, A, A2, A3, A4>(self: Stream<R, E, A>, options: {
+    }): <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: {
         readonly start: A2;
         readonly middle: A3;
         readonly end: A4;
-    }): Stream<R, E, A | A2 | A3 | A4>;
+    }): Stream<A | A2 | A3 | A4, E, R>;
 };
 /**
  * Specialized version of `Stream.interruptWhen` which interrupts the
@@ -1472,8 +1475,8 @@ export declare const intersperseAffixes: {
  * @category utils
  */
 export declare const interruptAfter: {
-    (duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, duration: Duration.DurationInput): Stream<R, E, A>;
+    (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>;
 };
 /**
  * Interrupts the evaluation of this stream when the provided effect
@@ -1488,8 +1491,8 @@ export declare const interruptAfter: {
  * @category utils
  */
 export declare const interruptWhen: {
-    <R2, E2, _>(effect: Effect.Effect<R2, E2, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, effect: Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Interrupts the evaluation of this stream when the provided promise
@@ -1502,8 +1505,8 @@ export declare const interruptWhen: {
  * @category utils
  */
 export declare const interruptWhenDeferred: {
-    <E2, _>(deferred: Deferred.Deferred<E2, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, A>;
-    <R, E, A, E2, _>(self: Stream<R, E, A>, deferred: Deferred.Deferred<E2, _>): Stream<R, E | E2, A>;
+    <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>;
 };
 /**
  * The infinite stream of iterative function application: a, f(a), f(f(a)),
@@ -1512,14 +1515,14 @@ export declare const interruptWhenDeferred: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const iterate: <A>(value: A, next: (value: A) => A) => Stream<never, never, A>;
+export declare const iterate: <A>(value: A, next: (value: A) => A) => Stream<A>;
 /**
  * Creates a stream from an sequence of values.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const make: <As extends Array<any>>(...as: As) => Stream<never, never, As[number]>;
+export declare const make: <As extends Array<any>>(...as: As) => Stream<As[number]>;
 /**
  * Transforms the elements of this stream using the supplied function.
  *
@@ -1527,8 +1530,8 @@ export declare const make: <As extends Array<any>>(...as: As) => Stream<never, n
  * @category mapping
  */
 export declare const map: {
-    <A, B>(f: (a: A) => B): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
-    <R, E, A, B>(self: Stream<R, E, A>, f: (a: A) => B): Stream<R, E, B>;
+    <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>;
 };
 /**
  * Statefully maps over the elements of this stream to produce new elements.
@@ -1537,8 +1540,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<R, E, A>) => Stream<R, E, A2>;
-    <R, E, S, A, A2>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => readonly [S, A2]): Stream<R, E, A2>;
+    <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>;
 };
 /**
  * Statefully and effectfully maps over the elements of this stream to produce
@@ -1548,8 +1551,8 @@ export declare const mapAccum: {
  * @category mapping
  */
 export declare const mapAccumEffect: {
-    <S, A, R2, E2, A2>(s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, readonly [S, A2]>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, S, A, R2, E2, A2>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, readonly [S, A2]>): Stream<R | R2, E | E2, A2>;
+    <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>;
 };
 /**
  * Returns a stream whose failure and success channels have been mapped by the
@@ -1562,11 +1565,11 @@ export declare const mapBoth: {
     <E, E2, A, A2>(options: {
         readonly onFailure: (e: E) => E2;
         readonly onSuccess: (a: A) => A2;
-    }): <R>(self: Stream<R, E, A>) => Stream<R, E2, A2>;
-    <R, E, E2, A, A2>(self: Stream<R, E, A>, options: {
+    }): <R>(self: Stream<A, E, R>) => Stream<A2, E2, R>;
+    <R, E, E2, A, A2>(self: Stream<A, E, R>, options: {
         readonly onFailure: (e: E) => E2;
         readonly onSuccess: (a: A) => A2;
-    }): Stream<R, E2, A2>;
+    }): Stream<A2, E2, R>;
 };
 /**
  * Transforms the chunks emitted by this stream.
@@ -1575,8 +1578,8 @@ export declare const mapBoth: {
  * @category mapping
  */
 export declare const mapChunks: {
-    <A, B>(f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
-    <R, E, A, B>(self: Stream<R, E, A>, f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<B>): Stream<R, E, B>;
+    <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>;
 };
 /**
  * Effectfully transforms the chunks emitted by this stream.
@@ -1585,8 +1588,8 @@ export declare const mapChunks: {
  * @category mapping
  */
 export declare const mapChunksEffect: {
-    <A, R2, E2, B>(f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, Chunk.Chunk<B>>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, B>;
-    <R, E, A, R2, E2, B>(self: Stream<R, E, A>, f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, Chunk.Chunk<B>>): Stream<R | R2, E | E2, B>;
+    <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>;
 };
 /**
  * Maps each element to an iterable, and flattens the iterables into the
@@ -1596,8 +1599,8 @@ export declare const mapChunksEffect: {
  * @category mapping
  */
 export declare const mapConcat: {
-    <A, A2>(f: (a: A) => Iterable<A2>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2>;
-    <R, E, A, A2>(self: Stream<R, E, A>, f: (a: A) => Iterable<A2>): Stream<R, E, A2>;
+    <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>;
 };
 /**
  * Maps each element to a chunk, and flattens the chunks into the output of
@@ -1607,8 +1610,8 @@ export declare const mapConcat: {
  * @category mapping
  */
 export declare const mapConcatChunk: {
-    <A, A2>(f: (a: A) => Chunk.Chunk<A2>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2>;
-    <R, E, A, A2>(self: Stream<R, E, A>, f: (a: A) => Chunk.Chunk<A2>): Stream<R, E, A2>;
+    <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>;
 };
 /**
  * Effectfully maps each element to a chunk, and flattens the chunks into the
@@ -1618,8 +1621,8 @@ export declare const mapConcatChunk: {
  * @category mapping
  */
 export declare const mapConcatChunkEffect: {
-    <A, R2, E2, A2>(f: (a: A) => Effect.Effect<R2, E2, Chunk.Chunk<A2>>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, Chunk.Chunk<A2>>): Stream<R | R2, E | E2, A2>;
+    <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>;
 };
 /**
  * Effectfully maps each element to an iterable, and flattens the iterables
@@ -1629,8 +1632,8 @@ export declare const mapConcatChunkEffect: {
  * @category mapping
  */
 export declare const mapConcatEffect: {
-    <A, R2, E2, A2>(f: (a: A) => Effect.Effect<R2, E2, Iterable<A2>>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, Iterable<A2>>): Stream<R | R2, E | E2, A2>;
+    <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>;
 };
 /**
  * Maps over elements of the stream with the specified effectful function.
@@ -1639,22 +1642,22 @@ export declare const mapConcatEffect: {
  * @category mapping
  */
 export declare const mapEffect: {
-    <A, R2, E2, A2>(f: (a: A) => Effect.Effect<R2, E2, A2>, options?: {
+    <A, R2, E2, A2>(f: (a: A) => Effect.Effect<A2, E2, R2>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly unordered?: boolean | undefined;
-    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <A, R2, E2, A2, K>(f: (a: A) => Effect.Effect<R2, E2, A2>, options: {
+    } | 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: {
         readonly key: (a: A) => K;
         readonly bufferSize?: number | undefined;
-    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, A2>, options?: {
+    }): <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?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly unordered?: boolean | undefined;
-    }): Stream<R | R2, E | E2, A2>;
-    <R, E, A, R2, E2, A2, K>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, A2>, options: {
+    } | 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: {
         readonly key: (a: A) => K;
         readonly bufferSize?: number | undefined;
-    }): Stream<R | R2, E | E2, A2>;
+    }): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Transforms the errors emitted by this stream using `f`.
@@ -1663,8 +1666,8 @@ export declare const mapEffect: {
  * @category mapping
  */
 export declare const mapError: {
-    <E, E2>(f: (error: E) => E2): <R, A>(self: Stream<R, E, A>) => Stream<R, E2, A>;
-    <R, A, E, E2>(self: Stream<R, E, A>, f: (error: E) => E2): Stream<R, E2, A>;
+    <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>;
 };
 /**
  * Transforms the full causes of failures emitted by this stream.
@@ -1673,8 +1676,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<R, E, A>) => Stream<R, E2, A>;
-    <R, A, E, E2>(self: Stream<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Stream<R, E2, A>;
+    <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>;
 };
 /**
  * Merges this stream and the specified stream together.
@@ -1686,12 +1689,12 @@ export declare const mapErrorCause: {
  * @category utils
  */
 export declare const merge: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>, options?: {
+    <R2, E2, A2>(that: Stream<A2, E2, R2>, options?: {
         readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined;
-    }): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, options?: {
+    } | 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?: {
         readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined;
-    }): Stream<R | R2, E | E2, A | A2>;
+    } | undefined): Stream<A | A2, E | E2, R | R2>;
 };
 /**
  * Merges a variable list of streams in a non-deterministic fashion. Up to `n`
@@ -1705,11 +1708,11 @@ export declare const mergeAll: {
     (options: {
         readonly concurrency: number | "unbounded";
         readonly bufferSize?: number | undefined;
-    }): <R, E, A>(streams: Iterable<Stream<R, E, A>>) => Stream<R, E, A>;
-    <R, E, A>(streams: Iterable<Stream<R, E, A>>, options: {
+    }): <A, E, R>(streams: Iterable<Stream<A, E, R>>) => Stream<A, E, R>;
+    <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
         readonly concurrency: number | "unbounded";
         readonly bufferSize?: number | undefined;
-    }): Stream<R, E, A>;
+    }): Stream<A, E, R>;
 };
 /**
  * Merges this stream and the specified stream together to a common element
@@ -1722,16 +1725,16 @@ export declare const mergeAll: {
  * @category utils
  */
 export declare const mergeWith: {
-    <R2, E2, A2, A, A3, A4>(other: Stream<R2, E2, A2>, options: {
+    <R2, E2, A2, 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<R, E, A>) => Stream<R2 | R, E2 | E, A3 | A4>;
-    <R, E, R2, E2, A2, A, A3, A4>(self: Stream<R, E, A>, other: Stream<R2, E2, A2>, options: {
+    }): <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: {
         readonly onSelf: (a: A) => A3;
         readonly onOther: (a2: A2) => A4;
         readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined;
-    }): Stream<R | R2, E | E2, A3 | A4>;
+    }): Stream<A3 | A4, E | E2, R | R2>;
 };
 /**
  * Merges this stream and the specified stream together to produce a stream of
@@ -1741,8 +1744,8 @@ export declare const mergeWith: {
  * @category utils
  */
 export declare const mergeEither: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, Either.Either<A, A2>>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, Either.Either<A, A2>>;
+    <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>;
 };
 /**
  * Merges this stream and the specified stream together, discarding the values
@@ -1752,8 +1755,8 @@ export declare const mergeEither: {
  * @category utils
  */
 export declare const mergeLeft: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Merges this stream and the specified stream together, discarding the values
@@ -1763,8 +1766,8 @@ export declare const mergeLeft: {
  * @category utils
  */
 export declare const mergeRight: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A2>;
+    <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>;
 };
 /**
  * Returns a combined string resulting from concatenating each of the values
@@ -1773,14 +1776,14 @@ export declare const mergeRight: {
  * @since 2.0.0
  * @category utils
  */
-export declare const mkString: <R, E>(self: Stream<R, E, string>) => Effect.Effect<R, E, string>;
+export declare const mkString: <R, E>(self: Stream<string, E, R>) => Effect.Effect<string, E, R>;
 /**
  * The stream that never produces any value or fails with any error.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const never: Stream<never, never, never>;
+export declare const never: Stream<never>;
 /**
  * Runs the specified effect if this stream fails, providing the error to the
  * effect if it exists.
@@ -1792,8 +1795,8 @@ export declare const never: Stream<never, never, never>;
  * @category utils
  */
 export declare const onError: {
-    <E, R2, _>(cleanup: (cause: Cause.Cause<E>) => Effect.Effect<R2, never, _>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
-    <R, A, E, R2, _>(self: Stream<R, E, A>, cleanup: (cause: Cause.Cause<E>) => Effect.Effect<R2, never, _>): Stream<R | R2, E, A>;
+    <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>;
 };
 /**
  * Runs the specified effect if this stream ends.
@@ -1802,8 +1805,8 @@ export declare const onError: {
  * @category utils
  */
 export declare const onDone: {
-    <R2, _>(cleanup: () => Effect.Effect<R2, never, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
-    <R, E, A, R2, _>(self: Stream<R, E, A>, cleanup: () => Effect.Effect<R2, never, _>): Stream<R | R2, E, A>;
+    <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>;
 };
 /**
  * Translates any failure into a stream termination, making the stream
@@ -1812,7 +1815,7 @@ export declare const onDone: {
  * @since 2.0.0
  * @category error handling
  */
-export declare const orDie: <R, E, A>(self: Stream<R, E, A>) => Stream<R, never, A>;
+export declare const orDie: <A, E, R>(self: Stream<A, E, R>) => Stream<A, never, R>;
 /**
  * Keeps none of the errors, and terminates the stream with them, using the
  * specified function to convert the `E` into a defect.
@@ -1821,8 +1824,8 @@ export declare const orDie: <R, E, A>(self: Stream<R, E, A>) => Stream<R, never,
  * @category error handling
  */
 export declare const orDieWith: {
-    <E>(f: (e: E) => unknown): <R, A>(self: Stream<R, E, A>) => Stream<R, never, A>;
-    <R, A, E>(self: Stream<R, E, A>, f: (e: E) => unknown): Stream<R, never, A>;
+    <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>;
 };
 /**
  * Switches to the provided stream in case this one fails with a typed error.
@@ -1833,8 +1836,8 @@ export declare const orDieWith: {
  * @category error handling
  */
 export declare const orElse: {
-    <R2, E2, A2>(that: LazyArg<Stream<R2, E2, A2>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: LazyArg<Stream<R2, E2, A2>>): Stream<R | R2, E2, A | A2>;
+    <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>;
 };
 /**
  * Switches to the provided stream in case this one fails with a typed error.
@@ -1845,8 +1848,8 @@ export declare const orElse: {
  * @category error handling
  */
 export declare const orElseEither: {
-    <R2, E2, A2>(that: LazyArg<Stream<R2, E2, A2>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2, Either.Either<A, A2>>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: LazyArg<Stream<R2, E2, A2>>): Stream<R | R2, E2, Either.Either<A, A2>>;
+    <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>;
 };
 /**
  * Fails with given error in case this one fails with a typed error.
@@ -1857,8 +1860,8 @@ export declare const orElseEither: {
  * @category error handling
  */
 export declare const orElseFail: {
-    <E2>(error: LazyArg<E2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2, A>;
-    <R, E, A, E2>(self: Stream<R, E, A>, error: LazyArg<E2>): Stream<R, E2, A>;
+    <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>;
 };
 /**
  * Produces the specified element if this stream is empty.
@@ -1867,8 +1870,8 @@ export declare const orElseFail: {
  * @category error handling
  */
 export declare const orElseIfEmpty: {
-    <A2>(element: LazyArg<A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A2 | A>;
-    <R, E, A, A2>(self: Stream<R, E, A>, element: LazyArg<A2>): Stream<R, E, A | A2>;
+    <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>;
 };
 /**
  * Produces the specified chunk if this stream is empty.
@@ -1877,8 +1880,8 @@ export declare const orElseIfEmpty: {
  * @category error handling
  */
 export declare const orElseIfEmptyChunk: {
-    <A2>(chunk: LazyArg<Chunk.Chunk<A2>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A2 | A>;
-    <R, E, A, A2>(self: Stream<R, E, A>, chunk: LazyArg<Chunk.Chunk<A2>>): Stream<R, E, A | A2>;
+    <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>;
 };
 /**
  * Switches to the provided stream in case this one is empty.
@@ -1887,8 +1890,8 @@ export declare const orElseIfEmptyChunk: {
  * @category error handling
  */
 export declare const orElseIfEmptyStream: {
-    <R2, E2, A2>(stream: LazyArg<Stream<R2, E2, A2>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, stream: LazyArg<Stream<R2, E2, A2>>): Stream<R | R2, E | E2, A | A2>;
+    <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>;
 };
 /**
  * Succeeds with the specified value if this one fails with a typed error.
@@ -1897,8 +1900,8 @@ export declare const orElseIfEmptyStream: {
  * @category error handling
  */
 export declare const orElseSucceed: {
-    <A2>(value: LazyArg<A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, never, A2 | A>;
-    <R, E, A, A2>(self: Stream<R, E, A>, value: LazyArg<A2>): Stream<R, never, A | A2>;
+    <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>;
 };
 /**
  * Like `Stream.unfold`, but allows the emission of values to end one step further
@@ -1908,7 +1911,7 @@ export declare const orElseSucceed: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const paginate: <S, A>(s: S, f: (s: S) => readonly [A, Option.Option<S>]) => Stream<never, never, A>;
+export declare const paginate: <S, A>(s: S, f: (s: S) => readonly [A, Option.Option<S>]) => Stream<A>;
 /**
  * Like `Stream.unfoldChunk`, but allows the emission of values to end one step
  * further than the unfolding of the state. This is useful for embedding
@@ -1917,7 +1920,7 @@ export declare const paginate: <S, A>(s: S, f: (s: S) => readonly [A, Option.Opt
  * @since 2.0.0
  * @category constructors
  */
-export declare const paginateChunk: <S, A>(s: S, f: (s: S) => readonly [Chunk.Chunk<A>, Option.Option<S>]) => Stream<never, never, A>;
+export declare const paginateChunk: <S, A>(s: S, f: (s: S) => readonly [Chunk.Chunk<A>, Option.Option<S>]) => Stream<A>;
 /**
  * Like `Stream.unfoldChunkEffect`, but allows the emission of values to end one step
  * further than the unfolding of the state. This is useful for embedding
@@ -1926,7 +1929,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<R, E, readonly [Chunk.Chunk<A>, Option.Option<S>]>) => Stream<R, E, A>;
+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>;
 /**
  * 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
@@ -1935,7 +1938,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<R, E, readonly [A, Option.Option<S>]>) => Stream<R, E, A>;
+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>;
 /**
  * Partition a stream using a predicate. The first stream will contain all
  * element evaluated to true and the second one will contain all element
@@ -1948,16 +1951,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;
-    }): <R, E>(self: Stream<R, E, C>) => Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, Exclude<C, B>>, satisfying: Stream<never, E, B>]>;
+    } | undefined): <R, E>(self: Stream<C, E, R>) => Effect.Effect<[excluded: Stream<Exclude<C, B>, E>, satisfying: Stream<B, E>], E, Scope.Scope | R>;
     <A>(predicate: Predicate<A>, options?: {
         bufferSize?: number | undefined;
-    }): <R, E, B extends A>(self: Stream<R, E, B>) => Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, B>, satisfying: Stream<never, E, B>]>;
-    <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>, options?: {
+    } | 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?: {
         bufferSize?: number | undefined;
-    }): Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, Exclude<A, B>>, satisfying: Stream<never, E, B>]>;
-    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>, options?: {
+    } | undefined): Effect.Effect<[excluded: Stream<Exclude<C, B>, E>, satisfying: Stream<B, E>], E, Scope.Scope | R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>, options?: {
         bufferSize?: number | undefined;
-    }): Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, A>, satisfying: Stream<never, E, A>]>;
+    } | undefined): Effect.Effect<[excluded: Stream<A, E>, satisfying: Stream<A, E>], E, Scope.Scope | R>;
 };
 /**
  * Split a stream by an effectful predicate. The faster stream may advance by
@@ -1967,12 +1970,12 @@ export declare const partition: {
  * @category utils
  */
 export declare const partitionEither: {
-    <A, R2, E2, A2, A3>(predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, Either.Either<A2, A3>>, options?: {
+    <A, R2, E2, A2, A3>(predicate: (a: NoInfer<A>) => Effect.Effect<Either.Either<A2, A3>, E2, R2>, options?: {
         readonly bufferSize?: number | undefined;
-    }): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, [left: Stream<never, E2 | E, A2>, right: Stream<never, E2 | E, A3>]>;
-    <R, E, A, R2, E2, A2, A3>(self: Stream<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, Either.Either<A2, A3>>, options?: {
+    } | 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?: {
         readonly bufferSize?: number | undefined;
-    }): Effect.Effect<Scope.Scope | R | R2, E | E2, [left: Stream<never, E | E2, A2>, right: Stream<never, E | E2, A3>]>;
+    } | undefined): Effect.Effect<[left: Stream<A2, E | E2>, right: Stream<A3, E | E2>], E | E2, Scope.Scope | R | R2>;
 };
 /**
  * Peels off enough material from the stream to construct a `Z` using the
@@ -1984,8 +1987,8 @@ export declare const partitionEither: {
  * @category utils
  */
 export declare const peel: {
-    <R2, E2, A, Z>(sink: Sink.Sink<R2, E2, A, A, Z>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, [Z, Stream<never, E, A>]>;
-    <R, E, R2, E2, A, Z>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, A, Z>): Effect.Effect<Scope.Scope | R | R2, E | E2, [Z, Stream<never, E, A>]>;
+    <A2, A, E2, R2>(sink: Sink.Sink<A2, A, A, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[A2, Stream<A, E, never>], E2 | E, Scope.Scope | R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<A2, A, A, E2, R2>): Effect.Effect<[A2, Stream<A, E, never>], E | E2, Scope.Scope | R | R2>;
 };
 /**
  * Pipes all of the values from this stream through the provided sink.
@@ -1996,8 +1999,8 @@ export declare const peel: {
  * @category utils
  */
 export declare const pipeThrough: {
-    <R2, E2, A, L, Z>(sink: Sink.Sink<R2, E2, A, L, Z>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, L>;
-    <R, E, R2, E2, A, L, Z>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, L, Z>): Stream<R | R2, E | E2, L>;
+    <A2, A, L, E2, R2>(sink: Sink.Sink<A2, A, L, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<L, E2 | E, R2 | R>;
+    <A, E, R, A2, L, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<A2, A, L, E2, R2>): Stream<L, E | E2, R | R2>;
 };
 /**
  * Pipes all the values from this stream through the provided channel.
@@ -2006,8 +2009,8 @@ export declare const pipeThrough: {
  * @category utils
  */
 export declare const pipeThroughChannel: {
-    <R2, E, E2, A, A2>(channel: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>): <R>(self: Stream<R, E, A>) => Stream<R2 | R, E2, A2>;
-    <R, R2, E, E2, A, A2>(self: Stream<R, E, A>, channel: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>): Stream<R | R2, E2, A2>;
+    <R2, E, E2, A, A2>(channel: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>): <R>(self: Stream<A, E, R>) => Stream<A2, E2, R2 | R>;
+    <R, R2, E, E2, A, A2>(self: Stream<A, E, R>, channel: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>): Stream<A2, E2, R | R2>;
 };
 /**
  * Pipes all values from this stream through the provided channel, passing
@@ -2017,8 +2020,8 @@ export declare const pipeThroughChannel: {
  * @category utils
  */
 export declare const pipeThroughChannelOrFail: {
-    <R2, E, E2, A, A2>(chan: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>): <R>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A2>;
-    <R, R2, E, E2, A, A2>(self: Stream<R, E, A>, chan: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>): Stream<R | R2, E | E2, A2>;
+    <R2, E, E2, A, A2>(chan: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>): <R>(self: Stream<A, E, R>) => Stream<A2, E | E2, R2 | R>;
+    <R, R2, E, E2, A, A2>(self: Stream<A, E, R>, chan: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Emits the provided chunk before emitting any other value.
@@ -2027,8 +2030,8 @@ export declare const pipeThroughChannelOrFail: {
  * @category utils
  */
 export declare const prepend: {
-    <B>(values: Chunk.Chunk<B>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, B | A>;
-    <R, E, A, B>(self: Stream<R, E, A>, values: Chunk.Chunk<B>): Stream<R, E, A | B>;
+    <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>;
 };
 /**
  * Provides the stream with its required context, which eliminates its
@@ -2038,8 +2041,8 @@ export declare const prepend: {
  * @category context
  */
 export declare const provideContext: {
-    <R>(context: Context.Context<R>): <E, A>(self: Stream<R, E, A>) => Stream<never, E, A>;
-    <E, A, R>(self: Stream<R, E, A>, context: Context.Context<R>): Stream<never, E, A>;
+    <R>(context: Context.Context<R>): <A, E>(self: Stream<A, E, R>) => Stream<A, E>;
+    <A, E, R>(self: Stream<A, E, R>, context: Context.Context<R>): Stream<A, E>;
 };
 /**
  * Provides a `Layer` to the stream, which translates it to another level.
@@ -2048,8 +2051,8 @@ export declare const provideContext: {
  * @category context
  */
 export declare const provideLayer: {
-    <RIn, E2, ROut>(layer: Layer.Layer<RIn, E2, ROut>): <E, A>(self: Stream<ROut, E, A>) => Stream<RIn, E2 | E, A>;
-    <E, A, RIn, E2, ROut>(self: Stream<ROut, E, A>, layer: Layer.Layer<RIn, E2, ROut>): Stream<RIn, E | E2, A>;
+    <RIn, E2, ROut>(layer: Layer.Layer<ROut, E2, RIn>): <A, E>(self: Stream<A, E, ROut>) => Stream<A, E2 | E, RIn>;
+    <A, E, RIn, E2, ROut>(self: Stream<A, E, ROut>, layer: Layer.Layer<ROut, E2, RIn>): Stream<A, E | E2, RIn>;
 };
 /**
  * Provides the stream with the single service it requires. If the stream
@@ -2059,8 +2062,8 @@ export declare const provideLayer: {
  * @category context
  */
 export declare const provideService: {
-    <T extends Context.Tag<any, any>>(tag: T, resource: Context.Tag.Service<T>): <R, E, A>(self: Stream<R, E, A>) => Stream<Exclude<R, Context.Tag.Identifier<T>>, E, A>;
-    <R, E, A, T extends Context.Tag<any, any>>(self: Stream<R, E, A>, tag: T, resource: Context.Tag.Service<T>): Stream<Exclude<R, Context.Tag.Identifier<T>>, E, A>;
+    <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>>>;
 };
 /**
  * Provides the stream with the single service it requires. If the stream
@@ -2070,8 +2073,8 @@ export declare const provideService: {
  * @category context
  */
 export declare const provideServiceEffect: {
-    <T extends Context.Tag<any, any>, R2, E2>(tag: T, effect: Effect.Effect<R2, E2, Context.Tag.Service<T>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | Exclude<R, Context.Tag.Identifier<T>>, E2 | E, A>;
-    <R, E, A, T extends Context.Tag<any, any>, R2, E2>(self: Stream<R, E, A>, tag: T, effect: Effect.Effect<R2, E2, Context.Tag.Service<T>>): Stream<R2 | Exclude<R, Context.Tag.Identifier<T>>, E | E2, A>;
+    <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>>>;
 };
 /**
  * Provides the stream with the single service it requires. If the stream
@@ -2081,8 +2084,8 @@ export declare const provideServiceEffect: {
  * @category context
  */
 export declare const provideServiceStream: {
-    <T extends Context.Tag<any, any>, R2, E2>(tag: T, stream: Stream<R2, E2, Context.Tag.Service<T>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | Exclude<R, Context.Tag.Identifier<T>>, E2 | E, A>;
-    <R, E, A, T extends Context.Tag<any, any>, R2, E2>(self: Stream<R, E, A>, tag: T, stream: Stream<R2, E2, Context.Tag.Service<T>>): Stream<R2 | Exclude<R, Context.Tag.Identifier<T>>, E | E2, A>;
+    <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>>>;
 };
 /**
  * Transforms the context being provided to the stream with the specified
@@ -2092,8 +2095,8 @@ export declare const provideServiceStream: {
  * @category context
  */
 export declare const mapInputContext: {
-    <R0, R>(f: (env: Context.Context<R0>) => Context.Context<R>): <E, A>(self: Stream<R, E, A>) => Stream<R0, E, A>;
-    <E, A, R0, R>(self: Stream<R, E, A>, f: (env: Context.Context<R0>) => Context.Context<R>): Stream<R0, E, A>;
+    <R0, R>(f: (env: Context.Context<R0>) => Context.Context<R>): <A, E>(self: Stream<A, E, R>) => Stream<A, E, R0>;
+    <A, E, R0, R>(self: Stream<A, E, R>, f: (env: Context.Context<R0>) => Context.Context<R>): Stream<A, E, R0>;
 };
 /**
  * Splits the context into two parts, providing one part using the
@@ -2103,8 +2106,8 @@ export declare const mapInputContext: {
  * @category context
  */
 export declare const provideSomeLayer: {
-    <RIn, E2, ROut>(layer: Layer.Layer<RIn, E2, ROut>): <R, E, A>(self: Stream<R, E, A>) => Stream<RIn | Exclude<R, ROut>, E2 | E, A>;
-    <R, E, A, RIn, E2, ROut>(self: Stream<R, E, A>, layer: Layer.Layer<RIn, E2, ROut>): Stream<RIn | Exclude<R, ROut>, E | E2, A>;
+    <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>>;
 };
 /**
  * Constructs a stream from a range of integers, including both endpoints.
@@ -2112,7 +2115,7 @@ export declare const provideSomeLayer: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const range: (min: number, max: number, chunkSize?: number) => Stream<never, never, number>;
+export declare const range: (min: number, max: number, chunkSize?: number) => Stream<number>;
 /**
  * Re-chunks the elements of the stream into chunks of `n` elements each. The
  * last chunk might contain less than `n` elements.
@@ -2121,8 +2124,8 @@ export declare const range: (min: number, max: number, chunkSize?: number) => St
  * @category utils
  */
 export declare const rechunk: {
-    (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>;
+    (n: number): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, n: number): Stream<A, E, R>;
 };
 /**
  * Keeps some of the errors, and terminates the fiber with the rest
@@ -2131,8 +2134,8 @@ export declare const rechunk: {
  * @category error handling
  */
 export declare const refineOrDie: {
-    <E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: Stream<R, E, A>) => Stream<R, E2, A>;
-    <R, A, E, E2>(self: Stream<R, E, A>, pf: (error: E) => Option.Option<E2>): Stream<R, E2, A>;
+    <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>;
 };
 /**
  * Keeps some of the errors, and terminates the fiber with the rest, using the
@@ -2142,8 +2145,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<R, E, A>) => Stream<R, E2, A>;
-    <R, A, E, E2>(self: Stream<R, E, A>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): Stream<R, E2, A>;
+    <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>;
 };
 /**
  * Repeats the entire stream using the specified schedule. The stream will
@@ -2153,8 +2156,8 @@ export declare const refineOrDieWith: {
  * @category utils
  */
 export declare const repeat: {
-    <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
-    <R, E, A, R2, B>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<R | R2, E, A>;
+    <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>;
 };
 /**
  * Creates a stream from an effect producing a value of type `A` which repeats
@@ -2163,7 +2166,7 @@ export declare const repeat: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const repeatEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream<R, E, A>;
+export declare const repeatEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Stream<A, E, R>;
 /**
  * Creates a stream from an effect producing chunks of `A` values which
  * repeats forever.
@@ -2171,7 +2174,7 @@ export declare const repeatEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) =>
  * @since 2.0.0
  * @category constructors
  */
-export declare const repeatEffectChunk: <R, E, A>(effect: Effect.Effect<R, E, Chunk.Chunk<A>>) => Stream<R, E, A>;
+export declare const repeatEffectChunk: <A, E, R>(effect: Effect.Effect<Chunk.Chunk<A>, E, R>) => Stream<A, E, R>;
 /**
  * Creates a stream from an effect producing chunks of `A` values until it
  * fails with `None`.
@@ -2179,7 +2182,7 @@ export declare const repeatEffectChunk: <R, E, A>(effect: Effect.Effect<R, E, Ch
  * @since 2.0.0
  * @category constructors
  */
-export declare const repeatEffectChunkOption: <R, E, A>(effect: Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>>) => Stream<R, E, A>;
+export declare const repeatEffectChunkOption: <A, E, R>(effect: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R>) => Stream<A, E, R>;
 /**
  * Creates a stream from an effect producing values of type `A` until it fails
  * with `None`.
@@ -2187,7 +2190,7 @@ export declare const repeatEffectChunkOption: <R, E, A>(effect: Effect.Effect<R,
  * @since 2.0.0
  * @category constructors
  */
-export declare const repeatEffectOption: <R, E, A>(effect: Effect.Effect<R, Option.Option<E>, A>) => Stream<R, E, A>;
+export declare const repeatEffectOption: <A, E, R>(effect: Effect.Effect<A, Option.Option<E>, R>) => Stream<A, E, R>;
 /**
  * Creates a stream from an effect producing a value of type `A`, which is
  * repeated using the specified schedule.
@@ -2195,7 +2198,7 @@ export declare const repeatEffectOption: <R, E, A>(effect: Effect.Effect<R, Opti
  * @since 2.0.0
  * @category constructors
  */
-export declare const repeatEffectWithSchedule: <R, E, A, A0 extends A, R2, _>(effect: Effect.Effect<R, E, A>, schedule: Schedule.Schedule<R2, A0, _>) => Stream<R | R2, E, A>;
+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>;
 /**
  * Repeats the entire stream using the specified schedule. The stream will
  * execute normally, and then repeat again according to the provided schedule.
@@ -2205,8 +2208,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>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, Either.Either<B, A>>;
-    <R, E, A, R2, B>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<R | R2, E, Either.Either<B, A>>;
+    <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>;
 };
 /**
  * Repeats each element of the stream using the provided schedule. Repetitions
@@ -2219,8 +2222,8 @@ export declare const repeatEither: {
  * @category utils
  */
 export declare const repeatElements: {
-    <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
-    <R, E, A, R2, B>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<R | R2, E, A>;
+    <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>;
 };
 /**
  * Repeats each element of the stream using the provided schedule. When the
@@ -2241,11 +2244,11 @@ export declare const repeatElementsWith: {
     <R2, B, A, C>(schedule: Schedule.Schedule<R2, unknown, B>, options: {
         readonly onElement: (a: A) => C;
         readonly onSchedule: (b: B) => C;
-    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, C>;
-    <R, E, R2, B, A, C>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, unknown, B>, options: {
+    }): <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: {
         readonly onElement: (a: A) => C;
         readonly onSchedule: (b: B) => C;
-    }): Stream<R | R2, E, C>;
+    }): Stream<C, E, R | R2>;
 };
 /**
  * Repeats the provided value infinitely.
@@ -2253,7 +2256,7 @@ export declare const repeatElementsWith: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const repeatValue: <A>(value: A) => Stream<never, never, A>;
+export declare const repeatValue: <A>(value: A) => Stream<A>;
 /**
  * Repeats the entire stream using the specified schedule. The stream will
  * execute normally, and then repeat again according to the provided schedule.
@@ -2267,11 +2270,11 @@ export declare const repeatWith: {
     <R2, B, A, C>(schedule: Schedule.Schedule<R2, unknown, B>, options: {
         readonly onElement: (a: A) => C;
         readonly onSchedule: (b: B) => C;
-    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, C>;
-    <R, E, R2, B, A, C>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, unknown, B>, options: {
+    }): <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: {
         readonly onElement: (a: A) => C;
         readonly onSchedule: (b: B) => C;
-    }): Stream<R | R2, E, C>;
+    }): Stream<C, E, R | R2>;
 };
 /**
  * When the stream fails, retry it according to the given schedule
@@ -2287,8 +2290,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<R, E, A>) => Stream<R2 | R, E, A>;
-    <R, A, R2, E, E0 extends E, _>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, E0, _>): Stream<R | R2, E, A>;
+    <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>;
 };
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
@@ -2297,8 +2300,8 @@ export declare const retry: {
  * @category destructors
  */
 export declare const run: {
-    <R2, E2, A, Z>(sink: Sink.Sink<R2, E2, A, unknown, Z>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, Z>;
-    <R, E, R2, E2, A, Z>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, unknown, Z>): Effect.Effect<R | R2, E | E2, Z>;
+    <A2, A, E2, R2>(sink: Sink.Sink<A2, A, unknown, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<A2, E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<A2, A, unknown, E2, R2>): Effect.Effect<A2, E | E2, R | R2>;
 };
 /**
  * Runs the stream and collects all of its elements to a chunk.
@@ -2306,21 +2309,21 @@ export declare const run: {
  * @since 2.0.0
  * @category destructors
  */
-export declare const runCollect: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>;
+export declare const runCollect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Chunk.Chunk<A>, E, R>;
 /**
  * Runs the stream and emits the number of elements processed
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare const runCount: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, number>;
+export declare const runCount: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<number, E, R>;
 /**
  * Runs the stream only for its effects. The emitted elements are discarded.
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare const runDrain: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, void>;
+export declare const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E, R>;
 /**
  * Executes a pure fold over the stream of values - reduces all elements in
  * the stream to a value of type `S`.
@@ -2329,8 +2332,8 @@ export declare const runDrain: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect
  * @category destructors
  */
 export declare const runFold: {
-    <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R, E, S>;
-    <R, E, S, A>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => S): Effect.Effect<R, E, S>;
+    <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>;
 };
 /**
  * Executes an effectful fold over the stream of values.
@@ -2339,8 +2342,8 @@ export declare const runFold: {
  * @category destructors
  */
 export declare const runFoldEffect: {
-    <S, A, R2, E2>(s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, S>;
-    <R, E, S, A, R2, E2>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): Effect.Effect<R | R2, E | E2, S>;
+    <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>;
 };
 /**
  * Executes a pure fold over the stream of values. Returns a scoped value that
@@ -2350,8 +2353,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<R, E, A>) => Effect.Effect<Scope.Scope | R, E, S>;
-    <R, E, S, A>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => S): Effect.Effect<Scope.Scope | R, E, S>;
+    <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>;
 };
 /**
  * Executes an effectful fold over the stream of values. Returns a scoped
@@ -2361,8 +2364,8 @@ export declare const runFoldScoped: {
  * @category destructors
  */
 export declare const runFoldScopedEffect: {
-    <S, A, R2, E2>(s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, S>;
-    <R, E, S, A, R2, E2>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): Effect.Effect<Scope.Scope | R | R2, E | E2, S>;
+    <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>;
 };
 /**
  * Reduces the elements in the stream to a value of type `S`. Stops the fold
@@ -2372,8 +2375,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<R, E, A>) => Effect.Effect<R, E, S>;
-    <R, E, S, A>(self: Stream<R, E, A>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<R, E, S>;
+    <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>;
 };
 /**
  * Executes an effectful fold over the stream of values. Stops the fold early
@@ -2383,8 +2386,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<R2, E2, S>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, S>;
-    <R, E, S, A, R2, E2>(self: Stream<R, E, A>, s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): Effect.Effect<R | R2, E | E2, S>;
+    <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>;
 };
 /**
  * Executes a pure fold over the stream of values. Returns a scoped value that
@@ -2395,8 +2398,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<R, E, A>) => Effect.Effect<R | Scope.Scope, E, S>;
-    <R, E, S, A>(self: Stream<R, E, A>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<Scope.Scope | R, E, S>;
+    <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>;
 };
 /**
  * Executes an effectful fold over the stream of values. Returns a scoped
@@ -2407,8 +2410,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<R2, E2, S>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, S>;
-    <R, E, S, A, R2, E2>(self: Stream<R, E, A>, s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): Effect.Effect<Scope.Scope | R | R2, E | E2, S>;
+    <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>;
 };
 /**
  * Consumes all elements of the stream, passing them to the specified
@@ -2418,8 +2421,8 @@ export declare const runFoldWhileScopedEffect: {
  * @category destructors
  */
 export declare const runForEach: {
-    <A, R2, E2, _>(f: (a: A) => Effect.Effect<R2, E2, _>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, void>;
-    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, _>): Effect.Effect<R | R2, E | E2, void>;
+    <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>;
 };
 /**
  * Consumes all elements of the stream, passing them to the specified
@@ -2429,8 +2432,8 @@ export declare const runForEach: {
  * @category destructors
  */
 export declare const runForEachChunk: {
-    <A, R2, E2, _>(f: (a: Chunk.Chunk<A>) => Effect.Effect<R2, E2, _>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, void>;
-    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, f: (a: Chunk.Chunk<A>) => Effect.Effect<R2, E2, _>): Effect.Effect<R | R2, E | E2, void>;
+    <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>;
 };
 /**
  * Like `Stream.runForEachChunk`, but returns a scoped effect so the
@@ -2440,8 +2443,8 @@ export declare const runForEachChunk: {
  * @category destructors
  */
 export declare const runForEachChunkScoped: {
-    <A, R2, E2, _>(f: (a: Chunk.Chunk<A>) => Effect.Effect<R2, E2, _>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, void>;
-    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, f: (a: Chunk.Chunk<A>) => Effect.Effect<R2, E2, _>): Effect.Effect<Scope.Scope | R | R2, E | E2, void>;
+    <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>;
 };
 /**
  * Like `Stream.forEach`, but returns a scoped effect so the finalization
@@ -2451,8 +2454,8 @@ export declare const runForEachChunkScoped: {
  * @category destructors
  */
 export declare const runForEachScoped: {
-    <A, R2, E2, _>(f: (a: A) => Effect.Effect<R2, E2, _>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, void>;
-    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, _>): Effect.Effect<Scope.Scope | R | R2, E | E2, void>;
+    <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>;
 };
 /**
  * Consumes elements of the stream, passing them to the specified callback,
@@ -2462,8 +2465,8 @@ export declare const runForEachScoped: {
  * @category destructors
  */
 export declare const runForEachWhile: {
-    <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, void>;
-    <R, E, A, R2, E2>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Effect.Effect<R | R2, E | E2, void>;
+    <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>;
 };
 /**
  * Like `Stream.runForEachWhile`, but returns a scoped effect so the
@@ -2473,8 +2476,8 @@ export declare const runForEachWhile: {
  * @category destructors
  */
 export declare const runForEachWhileScoped: {
-    <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, void>;
-    <R, E, A, R2, E2>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Effect.Effect<Scope.Scope | R | R2, E | E2, void>;
+    <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>;
 };
 /**
  * Runs the stream to completion and yields the first value emitted by it,
@@ -2483,7 +2486,7 @@ export declare const runForEachWhileScoped: {
  * @since 2.0.0
  * @category destructors
  */
-export declare const runHead: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, Option.Option<A>>;
+export declare const runHead: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Option.Option<A>, E, R>;
 /**
  * Publishes elements of this stream to a `PubSub`. Stream failure and ending will
  * also be signalled.
@@ -2492,8 +2495,8 @@ export declare const runHead: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<
  * @category destructors
  */
 export declare const runIntoPubSub: {
-    <E, A>(pubsub: PubSub.PubSub<Take.Take<E, A>>): <R>(self: Stream<R, E, A>) => Effect.Effect<R, never, void>;
-    <R, E, A>(self: Stream<R, E, A>, pubsub: PubSub.PubSub<Take.Take<E, A>>): Effect.Effect<R, never, void>;
+    <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, R>;
+    <A, E, R>(self: Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<A, E>>): Effect.Effect<void, never, R>;
 };
 /**
  * Like `Stream.runIntoPubSub`, but provides the result as a scoped effect to
@@ -2503,8 +2506,8 @@ export declare const runIntoPubSub: {
  * @category destructors
  */
 export declare const runIntoPubSubScoped: {
-    <E, A>(pubsub: PubSub.PubSub<Take.Take<E, A>>): <R>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, void>;
-    <R, E, A>(self: Stream<R, E, A>, pubsub: PubSub.PubSub<Take.Take<E, A>>): Effect.Effect<Scope.Scope | R, never, void>;
+    <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>;
+    <A, E, R>(self: Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<A, E>>): Effect.Effect<void, never, Scope.Scope | R>;
 };
 /**
  * Enqueues elements of this stream into a queue. Stream failure and ending
@@ -2514,8 +2517,8 @@ export declare const runIntoPubSubScoped: {
  * @category destructors
  */
 export declare const runIntoQueue: {
-    <E, A>(queue: Queue.Enqueue<Take.Take<E, A>>): <R>(self: Stream<R, E, A>) => Effect.Effect<R, never, void>;
-    <R, E, A>(self: Stream<R, E, A>, queue: Queue.Enqueue<Take.Take<E, A>>): Effect.Effect<R, never, void>;
+    <A, E>(queue: Queue.Enqueue<Take.Take<A, E>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, R>;
+    <A, E, R>(self: Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<A, E>>): Effect.Effect<void, never, R>;
 };
 /**
  * Like `Stream.runIntoQueue`, but provides the result as a scoped [[ZIO]]
@@ -2525,8 +2528,8 @@ export declare const runIntoQueue: {
  * @category destructors
  */
 export declare const runIntoQueueElementsScoped: {
-    <E, A>(queue: Queue.Enqueue<Exit.Exit<Option.Option<E>, A>>): <R>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, void>;
-    <R, E, A>(self: Stream<R, E, A>, queue: Queue.Enqueue<Exit.Exit<Option.Option<E>, A>>): Effect.Effect<Scope.Scope | R, never, void>;
+    <A, E>(queue: Queue.Enqueue<Exit.Exit<A, Option.Option<E>>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>;
+    <A, E, R>(self: Stream<A, E, R>, queue: Queue.Enqueue<Exit.Exit<A, Option.Option<E>>>): Effect.Effect<void, never, Scope.Scope | R>;
 };
 /**
  * Like `Stream.runIntoQueue`, but provides the result as a scoped effect
@@ -2536,8 +2539,8 @@ export declare const runIntoQueueElementsScoped: {
  * @category destructors
  */
 export declare const runIntoQueueScoped: {
-    <E, A>(queue: Queue.Enqueue<Take.Take<E, A>>): <R>(self: Stream<R, E, A>) => Effect.Effect<R | Scope.Scope, never, void>;
-    <R, E, A>(self: Stream<R, E, A>, queue: Queue.Enqueue<Take.Take<E, A>>): Effect.Effect<Scope.Scope | R, never, void>;
+    <A, E>(queue: Queue.Enqueue<Take.Take<A, E>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>;
+    <A, E, R>(self: Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<A, E>>): Effect.Effect<void, never, Scope.Scope | R>;
 };
 /**
  * Runs the stream to completion and yields the last value emitted by it,
@@ -2546,14 +2549,14 @@ export declare const runIntoQueueScoped: {
  * @since 2.0.0
  * @category destructors
  */
-export declare const runLast: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, Option.Option<A>>;
+export declare const runLast: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Option.Option<A>, E, R>;
 /**
  * @since 2.0.0
  * @category destructors
  */
 export declare const runScoped: {
-    <R2, E2, A, A2>(sink: Sink.Sink<R2, E2, A, unknown, A2>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, A2>;
-    <R, E, R2, E2, A, A2>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, unknown, A2>): Effect.Effect<Scope.Scope | R | R2, E | E2, A2>;
+    <A2, A, E2, R2>(sink: Sink.Sink<A2, A, unknown, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<A2, E2 | E, Scope.Scope | R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<A2, A, unknown, E2, R2>): Effect.Effect<A2, E | E2, Scope.Scope | R | R2>;
 };
 /**
  * Runs the stream to a sink which sums elements, provided they are Numeric.
@@ -2561,7 +2564,7 @@ export declare const runScoped: {
  * @since 2.0.0
  * @category destructors
  */
-export declare const runSum: <R, E>(self: Stream<R, E, number>) => Effect.Effect<R, E, number>;
+export declare const runSum: <R, E>(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.
@@ -2570,8 +2573,8 @@ export declare const runSum: <R, E>(self: Stream<R, E, number>) => Effect.Effect
  * @category utils
  */
 export declare const scan: {
-    <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<R, E, A>) => Stream<R, E, S>;
-    <R, E, S, A>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => S): Stream<R, E, S>;
+    <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>;
 };
 /**
  * Statefully and effectfully maps over the elements of this stream to produce
@@ -2581,8 +2584,8 @@ export declare const scan: {
  * @category utils
  */
 export declare const scanEffect: {
-    <S, A, R2, E2>(s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, S>;
-    <R, E, S, A, R2, E2>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): Stream<R | R2, E | E2, S>;
+    <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>;
 };
 /**
  * Statefully maps over the elements of this stream to produce all
@@ -2594,8 +2597,8 @@ export declare const scanEffect: {
  * @category utils
  */
 export declare const scanReduce: {
-    <A2, A>(f: (a2: A2 | A, a: A) => A2): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2 | A>;
-    <R, E, A2, A>(self: Stream<R, E, A>, f: (a2: A2 | A, a: A) => A2): Stream<R, E, A2 | A>;
+    <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>;
 };
 /**
  * Statefully and effectfully maps over the elements of this stream to produce
@@ -2606,7 +2609,7 @@ 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<R2, E2, A2 | A>) => <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>;
+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>);
 /**
  * Schedules the output of the stream using the provided `schedule`.
  *
@@ -2614,8 +2617,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<R, E, A>) => Stream<R2 | R, E, A>;
-    <R, E, R2, A, A0 extends A, _>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, A0, _>): Stream<R | R2, E, A>;
+    <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>;
 };
 /**
  * Schedules the output of the stream using the provided `schedule` and emits
@@ -2629,11 +2632,11 @@ export declare const scheduleWith: {
     <R2, A, A0 extends A, B, C>(schedule: Schedule.Schedule<R2, A0, B>, options: {
         readonly onElement: (a: A) => C;
         readonly onSchedule: (b: B) => C;
-    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, C>;
-    <R, E, R2, A, A0 extends A, B, C>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, A0, B>, options: {
+    }): <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: {
         readonly onElement: (a: A) => C;
         readonly onSchedule: (b: B) => C;
-    }): Stream<R | R2, E, C>;
+    }): Stream<C, E, R | R2>;
 };
 /**
  * Creates a single-valued stream from a scoped resource.
@@ -2641,7 +2644,7 @@ export declare const scheduleWith: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const scoped: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream<Exclude<R, Scope.Scope>, E, A>;
+export declare const scoped: <A, E, R>(effect: Effect.Effect<A, E, R>) => Stream<A, E, Exclude<R, Scope.Scope>>;
 /**
  * Emits a sliding window of `n` elements.
  *
@@ -2661,8 +2664,8 @@ export declare const scoped: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream
  * @category utils
  */
 export declare const sliding: {
-    (chunkSize: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
-    <R, E, A>(self: Stream<R, E, A>, chunkSize: number): Stream<R, E, Chunk.Chunk<A>>;
+    (chunkSize: number): <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, chunkSize: number): Stream<Chunk.Chunk<A>, E, R>;
 };
 /**
  * Like `sliding`, but with a configurable `stepSize` parameter.
@@ -2671,8 +2674,8 @@ export declare const sliding: {
  * @category utils
  */
 export declare const slidingSize: {
-    (chunkSize: number, stepSize: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
-    <R, E, A>(self: Stream<R, E, A>, chunkSize: number, stepSize: number): Stream<R, E, Chunk.Chunk<A>>;
+    (chunkSize: number, stepSize: number): <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, chunkSize: number, stepSize: number): Stream<Chunk.Chunk<A>, E, R>;
 };
 /**
  * Converts an option on values into an option on errors.
@@ -2680,7 +2683,7 @@ export declare const slidingSize: {
  * @since 2.0.0
  * @category utils
  */
-export declare const some: <R, E, A>(self: Stream<R, E, Option.Option<A>>) => Stream<R, Option.Option<E>, A>;
+export declare const some: <A, E, R>(self: Stream<Option.Option<A>, E, R>) => Stream<A, Option.Option<E>, R>;
 /**
  * Extracts the optional value, or returns the given 'default'.
  *
@@ -2688,8 +2691,8 @@ export declare const some: <R, E, A>(self: Stream<R, E, Option.Option<A>>) => St
  * @category utils
  */
 export declare const someOrElse: {
-    <A2>(fallback: LazyArg<A2>): <R, E, A>(self: Stream<R, E, Option.Option<A>>) => Stream<R, E, A2 | A>;
-    <R, E, A, A2>(self: Stream<R, E, Option.Option<A>>, fallback: LazyArg<A2>): Stream<R, E, A | A2>;
+    <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>;
 };
 /**
  * Extracts the optional value, or fails with the given error 'e'.
@@ -2698,8 +2701,8 @@ export declare const someOrElse: {
  * @category utils
  */
 export declare const someOrFail: {
-    <E2>(error: LazyArg<E2>): <R, E, A>(self: Stream<R, E, Option.Option<A>>) => Stream<R, E2 | E, A>;
-    <R, E, A, E2>(self: Stream<R, E, Option.Option<A>>, error: LazyArg<E2>): Stream<R, E | E2, A>;
+    <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>;
 };
 /**
  * Splits elements based on a predicate.
@@ -2720,8 +2723,8 @@ export declare const someOrFail: {
  * @category utils
  */
 export declare const split: {
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
-    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, Chunk.Chunk<A>>;
+    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(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>;
 };
 /**
  * Splits elements on a delimiter and transforms the splits into desired output.
@@ -2730,8 +2733,8 @@ export declare const split: {
  * @category utils
  */
 export declare const splitOnChunk: {
-    <A>(delimiter: Chunk.Chunk<A>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
-    <R, E, A>(self: Stream<R, E, A>, delimiter: Chunk.Chunk<A>): Stream<R, E, Chunk.Chunk<A>>;
+    <A>(delimiter: Chunk.Chunk<A>): <R, E>(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>;
 };
 /**
  * Splits strings on newlines. Handles both Windows newlines (`\r\n`) and UNIX
@@ -2740,28 +2743,28 @@ export declare const splitOnChunk: {
  * @since 2.0.0
  * @category combinators
  */
-export declare const splitLines: <R, E>(self: Stream<R, E, string>) => Stream<R, E, string>;
+export declare const splitLines: <R, E>(self: Stream<string, E, R>) => Stream<string, E, R>;
 /**
  * Creates a single-valued pure stream.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const succeed: <A>(value: A) => Stream<never, never, A>;
+export declare const succeed: <A>(value: A) => Stream<A>;
 /**
  * Creates a single-valued pure stream.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const sync: <A>(evaluate: LazyArg<A>) => Stream<never, never, A>;
+export declare const sync: <A>(evaluate: LazyArg<A>) => Stream<A>;
 /**
  * Returns a lazily constructed stream.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const suspend: <R, E, A>(stream: LazyArg<Stream<R, E, A>>) => Stream<R, E, A>;
+export declare const suspend: <A, E, R>(stream: LazyArg<Stream<A, E, R>>) => Stream<A, E, R>;
 /**
  * Takes the specified number of elements from this stream.
  *
@@ -2769,8 +2772,8 @@ export declare const suspend: <R, E, A>(stream: LazyArg<Stream<R, E, A>>) => Str
  * @category utils
  */
 export declare const take: {
-    (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>;
+    (n: number): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, n: number): Stream<A, E, R>;
 };
 /**
  * Takes the last specified number of elements from this stream.
@@ -2779,8 +2782,8 @@ export declare const take: {
  * @category utils
  */
 export declare const takeRight: {
-    (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>;
+    (n: number): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, n: number): Stream<A, E, R>;
 };
 /**
  * Takes all elements of the stream until the specified predicate evaluates to
@@ -2790,8 +2793,8 @@ export declare const takeRight: {
  * @category utils
  */
 export declare const takeUntil: {
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
+    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
  * Takes all elements of the stream until the specified effectual predicate
@@ -2801,8 +2804,8 @@ export declare const takeUntil: {
  * @category utils
  */
 export declare const takeUntilEffect: {
-    <A, R2, E2>(predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2>(self: Stream<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Takes all elements of the stream for as long as the specified predicate
@@ -2812,10 +2815,10 @@ export declare const takeUntilEffect: {
  * @category utils
  */
 export declare const takeWhile: {
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
-    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>;
-    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
+    <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, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
  * Adds an effect to consumption of every element of the stream.
@@ -2824,8 +2827,8 @@ export declare const takeWhile: {
  * @category sequencing
  */
 export declare const tap: {
-    <A, R2, E2, _>(f: (a: NoInfer<A>) => Effect.Effect<R2, E2, _>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, f: (a: NoInfer<A>) => Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Returns a stream that effectfully "peeks" at the failure or success of
@@ -2836,13 +2839,13 @@ export declare const tap: {
  */
 export declare const tapBoth: {
     <E, R2, E2, X1, A, R3, E3, X2>(options: {
-        readonly onFailure: (e: NoInfer<E>) => Effect.Effect<R2, E2, X1>;
-        readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<R3, E3, X2>;
-    }): <R>(self: Stream<R, E, A>) => Stream<R | R2 | R3, E | E2 | E3, A>;
-    <R, E, A, R2, E2, X1, R3, E3, X2>(self: Stream<R, E, A>, options: {
-        readonly onFailure: (e: NoInfer<E>) => Effect.Effect<R2, E2, X1>;
-        readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<R3, E3, X2>;
-    }): Stream<R | R2 | R3, E | E2 | E3, A>;
+        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: {
+        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>;
 };
 /**
  * Returns a stream that effectfully "peeks" at the failure of the stream.
@@ -2851,8 +2854,8 @@ export declare const tapBoth: {
  * @category sequencing
  */
 export declare const tapError: {
-    <E, R2, E2, _>(f: (error: NoInfer<E>) => Effect.Effect<R2, E2, _>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>;
-    <R, A, E, R2, E2, _>(self: Stream<R, E, A>, f: (error: E) => Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Returns a stream that effectfully "peeks" at the cause of failure of the
@@ -2862,8 +2865,8 @@ export declare const tapError: {
  * @category utils
  */
 export declare const tapErrorCause: {
-    <E, R2, E2, _>(f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<R2, E2, _>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>;
-    <R, A, E, R2, E2, _>(self: Stream<R, E, A>, f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Sends all elements emitted by this stream to the specified sink in addition
@@ -2873,8 +2876,8 @@ export declare const tapErrorCause: {
  * @category sequencing
  */
 export declare const tapSink: {
-    <R2, E2, A>(sink: Sink.Sink<R2, E2, A, unknown, unknown>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, R2, E2, A>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, unknown, unknown>): Stream<R | R2, E | E2, A>;
+    <A, E2, R2>(sink: Sink.Sink<unknown, A, unknown, 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>, sink: Sink.Sink<unknown, A, unknown, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
  * Delays the chunks of this stream according to the given bandwidth
@@ -2899,14 +2902,14 @@ export declare const throttle: {
         readonly duration: Duration.DurationInput;
         readonly burst?: number | undefined;
         readonly strategy?: "enforce" | "shape" | undefined;
-    }): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, options: {
+    }): <R, E>(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;
         readonly duration: Duration.DurationInput;
         readonly burst?: number | undefined;
         readonly strategy?: "enforce" | "shape" | undefined;
-    }): Stream<R, E, A>;
+    }): Stream<A, E, R>;
 };
 /**
  * Delays the chunks of this stream according to the given bandwidth
@@ -2926,19 +2929,19 @@ export declare const throttle: {
  */
 export declare const throttleEffect: {
     <A, R2, E2>(options: {
-        readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, number>;
+        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<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2>(self: Stream<R, E, A>, options: {
-        readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, number>;
+    }): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
+    <R, E, A, R2, E2>(self: Stream<A, E, R>, 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;
-    }): Stream<R | R2, E | E2, A>;
+    }): Stream<A, E | E2, R | R2>;
 };
 /**
  * A stream that emits Unit values spaced by the specified duration.
@@ -2946,7 +2949,7 @@ export declare const throttleEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const tick: (interval: Duration.DurationInput) => Stream<never, never, void>;
+export declare const tick: (interval: Duration.DurationInput) => Stream<void>;
 /**
  * Ends the stream if it does not produce a value after the specified duration.
  *
@@ -2954,8 +2957,8 @@ export declare const tick: (interval: Duration.DurationInput) => Stream<never, n
  * @category utils
  */
 export declare const timeout: {
-    (duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, duration: Duration.DurationInput): Stream<R, E, A>;
+    (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>;
 };
 /**
  * Fails the stream with given error if it does not produce a value after d
@@ -2965,8 +2968,8 @@ export declare const timeout: {
  * @category utils
  */
 export declare const timeoutFail: {
-    <E2>(error: LazyArg<E2>, duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, A>;
-    <R, E, A, E2>(self: Stream<R, E, A>, error: LazyArg<E2>, duration: Duration.DurationInput): Stream<R, E | E2, A>;
+    <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>;
 };
 /**
  * Fails the stream with given cause if it does not produce a value after d
@@ -2976,8 +2979,8 @@ export declare const timeoutFail: {
  * @category utils
  */
 export declare const timeoutFailCause: {
-    <E2>(cause: LazyArg<Cause.Cause<E2>>, duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, A>;
-    <R, E, A, E2>(self: Stream<R, E, A>, cause: LazyArg<Cause.Cause<E2>>, duration: Duration.DurationInput): Stream<R, E | E2, A>;
+    <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>;
 };
 /**
  * Switches the stream if it does not produce a value after the specified
@@ -2987,8 +2990,8 @@ export declare const timeoutFailCause: {
  * @category utils
  */
 export declare const timeoutTo: {
-    <R2, E2, A2>(duration: Duration.DurationInput, that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, duration: Duration.DurationInput, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A | A2>;
+    <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>;
 };
 /**
  * Converts the stream to a scoped `PubSub` of chunks. After the scope is closed,
@@ -2998,8 +3001,8 @@ export declare const timeoutTo: {
  * @category destructors
  */
 export declare const toPubSub: {
-    (capacity: number): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, PubSub.PubSub<Take.Take<E, A>>>;
-    <R, E, A>(self: Stream<R, E, A>, capacity: number): Effect.Effect<Scope.Scope | R, never, PubSub.PubSub<Take.Take<E, A>>>;
+    (capacity: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>;
+    <A, E, R>(self: Stream<A, E, R>, capacity: number): Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>;
 };
 /**
  * Returns in a scope a ZIO effect that can be used to repeatedly pull chunks
@@ -3010,7 +3013,7 @@ export declare const toPubSub: {
  * @since 2.0.0
  * @category destructors
  */
-export declare const toPull: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>>>;
+export declare const toPull: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R>, never, Scope.Scope | R>;
 /**
  * Converts the stream to a scoped queue of chunks. After the scope is closed,
  * the queue will never again produce values and should be discarded.
@@ -3026,13 +3029,13 @@ export declare const toQueue: {
         readonly capacity?: number | undefined;
     } | {
         readonly strategy: "unbounded";
-    }): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Queue.Dequeue<Take.Take<E, A>>>;
-    <R, E, A>(self: Stream<R, E, A>, options?: {
+    } | undefined): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope | R>;
+    <A, E, R>(self: Stream<A, E, R>, options?: {
         readonly strategy?: "dropping" | "sliding" | "suspend" | undefined;
         readonly capacity?: number | undefined;
     } | {
         readonly strategy: "unbounded";
-    }): Effect.Effect<Scope.Scope | R, never, Queue.Dequeue<Take.Take<E, A>>>;
+    } | undefined): Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope | R>;
 };
 /**
  * Converts the stream to a scoped queue of elements. After the scope is
@@ -3046,10 +3049,10 @@ export declare const toQueue: {
 export declare const toQueueOfElements: {
     (options?: {
         readonly capacity?: number | undefined;
-    }): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>>;
-    <R, E, A>(self: Stream<R, E, A>, options?: {
+    } | undefined): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, never, Scope.Scope | R>;
+    <A, E, R>(self: Stream<A, E, R>, options?: {
         readonly capacity?: number | undefined;
-    }): Effect.Effect<Scope.Scope | R, never, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>>;
+    } | undefined): Effect.Effect<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, never, Scope.Scope | R>;
 };
 /**
  * Converts the stream to a `ReadableStream`.
@@ -3059,7 +3062,7 @@ export declare const toQueueOfElements: {
  * @since 2.0.0
  * @category destructors
  */
-export declare const toReadableStream: <E, A>(source: Stream<never, E, A>) => ReadableStream<A>;
+export declare const toReadableStream: <A, E>(source: Stream<A, E>) => ReadableStream<A>;
 /**
  * Applies the transducer to the stream and emits its outputs.
  *
@@ -3067,8 +3070,8 @@ export declare const toReadableStream: <E, A>(source: Stream<never, E, A>) => Re
  * @category utils
  */
 export declare const transduce: {
-    <R2, E2, A, Z>(sink: Sink.Sink<R2, E2, A, A, Z>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, Z>;
-    <R, E, R2, E2, A, Z>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, A, Z>): Stream<R | R2, E | E2, Z>;
+    <A2, A, E2, R2>(sink: Sink.Sink<A2, A, A, 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>, sink: Sink.Sink<A2, A, A, E2, R2>): Stream<A2, E | E2, R | R2>;
 };
 /**
  * Creates a stream by peeling off the "layers" of a value of type `S`.
@@ -3076,14 +3079,14 @@ export declare const transduce: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const unfold: <S, A>(s: S, f: (s: S) => Option.Option<readonly [A, S]>) => Stream<never, never, A>;
+export declare const unfold: <S, A>(s: S, f: (s: S) => Option.Option<readonly [A, S]>) => Stream<A>;
 /**
  * Creates a stream by peeling off the "layers" of a value of type `S`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const unfoldChunk: <S, A>(s: S, f: (s: S) => Option.Option<readonly [Chunk.Chunk<A>, S]>) => Stream<never, never, A>;
+export declare const unfoldChunk: <S, A>(s: S, f: (s: S) => Option.Option<readonly [Chunk.Chunk<A>, S]>) => Stream<A>;
 /**
  * Creates a stream by effectfully peeling off the "layers" of a value of type
  * `S`.
@@ -3091,7 +3094,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<R, E, Option.Option<readonly [Chunk.Chunk<A>, S]>>) => Stream<R, E, A>;
+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>;
 /**
  * Creates a stream by effectfully peeling off the "layers" of a value of type
  * `S`.
@@ -3099,35 +3102,35 @@ 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<R, E, Option.Option<readonly [A, S]>>) => Stream<R, E, A>;
+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>;
 /**
  * A stream that contains a single `Unit` value.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const unit: Stream<never, never, void>;
+export declare const unit: Stream<void>;
 /**
  * Creates a stream produced from an `Effect`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const unwrap: <R, E, R2, E2, A>(effect: Effect.Effect<R, E, Stream<R2, E2, A>>) => Stream<R | R2, E | E2, A>;
+export declare const unwrap: <R, E, R2, E2, A>(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<R, E, Stream<R2, E2, A>>) => Stream<R2 | Exclude<R, Scope.Scope>, E | E2, A>;
+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>>;
 /**
  * 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>) => <R, E, A>(self: Stream<R, E, A>) => Stream<T | R, E, A>) & (<R_1, E_1, A_1, T_1 extends Context.Tag<any, any>>(self: Stream<R_1, E_1, A_1>, tag: T_1, f: (service: Context.Tag.Service<T_1>) => Context.Tag.Service<T_1>) => Stream<R_1 | T_1, E_1, A_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>) & (<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>);
 /**
  * Returns the specified stream if the given condition is satisfied, otherwise
  * returns an empty stream.
@@ -3136,8 +3139,8 @@ export declare const updateService: (<T extends Context.Tag<any, any>>(tag: T, f
  * @category utils
  */
 export declare const when: {
-    (test: LazyArg<boolean>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, test: LazyArg<boolean>): Stream<R, E, A>;
+    (test: LazyArg<boolean>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, test: LazyArg<boolean>): Stream<A, E, R>;
 };
 /**
  * Returns the resulting stream when the given `PartialFunction` is defined
@@ -3146,7 +3149,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<R, E, A2>>) => Stream<R, E, A2>;
+export declare const whenCase: <A, R, E, A2>(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.
@@ -3155,8 +3158,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<R2, E2, A2>>): <R, E>(self: Effect.Effect<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Effect.Effect<R, E, A>, pf: (a: A) => Option.Option<Stream<R2, E2, A2>>): Stream<R | R2, E | E2, A2>;
+    <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>;
 };
 /**
  * Returns the stream if the given effectful condition is satisfied, otherwise
@@ -3166,8 +3169,8 @@ export declare const whenCaseEffect: {
  * @category utils
  */
 export declare const whenEffect: {
-    <R2, E2>(effect: Effect.Effect<R2, E2, boolean>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2>(self: Stream<R, E, A>, effect: Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Wraps the stream with a new span for tracing.
@@ -3182,14 +3185,14 @@ export declare const withSpan: {
         readonly parent?: Tracer.ParentSpan | undefined;
         readonly root?: boolean | undefined;
         readonly context?: Context.Context<never> | undefined;
-    }): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, name: string, options?: {
+    } | undefined): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, Tracer.ParentSpan>>;
+    <A, E, R>(self: Stream<A, E, R>, name: string, options?: {
         readonly attributes?: Record<string, unknown> | undefined;
         readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
         readonly parent?: Tracer.ParentSpan | undefined;
         readonly root?: boolean | undefined;
         readonly context?: Context.Context<never> | undefined;
-    }): Stream<R, E, A>;
+    } | undefined): Stream<A, E, Exclude<R, Tracer.ParentSpan>>;
 };
 /**
  * Zips this stream with another point-wise and emits tuples of elements from
@@ -3201,8 +3204,8 @@ export declare const withSpan: {
  * @category zipping
  */
 export declare const zip: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, [A, A2]>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, [A, A2]>;
+    <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>;
 };
 /**
  * Zips this stream with another point-wise and emits tuples of elements from
@@ -3214,8 +3217,8 @@ export declare const zip: {
  * @category zipping
  */
 export declare const zipFlatten: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A extends ReadonlyArray<any>>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, [...A, A2]>;
-    <R, E, A extends ReadonlyArray<any>, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, [...A, A2]>;
+    <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>;
 };
 /**
  * Zips this stream with another point-wise, creating a new stream of pairs of
@@ -3229,15 +3232,15 @@ export declare const zipFlatten: {
  */
 export declare const zipAll: {
     <R2, E2, A2, A>(options: {
-        readonly other: Stream<R2, E2, A2>;
+        readonly other: Stream<A2, E2, R2>;
         readonly defaultSelf: A;
         readonly defaultOther: A2;
-    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, [A, A2]>;
-    <R, E, R2, E2, A2, A>(self: Stream<R, E, A>, options: {
-        readonly other: Stream<R2, E2, 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: {
+        readonly other: Stream<A2, E2, R2>;
         readonly defaultSelf: A;
         readonly defaultOther: A2;
-    }): Stream<R | R2, E | E2, [A, A2]>;
+    }): Stream<[A, A2], E | E2, R | R2>;
 };
 /**
  * Zips this stream with another point-wise, and keeps only elements from this
@@ -3250,8 +3253,8 @@ export declare const zipAll: {
  * @category zipping
  */
 export declare const zipAllLeft: {
-    <R2, E2, A2, A>(that: Stream<R2, E2, A2>, defaultLeft: A): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, R2, E2, A2, A>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, defaultLeft: A): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Zips this stream with another point-wise, and keeps only elements from the
@@ -3264,8 +3267,8 @@ export declare const zipAllLeft: {
  * @category zipping
  */
 export declare const zipAllRight: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>, defaultRight: A2): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, defaultRight: A2): Stream<R | R2, E | E2, A2>;
+    <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>;
 };
 /**
  * Zips this stream that is sorted by distinct keys and the specified stream
@@ -3283,17 +3286,17 @@ export declare const zipAllRight: {
  */
 export declare const zipAllSortedByKey: {
     <R2, E2, A2, A, K>(options: {
-        readonly other: Stream<R2, E2, readonly [K, A2]>;
+        readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly defaultSelf: A;
         readonly defaultOther: A2;
         readonly order: Order.Order<K>;
-    }): <R, E>(self: Stream<R, E, readonly [K, A]>) => Stream<R2 | R, E2 | E, [K, [A, A2]]>;
-    <R, E, R2, E2, A2, A, K>(self: Stream<R, E, readonly [K, A]>, options: {
-        readonly other: Stream<R2, E2, readonly [K, A2]>;
+    }): <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: {
+        readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly defaultSelf: A;
         readonly defaultOther: A2;
         readonly order: Order.Order<K>;
-    }): Stream<R | R2, E | E2, [K, [A, A2]]>;
+    }): Stream<[K, [A, A2]], E | E2, R | R2>;
 };
 /**
  * Zips this stream that is sorted by distinct keys and the specified stream
@@ -3310,15 +3313,15 @@ export declare const zipAllSortedByKey: {
  */
 export declare const zipAllSortedByKeyLeft: {
     <R2, E2, A2, A, K>(options: {
-        readonly other: Stream<R2, E2, readonly [K, A2]>;
+        readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly defaultSelf: A;
         readonly order: Order.Order<K>;
-    }): <R, E>(self: Stream<R, E, readonly [K, A]>) => Stream<R2 | R, E2 | E, [K, A]>;
-    <R, E, R2, E2, A2, A, K>(self: Stream<R, E, readonly [K, A]>, options: {
-        readonly other: Stream<R2, E2, readonly [K, A2]>;
+    }): <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: {
+        readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly defaultSelf: A;
         readonly order: Order.Order<K>;
-    }): Stream<R | R2, E | E2, [K, A]>;
+    }): Stream<[K, A], E | E2, R | R2>;
 };
 /**
  * Zips this stream that is sorted by distinct keys and the specified stream
@@ -3335,15 +3338,15 @@ export declare const zipAllSortedByKeyLeft: {
  */
 export declare const zipAllSortedByKeyRight: {
     <R2, E2, A2, K>(options: {
-        readonly other: Stream<R2, E2, readonly [K, A2]>;
+        readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly defaultOther: A2;
         readonly order: Order.Order<K>;
-    }): <R, E, A>(self: Stream<R, E, readonly [K, A]>) => Stream<R2 | R, E2 | E, [K, A2]>;
-    <R, E, A, R2, E2, A2, K>(self: Stream<R, E, readonly [K, A]>, options: {
-        readonly other: Stream<R2, E2, readonly [K, A2]>;
+    }): <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: {
+        readonly other: Stream<readonly [K, A2], E2, R2>;
         readonly defaultOther: A2;
         readonly order: Order.Order<K>;
-    }): Stream<R | R2, E | E2, [K, A2]>;
+    }): Stream<[K, A2], E | E2, R | R2>;
 };
 /**
  * Zips this stream that is sorted by distinct keys and the specified stream
@@ -3361,19 +3364,19 @@ export declare const zipAllSortedByKeyRight: {
  */
 export declare const zipAllSortedByKeyWith: {
     <R2, E2, A, A3, A2, K>(options: {
-        readonly other: Stream<R2, E2, readonly [K, A2]>;
+        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<R, E, readonly [K, A]>) => Stream<R2 | R, E2 | E, [K, A3]>;
-    <R, E, R2, E2, A, A3, A2, K>(self: Stream<R, E, readonly [K, A]>, options: {
-        readonly other: Stream<R2, E2, readonly [K, A2]>;
+    }): <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: {
+        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>;
-    }): Stream<R | R2, E | E2, [K, A3]>;
+    }): Stream<[K, A3], E | E2, R | R2>;
 };
 /**
  * Zips this stream with another point-wise. The provided functions will be
@@ -3387,17 +3390,17 @@ export declare const zipAllSortedByKeyWith: {
  */
 export declare const zipAllWith: {
     <R2, E2, A2, A, A3>(options: {
-        readonly other: Stream<R2, E2, A2>;
+        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<R, E, A>) => Stream<R2 | R, E2 | E, A3>;
-    <R, E, R2, E2, A2, A, A3>(self: Stream<R, E, A>, options: {
-        readonly other: Stream<R2, E2, 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>, options: {
+        readonly other: Stream<A2, E2, R2>;
         readonly onSelf: (a: A) => A3;
         readonly onOther: (a2: A2) => A3;
         readonly onBoth: (a: A, a2: A2) => A3;
-    }): Stream<R | R2, E | E2, A3>;
+    }): Stream<A3, E | E2, R | R2>;
 };
 /**
  * Zips the two streams so that when a value is emitted by either of the two
@@ -3412,8 +3415,8 @@ export declare const zipAllWith: {
  * @category zipping
  */
 export declare const zipLatest: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, [A, A2]>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, [A, A2]>;
+    <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>;
 };
 /**
  * Zips the two streams so that when a value is emitted by either of the two
@@ -3428,8 +3431,8 @@ export declare const zipLatest: {
  * @category zipping
  */
 export declare const zipLatestWith: {
-    <R2, E2, A2, A, A3>(that: Stream<R2, E2, A2>, f: (a: A, a2: A2) => A3): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A3>;
-    <R, E, R2, E2, A2, A, A3>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, f: (a: A, a2: A2) => A3): Stream<R | R2, E | E2, A3>;
+    <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>;
 };
 /**
  * Zips this stream with another point-wise, but keeps only the outputs of
@@ -3441,8 +3444,8 @@ export declare const zipLatestWith: {
  * @category zipping
  */
 export declare const zipLeft: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A>;
+    <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>;
 };
 /**
  * Zips this stream with another point-wise, but keeps only the outputs of the
@@ -3454,8 +3457,8 @@ export declare const zipLeft: {
  * @category zipping
  */
 export declare const zipRight: {
-    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
-    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A2>;
+    <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>;
 };
 /**
  * Zips this stream with another point-wise and applies the function to the
@@ -3467,8 +3470,8 @@ export declare const zipRight: {
  * @category zipping
  */
 export declare const zipWith: {
-    <R2, E2, A2, A, A3>(that: Stream<R2, E2, A2>, f: (a: A, a2: A2) => A3): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A3>;
-    <R, E, R2, E2, A2, A, A3>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, f: (a: A, a2: A2) => A3): Stream<R | R2, E | E2, A3>;
+    <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>;
 };
 /**
  * Zips this stream with another point-wise and applies the function to the
@@ -3480,8 +3483,8 @@ export declare const zipWith: {
  * @category zipping
  */
 export declare const zipWithChunks: {
-    <R2, E2, A2, A, A3>(that: Stream<R2, E2, A2>, 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<R, E, A>) => Stream<R2 | R, E2 | E, A3>;
-    <R, E, R2, E2, A2, A, A3>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, f: (left: Chunk.Chunk<A>, right: Chunk.Chunk<A2>) => readonly [Chunk.Chunk<A3>, Either.Either<Chunk.Chunk<A>, Chunk.Chunk<A2>>]): Stream<R | R2, E | E2, A3>;
+    <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>;
 };
 /**
  * Zips each element with the next element if present.
@@ -3489,7 +3492,7 @@ export declare const zipWithChunks: {
  * @since 2.0.0
  * @category zipping
  */
-export declare const zipWithNext: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, [A, Option.Option<A>]>;
+export declare const zipWithNext: <A, E, R>(self: Stream<A, E, R>) => Stream<[A, Option.Option<A>], E, R>;
 /**
  * Zips each element with the previous element. Initially accompanied by
  * `None`.
@@ -3497,26 +3500,26 @@ export declare const zipWithNext: <R, E, A>(self: Stream<R, E, A>) => Stream<R,
  * @since 2.0.0
  * @category zipping
  */
-export declare const zipWithPrevious: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, [Option.Option<A>, A]>;
+export declare const zipWithPrevious: <A, E, R>(self: Stream<A, E, R>) => Stream<[Option.Option<A>, A], E, R>;
 /**
  * Zips each element with both the previous and next element.
  *
  * @since 2.0.0
  * @category zipping
  */
-export declare const zipWithPreviousAndNext: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, [Option.Option<A>, A, Option.Option<A>]>;
+export declare const zipWithPreviousAndNext: <A, E, R>(self: Stream<A, E, R>) => Stream<[Option.Option<A>, A, Option.Option<A>], E, R>;
 /**
  * Zips this stream together with the index of elements.
  *
  * @since 2.0.0
  * @category zipping
  */
-export declare const zipWithIndex: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, [A, number]>;
+export declare const zipWithIndex: <A, E, R>(self: Stream<A, E, R>) => Stream<[A, number], E, R>;
 /**
  * @since 2.0.0
  * @category do notation
  */
-export declare const Do: Stream<never, never, {}>;
+export declare const Do: Stream<{}>;
 /**
  * Binds a value from a stream in a `do` scope
  *
@@ -3524,18 +3527,18 @@ export declare const Do: Stream<never, never, {}>;
  * @category do notation
  */
 export declare const bind: {
-    <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => Stream<R2, E2, A>, options?: {
+    <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => Stream<A, E2, R2>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
-    }): <R, E>(self: Stream<R, E, K>) => Stream<R2 | R, E2 | E, Effect.MergeRecord<K, {
+    } | undefined): <R, E>(self: Stream<K, E, R>) => Stream<Effect.MergeRecord<K, {
         [k in N]: A;
-    }>>;
-    <R, E, N extends string, K, R2, E2, A>(self: Stream<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => Stream<R2, E2, A>, options?: {
+    }>, 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?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
-    }): Stream<R | R2, E | E2, Effect.MergeRecord<K, {
+    } | undefined): Stream<Effect.MergeRecord<K, {
         [k in N]: A;
-    }>>;
+    }>, E | E2, R | R2>;
 };
 /**
  * Binds an effectful value in a `do` scope
@@ -3544,34 +3547,34 @@ 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<R2, E2, A>, options?: {
+    <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => Effect.Effect<A, E2, R2>, options?: {
         readonly concurrency?: number | "unbounded" | undefined;
         readonly bufferSize?: number | undefined;
-    }): <R, E>(self: Stream<R, E, K>) => Stream<R2 | R, E2 | E, Effect.MergeRecord<K, {
+    } | undefined): <R, E>(self: Stream<K, E, R>) => Stream<Effect.MergeRecord<K, {
         [k in N]: A;
-    }>>;
-    <R, E, N extends string, K, R2, E2, A>(self: Stream<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => Effect.Effect<R2, E2, A>, options?: {
+    }>, 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?: {
         readonly concurrency?: number | "unbounded" | undefined;
-        readonly bufferSize?: number | undefined;
-    }): Stream<R | R2, E | E2, Effect.MergeRecord<K, {
+        readonly unordered?: boolean | undefined;
+    } | undefined): Stream<Effect.MergeRecord<K, {
         [k in N]: A;
-    }>>;
+    }>, E | E2, R | R2>;
 };
 /**
  * @since 2.0.0
  * @category do notation
  */
 export declare const bindTo: {
-    <N extends string>(tag: N): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Record<N, A>>;
-    <R, E, A, N extends string>(self: Stream<R, E, A>, tag: N): Stream<R, E, Record<N, A>>;
+    <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>;
 };
 declare const let_: {
-    <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <R, E>(self: Stream<R, E, K>) => Stream<R, E, Effect.MergeRecord<K, {
+    <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <R, E>(self: Stream<K, E, R>) => Stream<Effect.MergeRecord<K, {
         [k in N]: A;
-    }>>;
-    <R, E, K, N extends string, A>(self: Stream<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => A): Stream<R, E, Effect.MergeRecord<K, {
+    }>, 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 in N]: A;
-    }>>;
+    }>, E, R>;
 };
 export { 
 /**
@@ -3588,8 +3591,8 @@ let_ as let };
  * @category encoding
  */
 export declare const decodeText: {
-    (encoding?: string): <R, E>(self: Stream<R, E, Uint8Array>) => Stream<R, E, string>;
-    <R, E>(self: Stream<R, E, Uint8Array>, encoding?: string): Stream<R, E, string>;
+    (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>;
 };
 /**
  * Encode a stream of strings into a stream of Uint8Array chunks using the specified encoding.
@@ -3597,5 +3600,5 @@ export declare const decodeText: {
  * @since 2.0.0
  * @category encoding
  */
-export declare const encodeText: <R, E>(self: Stream<R, E, string>) => Stream<R, E, Uint8Array>;
+export declare const encodeText: <R, E>(self: Stream<string, E, R>) => Stream<Uint8Array, E, R>;
 //# sourceMappingURL=Stream.d.ts.map