effect 2.2.5 → 2.3.1

package/dist/dts/Sink.d.ts

@@ -32,16 +32,16 @@ export declare const SinkTypeId: unique symbol;
  */
 export type SinkTypeId = typeof SinkTypeId;
 /**
- * A `Sink<R, E, In, L, Z>` is used to consume elements produced by a `Stream`.
+ * A `Sink<A, In, L, E, R>` is used to consume elements produced by a `Stream`.
  * You can think of a sink as a function that will consume a variable amount of
  * `In` elements (could be 0, 1, or many), might fail with an error of type `E`,
- * and will eventually yield a value of type `Z` together with a remainder of
+ * and will eventually yield a value of type `A` together with a remainder of
  * type `L` (i.e. any leftovers).
  *
  * @since 2.0.0
  * @category models
  */
-export interface Sink<out R, out E, in In, out L, out Z> extends Sink.Variance<R, E, In, L, Z>, Pipeable {
+export interface Sink<out A, in In = unknown, out L = never, out E = never, out R = never> extends Sink.Variance<A, In, L, E, R>, Pipeable {
 }
 /**
  * @since 2.0.0
@@ -50,7 +50,7 @@ export interface Sink<out R, out E, in In, out L, out Z> extends Sink.Variance<R
 export interface SinkUnify<A extends {
     [Unify.typeSymbol]?: any;
 }> extends Effect.EffectUnify<A> {
-    Sink?: () => A[Unify.typeSymbol] extends Sink<infer R, infer E, infer In, infer L, infer Z> | infer _ ? Sink<R, E, In, L, Z> : never;
+    Sink?: () => A[Unify.typeSymbol] extends Sink<infer A, infer In, infer L, infer E, infer R> | infer _ ? Sink<A, In, L, E, R> : never;
 }
 /**
  * @category models
@@ -64,7 +64,7 @@ export interface SinkUnifyIgnore extends Effect.EffectUnifyIgnore {
  * @category models
  */
 declare module "./Effect.js" {
-    interface Effect<R, E, A> extends Sink<R, E, unknown, never, A> {
+    interface Effect<A, E, R> extends Sink<A, unknown, never, E, R> {
     }
     interface EffectUnifyIgnore {
         Sink?: true;
@@ -78,19 +78,19 @@ export declare namespace Sink {
      * @since 2.0.0
      * @category models
      */
-    interface Variance<out R, out E, in In, out L, out Z> {
-        readonly [SinkTypeId]: VarianceStruct<R, E, In, L, Z>;
+    interface Variance<out A, in In, out L, out E, out R> {
+        readonly [SinkTypeId]: VarianceStruct<A, In, L, E, R>;
     }
     /**
      * @since 2.0.0
      * @category models
      */
-    interface VarianceStruct<out R, out E, in In, out L, out Z> {
-        _R: Types.Covariant<R>;
-        _E: Types.Covariant<E>;
+    interface VarianceStruct<out A, in In, out L, out E, out R> {
+        _A: Types.Covariant<A>;
         _In: Types.Contravariant<In>;
         _L: Types.Covariant<L>;
-        _Z: Types.Covariant<Z>;
+        _E: Types.Covariant<E>;
+        _R: Types.Covariant<R>;
     }
 }
 /**
@@ -100,8 +100,8 @@ export declare namespace Sink {
  * @category mapping
  */
 export declare const as: {
-    <Z2>(z: Z2): <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, L, Z2>;
-    <R, E, In, L, Z, Z2>(self: Sink<R, E, In, L, Z>, z: Z2): Sink<R, E, In, L, Z2>;
+    <A2>(a: A2): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E, R>;
+    <A, In, L, E, R, A2>(self: Sink<A, In, L, E, R>, a: A2): Sink<A2, In, L, E, R>;
 };
 /**
  * A sink that collects all elements into a `Chunk`.
@@ -109,21 +109,21 @@ export declare const as: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const collectAll: <In>() => Sink<never, never, In, never, Chunk.Chunk<In>>;
+export declare const collectAll: <In>() => Sink<Chunk.Chunk<In>, In>;
 /**
  * A sink that collects first `n` elements into a chunk.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const collectAllN: <In>(n: number) => Sink<never, never, In, In, Chunk.Chunk<In>>;
+export declare const collectAllN: <In>(n: number) => Sink<Chunk.Chunk<In>, In, In>;
 /**
  * Repeatedly runs the sink and accumulates its results into a `Chunk`.
  *
  * @since 2.0.0
  * @category utils
  */
-export declare const collectAllFrom: <R, E, In, L extends In, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, L, Chunk.Chunk<Z>>;
+export declare const collectAllFrom: <A, In, L extends In, E, R>(self: Sink<A, In, L, E, R>) => Sink<Chunk.Chunk<A>, In, L, E, R>;
 /**
  * A sink that collects all of its inputs into a map. The keys are extracted
  * from inputs using the keying function `key`; if multiple inputs use the
@@ -132,7 +132,7 @@ export declare const collectAllFrom: <R, E, In, L extends In, Z>(self: Sink<R, E
  * @since 2.0.0
  * @category constructors
  */
-export declare const collectAllToMap: <In, K>(key: (input: In) => K, merge: (x: In, y: In) => In) => Sink<never, never, In, never, HashMap.HashMap<K, In>>;
+export declare const collectAllToMap: <In, K>(key: (input: In) => K, merge: (x: In, y: In) => In) => Sink<HashMap.HashMap<K, In>, In>;
 /**
  * A sink that collects first `n` keys into a map. The keys are calculated
  * from inputs using the keying function `key`; if multiple inputs use the the
@@ -141,21 +141,21 @@ export declare const collectAllToMap: <In, K>(key: (input: In) => K, merge: (x:
  * @since 2.0.0
  * @category constructors
  */
-export declare const collectAllToMapN: <In, K>(n: number, key: (input: In) => K, merge: (x: In, y: In) => In) => Sink<never, never, In, In, HashMap.HashMap<K, In>>;
+export declare const collectAllToMapN: <In, K>(n: number, key: (input: In) => K, merge: (x: In, y: In) => In) => Sink<HashMap.HashMap<K, In>, In, In>;
 /**
  * A sink that collects all of its inputs into a set.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const collectAllToSet: <In>() => Sink<never, never, In, never, HashSet.HashSet<In>>;
+export declare const collectAllToSet: <In>() => Sink<HashSet.HashSet<In>, In>;
 /**
  * A sink that collects first `n` distinct inputs into a set.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const collectAllToSetN: <In>(n: number) => Sink<never, never, In, In, HashSet.HashSet<In>>;
+export declare const collectAllToSetN: <In>(n: number) => Sink<HashSet.HashSet<In>, In, In>;
 /**
  * Accumulates incoming elements into a chunk until predicate `p` is
  * satisfied.
@@ -163,7 +163,7 @@ export declare const collectAllToSetN: <In>(n: number) => Sink<never, never, In,
  * @since 2.0.0
  * @category constructors
  */
-export declare const collectAllUntil: <In>(p: Predicate<In>) => Sink<never, never, In, In, Chunk.Chunk<In>>;
+export declare const collectAllUntil: <In>(p: Predicate<In>) => Sink<Chunk.Chunk<In>, In, In>;
 /**
  * Accumulates incoming elements into a chunk until effectful predicate `p` is
  * satisfied.
@@ -171,7 +171,7 @@ export declare const collectAllUntil: <In>(p: Predicate<In>) => Sink<never, neve
  * @since 2.0.0
  * @category constructors
  */
-export declare const collectAllUntilEffect: <In, R, E>(p: (input: In) => Effect.Effect<R, E, boolean>) => Sink<R, E, In, In, Chunk.Chunk<In>>;
+export declare const collectAllUntilEffect: <In, E, R>(p: (input: In) => Effect.Effect<boolean, E, R>) => Sink<Chunk.Chunk<In>, In, In, E, R>;
 /**
  * Accumulates incoming elements into a chunk as long as they verify predicate
  * `p`.
@@ -180,8 +180,8 @@ export declare const collectAllUntilEffect: <In, R, E>(p: (input: In) => Effect.
  * @category constructors
  */
 export declare const collectAllWhile: {
-    <In, Out extends In>(refinement: Refinement<In, Out>): Sink<never, never, In, In, Chunk.Chunk<Out>>;
-    <In>(predicate: Predicate<In>): Sink<never, never, In, In, Chunk.Chunk<In>>;
+    <In, Out extends In>(refinement: Refinement<In, Out>): Sink<Chunk.Chunk<Out>, In, In>;
+    <In>(predicate: Predicate<In>): Sink<Chunk.Chunk<In>, In, In>;
 };
 /**
  * Accumulates incoming elements into a chunk as long as they verify effectful
@@ -190,7 +190,7 @@ export declare const collectAllWhile: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const collectAllWhileEffect: <In, R, E>(predicate: (input: In) => Effect.Effect<R, E, boolean>) => Sink<R, E, In, In, Chunk.Chunk<In>>;
+export declare const collectAllWhileEffect: <In, E, R>(predicate: (input: In) => Effect.Effect<boolean, E, R>) => Sink<Chunk.Chunk<In>, In, In, E, R>;
 /**
  * Repeatedly runs the sink for as long as its results satisfy the predicate
  * `p`. The sink's results will be accumulated using the stepping function `f`.
@@ -199,16 +199,16 @@ export declare const collectAllWhileEffect: <In, R, E>(predicate: (input: In) =>
  * @category utils
  */
 export declare const collectAllWhileWith: {
-    <Z, S>(options: {
+    <A, S>(options: {
         readonly initial: S;
-        readonly while: Predicate<Z>;
-        readonly body: (s: S, z: Z) => S;
-    }): <R, E, In, L extends In>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, L, S>;
-    <R, E, In, L extends In, Z, S>(self: Sink<R, E, In, L, Z>, options: {
+        readonly while: Predicate<A>;
+        readonly body: (s: S, a: A) => S;
+    }): <In, L extends In, E, R>(self: Sink<A, In, L, E, R>) => Sink<S, In, L, E, R>;
+    <A, In, L extends In, E, R, S>(self: Sink<A, In, L, E, R>, options: {
         readonly initial: S;
-        readonly while: Predicate<Z>;
-        readonly body: (s: S, z: Z) => S;
-    }): Sink<R, E, In, L, S>;
+        readonly while: Predicate<A>;
+        readonly body: (s: S, a: A) => S;
+    }): Sink<S, In, L, E, R>;
 };
 /**
  * Collects the leftovers from the stream when the sink succeeds and returns
@@ -217,21 +217,27 @@ export declare const collectAllWhileWith: {
  * @since 2.0.0
  * @category utils
  */
-export declare const collectLeftover: <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, never, [Z, Chunk.Chunk<L>]>;
+export declare const collectLeftover: <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, Chunk.Chunk<L>], In, never, E, R>;
 /**
  * Transforms this sink's input elements.
  *
  * @since 2.0.0
  * @category mapping
  */
-export declare const mapInput: (<In0, In>(f: (input: In0) => In) => <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In0, L, Z>) & (<R_1, E_1, L_1, Z_1, In0_1, In_1>(self: Sink<R_1, E_1, In_1, L_1, Z_1>, f: (input: In0_1) => In_1) => Sink<R_1, E_1, In0_1, L_1, Z_1>);
+export declare const mapInput: {
+    <In0, In>(f: (input: In0) => In): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E, R>;
+    <A, In, L, E, R, In0>(self: Sink<A, In, L, E, R>, f: (input: In0) => In): Sink<A, In0, L, E, R>;
+};
 /**
  * Effectfully transforms this sink's input elements.
  *
  * @since 2.0.0
  * @category mapping
  */
-export declare const mapInputEffect: (<In0, R2, E2, In>(f: (input: In0) => Effect.Effect<R2, E2, In>) => <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In0, L, Z>) & (<R_1, E_1, L_1, Z_1, In0_1, R2_1, E2_1, In_1>(self: Sink<R_1, E_1, In_1, L_1, Z_1>, f: (input: In0_1) => Effect.Effect<R2_1, E2_1, In_1>) => Sink<R_1 | R2_1, E_1 | E2_1, In0_1, L_1, Z_1>);
+export declare const mapInputEffect: {
+    <In0, In, E2, R2>(f: (input: In0) => Effect.Effect<In, E2, R2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>;
+    <A, In, L, E, R, In0, E2, R2>(self: Sink<A, In, L, E, R>, f: (input: In0) => Effect.Effect<In, E2, R2>): Sink<A, In0, L, E | E2, R | R2>;
+};
 /**
  * Transforms this sink's input chunks. `f` must preserve chunking-invariance.
  *
@@ -239,8 +245,8 @@ export declare const mapInputEffect: (<In0, R2, E2, In>(f: (input: In0) => Effec
  * @category mapping
  */
 export declare const mapInputChunks: {
-    <In0, In>(f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>): <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In0, L, Z>;
-    <R, E, L, Z, In0, In>(self: Sink<R, E, In, L, Z>, f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>): Sink<R, E, In0, L, Z>;
+    <In0, In>(f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E, R>;
+    <A, In, L, E, R, In0>(self: Sink<A, In, L, E, R>, f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>): Sink<A, In0, L, E, R>;
 };
 /**
  * Effectfully transforms this sink's input chunks. `f` must preserve
@@ -250,8 +256,8 @@ export declare const mapInputChunks: {
  * @category mapping
  */
 export declare const mapInputChunksEffect: {
-    <In0, R2, E2, In>(f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>): <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In0, L, Z>;
-    <R, E, L, Z, In0, R2, E2, In>(self: Sink<R, E, In, L, Z>, f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>): Sink<R | R2, E | E2, In0, L, Z>;
+    <In0, In, E2, R2>(f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>;
+    <A, In, L, E, R, In0, E2, R2>(self: Sink<A, In, L, E, R>, f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>): Sink<A, In0, L, E | E2, R | R2>;
 };
 /**
  * A sink that counts the number of elements fed to it.
@@ -259,14 +265,14 @@ export declare const mapInputChunksEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const count: Sink<never, never, unknown, never, number>;
+export declare const count: Sink<number, unknown>;
 /**
  * Creates a sink halting with the specified defect.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const die: (defect: unknown) => Sink<never, never, unknown, never, never>;
+export declare const die: (defect: unknown) => Sink<never, unknown>;
 /**
  * Creates a sink halting with the specified message, wrapped in a
  * `RuntimeException`.
@@ -274,14 +280,14 @@ export declare const die: (defect: unknown) => Sink<never, never, unknown, never
  * @since 2.0.0
  * @category constructors
  */
-export declare const dieMessage: (message: string) => Sink<never, never, unknown, never, never>;
+export declare const dieMessage: (message: string) => Sink<never, unknown>;
 /**
  * Creates a sink halting with the specified defect.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const dieSync: (evaluate: LazyArg<unknown>) => Sink<never, never, unknown, never, never>;
+export declare const dieSync: (evaluate: LazyArg<unknown>) => Sink<never, unknown>;
 /**
  * Transforms both inputs and result of this sink using the provided
  * functions.
@@ -290,14 +296,14 @@ export declare const dieSync: (evaluate: LazyArg<unknown>) => Sink<never, never,
  * @category mapping
  */
 export declare const dimap: {
-    <In0, In, Z, Z2>(options: {
+    <In0, In, A, A2>(options: {
         readonly onInput: (input: In0) => In;
-        readonly onDone: (z: Z) => Z2;
-    }): <R, E, L>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In0, L, Z2>;
-    <R, E, L, In0, In, Z, Z2>(self: Sink<R, E, In, L, Z>, options: {
+        readonly onDone: (a: A) => A2;
+    }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E, R>;
+    <A, In, L, E, R, In0, A2>(self: Sink<A, In, L, E, R>, options: {
         readonly onInput: (input: In0) => In;
-        readonly onDone: (z: Z) => Z2;
-    }): Sink<R, E, In0, L, Z2>;
+        readonly onDone: (a: A) => A2;
+    }): Sink<A2, In0, L, E, R>;
 };
 /**
  * Effectfully transforms both inputs and result of this sink using the
@@ -307,14 +313,14 @@ export declare const dimap: {
  * @category mapping
  */
 export declare const dimapEffect: {
-    <In0, R2, E2, In, Z, R3, E3, Z2>(options: {
-        readonly onInput: (input: In0) => Effect.Effect<R2, E2, In>;
-        readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>;
-    }): <R, E, L>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R3 | R, E2 | E3 | E, In0, L, Z2>;
-    <R, E, L, In0, R2, E2, In, Z, R3, E3, Z2>(self: Sink<R, E, In, L, Z>, options: {
-        readonly onInput: (input: In0) => Effect.Effect<R2, E2, In>;
-        readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>;
-    }): Sink<R | R2 | R3, E | E2 | E3, In0, L, Z2>;
+    <In0, R2, E2, In, A, R3, E3, A2>(options: {
+        readonly onInput: (input: In0) => Effect.Effect<In, E2, R2>;
+        readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
+    }): <R, E, L>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>;
+    <A, In, L, E, R, In0, E2, R2, A2, E3, R3>(self: Sink<A, In, L, E, R>, options: {
+        readonly onInput: (input: In0) => Effect.Effect<In, E2, R2>;
+        readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
+    }): Sink<A2, In0, L, E | E2 | E3, R | R2 | R3>;
 };
 /**
  * Transforms both input chunks and result of this sink using the provided
@@ -324,14 +330,14 @@ export declare const dimapEffect: {
  * @category mapping
  */
 export declare const dimapChunks: {
-    <In0, In, Z, Z2>(options: {
+    <In0, In, A, A2>(options: {
         readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>;
-        readonly onDone: (z: Z) => Z2;
-    }): <R, E, L>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In0, L, Z2>;
-    <R, E, L, In0, In, Z, Z2>(self: Sink<R, E, In, L, Z>, options: {
+        readonly onDone: (a: A) => A2;
+    }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E, R>;
+    <A, In, L, E, R, In0, A2>(self: Sink<A, In, L, E, R>, options: {
         readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>;
-        readonly onDone: (z: Z) => Z2;
-    }): Sink<R, E, In0, L, Z2>;
+        readonly onDone: (a: A) => A2;
+    }): Sink<A2, In0, L, E, R>;
 };
 /**
  * Effectfully transforms both input chunks and result of this sink using the
@@ -341,14 +347,14 @@ export declare const dimapChunks: {
  * @category mapping
  */
 export declare const dimapChunksEffect: {
-    <In0, R2, E2, In, Z, R3, E3, Z2>(options: {
-        readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>;
-        readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>;
-    }): <R, E, L>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R3 | R, E2 | E3 | E, In0, L, Z2>;
-    <R, E, L, In0, R2, E2, In, Z, R3, E3, Z2>(self: Sink<R, E, In, L, Z>, options: {
-        readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>;
-        readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>;
-    }): Sink<R | R2 | R3, E | E2 | E3, In0, L, Z2>;
+    <In0, In, E2, R2, A, A2, E3, R3>(options: {
+        readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>;
+        readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
+    }): <R, E, L>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>;
+    <A, In, L, E, R, In0, E2, R2, A2, E3, R3>(self: Sink<A, In, L, E, R>, options: {
+        readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>;
+        readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
+    }): Sink<A2, In0, L, E | E2 | E3, R | R2 | R3>;
 };
 /**
  * A sink that ignores its inputs.
@@ -356,42 +362,42 @@ export declare const dimapChunksEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const drain: Sink<never, never, unknown, never, void>;
+export declare const drain: Sink<void, unknown>;
 /**
  * Creates a sink that drops `n` elements.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const drop: <In>(n: number) => Sink<never, never, In, In, unknown>;
+export declare const drop: <In>(n: number) => Sink<unknown, In, In>;
 /**
  * Drops incoming elements until the predicate is satisfied.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const dropUntil: <In>(predicate: Predicate<In>) => Sink<never, never, In, In, unknown>;
+export declare const dropUntil: <In>(predicate: Predicate<In>) => Sink<unknown, In, In>;
 /**
  * Drops incoming elements until the effectful predicate is satisfied.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const dropUntilEffect: <In, R, E>(predicate: (input: In) => Effect.Effect<R, E, boolean>) => Sink<R, E, In, In, unknown>;
+export declare const dropUntilEffect: <In, E, R>(predicate: (input: In) => Effect.Effect<boolean, E, R>) => Sink<unknown, In, In, E, R>;
 /**
  * Drops incoming elements as long as the predicate is satisfied.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const dropWhile: <In>(predicate: Predicate<In>) => Sink<never, never, In, In, unknown>;
+export declare const dropWhile: <In>(predicate: Predicate<In>) => Sink<unknown, In, In>;
 /**
  * Drops incoming elements as long as the effectful predicate is satisfied.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const dropWhileEffect: <In, R, E>(predicate: (input: In) => Effect.Effect<R, E, boolean>) => Sink<R, E, In, In, unknown>;
+export declare const dropWhileEffect: <In, E, R>(predicate: (input: In) => Effect.Effect<boolean, E, R>) => Sink<unknown, In, In, E, R>;
 /**
  * Returns a new sink with an attached finalizer. The finalizer is guaranteed
  * to be executed so long as the sink begins execution (and regardless of
@@ -401,8 +407,8 @@ export declare const dropWhileEffect: <In, R, E>(predicate: (input: In) => Effec
  * @category finalization
  */
 export declare const ensuring: {
-    <R2, _>(finalizer: Effect.Effect<R2, never, _>): <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E, In, L, Z>;
-    <R, E, In, L, Z, R2, _>(self: Sink<R, E, In, L, Z>, finalizer: Effect.Effect<R2, never, _>): Sink<R | R2, E, In, L, Z>;
+    <_, R2>(finalizer: Effect.Effect<_, never, R2>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>;
+    <A, In, L, E, R, _, R2>(self: Sink<A, In, L, E, R>, finalizer: Effect.Effect<_, never, R2>): Sink<A, In, L, E, R | R2>;
 };
 /**
  * Returns a new sink with an attached finalizer. The finalizer is guaranteed
@@ -413,8 +419,8 @@ export declare const ensuring: {
  * @category finalization
  */
 export declare const ensuringWith: {
-    <E, Z, R2, _>(finalizer: (exit: Exit.Exit<E, Z>) => Effect.Effect<R2, never, _>): <R, In, L>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E, In, L, Z>;
-    <R, In, L, E, Z, R2, _>(self: Sink<R, E, In, L, Z>, finalizer: (exit: Exit.Exit<E, Z>) => Effect.Effect<R2, never, _>): Sink<R | R2, E, In, L, Z>;
+    <A, E, _, R2>(finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<_, never, R2>): <In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>;
+    <A, In, L, E, R, _, R2>(self: Sink<A, In, L, E, R>, finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<_, never, R2>): Sink<A, In, L, E, R | R2>;
 };
 /**
  * Accesses the whole context of the sink.
@@ -422,63 +428,63 @@ export declare const ensuringWith: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const context: <R>() => Sink<R, never, unknown, never, Context.Context<R>>;
+export declare const context: <R>() => Sink<Context.Context<R>, unknown, never, never, R>;
 /**
  * Accesses the context of the sink.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const contextWith: <R, Z>(f: (context: Context.Context<R>) => Z) => Sink<R, never, unknown, never, Z>;
+export declare const contextWith: <R, Z>(f: (context: Context.Context<R>) => Z) => Sink<Z, unknown, never, never, R>;
 /**
  * Accesses the context of the sink in the context of an effect.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const contextWithEffect: <R, R2, E, Z>(f: (context: Context.Context<R>) => Effect.Effect<R2, E, Z>) => Sink<R | R2, E, unknown, never, Z>;
+export declare const contextWithEffect: <R0, A, E, R>(f: (context: Context.Context<R0>) => Effect.Effect<A, E, R>) => Sink<A, unknown, never, E, R0 | R>;
 /**
  * Accesses the context of the sink in the context of a sink.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const contextWithSink: <R0, R, E, In, L, Z>(f: (context: Context.Context<R0>) => Sink<R, E, In, L, Z>) => Sink<R0 | R, E, In, L, Z>;
+export declare const contextWithSink: <R0, A, In, L, E, R>(f: (context: Context.Context<R0>) => Sink<A, In, L, E, R>) => Sink<A, In, L, E, R0 | R>;
 /**
  * A sink that returns whether all elements satisfy the specified predicate.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const every: <In>(predicate: Predicate<In>) => Sink<never, never, In, In, boolean>;
+export declare const every: <In>(predicate: Predicate<In>) => Sink<boolean, In, In>;
 /**
  * A sink that always fails with the specified error.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fail: <E>(e: E) => Sink<never, E, unknown, never, never>;
+export declare const fail: <E>(e: E) => Sink<never, unknown, never, E>;
 /**
  * A sink that always fails with the specified lazily evaluated error.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const failSync: <E>(evaluate: LazyArg<E>) => Sink<never, E, unknown, never, never>;
+export declare const failSync: <E>(evaluate: LazyArg<E>) => Sink<never, unknown, never, E>;
 /**
  * Creates a sink halting with a specified `Cause`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const failCause: <E>(cause: Cause.Cause<E>) => Sink<never, E, unknown, never, never>;
+export declare const failCause: <E>(cause: Cause.Cause<E>) => Sink<never, unknown, never, E>;
 /**
  * Creates a sink halting with a specified lazily evaluated `Cause`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Sink<never, E, unknown, never, never>;
+export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Sink<never, unknown, never, E>;
 /**
  * Filters the sink's input with the given predicate.
  *
@@ -486,8 +492,8 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Si
  * @category filtering
  */
 export declare const filterInput: {
-    <In, In1 extends In, In2 extends In1>(f: Refinement<In1, In2>): <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In2, L, Z>;
-    <In, In1 extends In>(f: Predicate<In1>): <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In1, L, Z>;
+    <In, In1 extends In, In2 extends In1>(f: Refinement<In1, In2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In2, L, E, R>;
+    <In, In1 extends In>(f: Predicate<In1>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In1, L, E, R>;
 };
 /**
  * Effectfully filter the input of this sink using the specified predicate.
@@ -496,8 +502,8 @@ export declare const filterInput: {
  * @category filtering
  */
 export declare const filterInputEffect: {
-    <R2, E2, In, In1 extends In>(f: (input: In1) => Effect.Effect<R2, E2, boolean>): <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In1, L, Z>;
-    <R, E, L, Z, R2, E2, In, In1 extends In>(self: Sink<R, E, In, L, Z>, f: (input: In1) => Effect.Effect<R2, E2, boolean>): Sink<R | R2, E | E2, In1, L, Z>;
+    <In, In1 extends In, E2, R2>(f: (input: In1) => Effect.Effect<boolean, E2, R2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In1, L, E2 | E, R2 | R>;
+    <A, In, L, E, R, In1 extends In, E2, R2>(self: Sink<A, In, L, E, R>, f: (input: In1) => Effect.Effect<boolean, E2, R2>): Sink<A, In1, L, E | E2, R | R2>;
 };
 /**
  * Creates a sink that produces values until one verifies the predicate `f`.
@@ -506,8 +512,8 @@ export declare const filterInputEffect: {
  * @category elements
  */
 export declare const findEffect: {
-    <Z, R2, E2>(f: (z: Z) => Effect.Effect<R2, E2, boolean>): <R, E, In, L extends In>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In, L, Option.Option<Z>>;
-    <R, E, In, L extends In, Z, R2, E2>(self: Sink<R, E, In, L, Z>, f: (z: Z) => Effect.Effect<R2, E2, boolean>): Sink<R | R2, E | E2, In, L, Option.Option<Z>>;
+    <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <In, L extends In, E, R>(self: Sink<A, In, L, E, R>) => Sink<Option.Option<A>, In, L, E2 | E, R2 | R>;
+    <A, In, L extends In, E, R, E2, R2>(self: Sink<A, In, L, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Sink<Option.Option<A>, In, L, E | E2, R | R2>;
 };
 /**
  * A sink that folds its inputs with the provided function, termination
@@ -516,7 +522,7 @@ export declare const findEffect: {
  * @since 2.0.0
  * @category folding
  */
-export declare const fold: <S, In>(s: S, contFn: Predicate<S>, f: (z: S, input: In) => S) => Sink<never, never, In, In, S>;
+export declare const fold: <S, In>(s: S, contFn: Predicate<S>, f: (s: S, input: In) => S) => Sink<S, In, In>;
 /**
  * Folds over the result of the sink
  *
@@ -524,14 +530,14 @@ export declare const fold: <S, In>(s: S, contFn: Predicate<S>, f: (z: S, input:
  * @category folding
  */
 export declare const foldSink: {
-    <R1, R2, E, E1, E2, In, In1 extends In, In2 extends In, L, L1, L2, Z, Z1, Z2>(options: {
-        readonly onFailure: (err: E) => Sink<R1, E1, In1, L1, Z1>;
-        readonly onSuccess: (z: Z) => Sink<R2, E2, In2, L2, Z2>;
-    }): <R>(self: Sink<R, E, In, L, Z>) => Sink<R1 | R2 | R, E1 | E2, In1 & In2, L1 | L2, Z1 | Z2>;
-    <R, R1, R2, E, E1, E2, In, In1 extends In, In2 extends In, L, L1, L2, Z, Z1, Z2>(self: Sink<R, E, In, L, Z>, options: {
-        readonly onFailure: (err: E) => Sink<R1, E1, In1, L1, Z1>;
-        readonly onSuccess: (z: Z) => Sink<R2, E2, In2, L2, Z2>;
-    }): Sink<R | R1 | R2, E1 | E2, In1 & In2, L1 | L2, Z1 | Z2>;
+    <E, A1, In, In1 extends In, L1, E1, R1, A, A2, In2 extends In, L2, E2, R2>(options: {
+        readonly onFailure: (err: E) => Sink<A1, In1, L1, E1, R1>;
+        readonly onSuccess: (a: A) => Sink<A2, In2, L2, E2, R2>;
+    }): <L, R>(self: Sink<A, In, L, E, R>) => Sink<A1 | A2, In1 & In2, L1 | L2, E1 | E2, R1 | R2 | R>;
+    <A, In, L, E, R, A1, In1 extends In, L1, E1, R1, A2, In2 extends In, L2, E2, R2>(self: Sink<A, In, L, E, R>, options: {
+        readonly onFailure: (err: E) => Sink<A1, In1, L1, E1, R1>;
+        readonly onSuccess: (a: A) => Sink<A2, In2, L2, E2, R2>;
+    }): Sink<A1 | A2, In1 & In2, L1 | L2, E1 | E2, R | R1 | R2>;
 };
 /**
  * A sink that folds its input chunks with the provided function, termination
@@ -542,7 +548,7 @@ export declare const foldSink: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const foldChunks: <S, In>(s: S, contFn: Predicate<S>, f: (s: S, chunk: Chunk.Chunk<In>) => S) => Sink<never, never, In, never, S>;
+export declare const foldChunks: <S, In>(s: S, contFn: Predicate<S>, f: (s: S, chunk: Chunk.Chunk<In>) => S) => Sink<S, In>;
 /**
  * A sink that effectfully folds its input chunks with the provided function,
  * termination predicate and initial state. `contFn` condition is checked only
@@ -552,7 +558,7 @@ export declare const foldChunks: <S, In>(s: S, contFn: Predicate<S>, f: (s: S, c
  * @since 2.0.0
  * @category constructors
  */
-export declare const foldChunksEffect: <S, R, E, In>(s: S, contFn: Predicate<S>, f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<R, E, S>) => Sink<R, E, In, In, S>;
+export declare const foldChunksEffect: <S, In, E, R>(s: S, contFn: Predicate<S>, f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<S, E, R>) => Sink<S, In, In, E, R>;
 /**
  * A sink that effectfully folds its inputs with the provided function,
  * termination predicate and initial state.
@@ -560,14 +566,14 @@ export declare const foldChunksEffect: <S, R, E, In>(s: S, contFn: Predicate<S>,
  * @since 2.0.0
  * @category constructors
  */
-export declare const foldEffect: <S, R, E, In>(s: S, contFn: Predicate<S>, f: (s: S, input: In) => Effect.Effect<R, E, S>) => Sink<R, E, In, In, S>;
+export declare const foldEffect: <S, In, E, R>(s: S, contFn: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>) => Sink<S, In, In, E, R>;
 /**
  * A sink that folds its inputs with the provided function and initial state.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const foldLeft: <S, In>(s: S, f: (s: S, input: In) => S) => Sink<never, never, In, never, S>;
+export declare const foldLeft: <S, In>(s: S, f: (s: S, input: In) => S) => Sink<S, In>;
 /**
  * A sink that folds its input chunks with the provided function and initial
  * state. `f` must preserve chunking-invariance.
@@ -575,7 +581,7 @@ export declare const foldLeft: <S, In>(s: S, f: (s: S, input: In) => S) => Sink<
  * @since 2.0.0
  * @category constructors
  */
-export declare const foldLeftChunks: <S, In>(s: S, f: (s: S, chunk: Chunk.Chunk<In>) => S) => Sink<never, never, In, never, S>;
+export declare const foldLeftChunks: <S, In>(s: S, f: (s: S, chunk: Chunk.Chunk<In>) => S) => Sink<S, In>;
 /**
  * A sink that effectfully folds its input chunks with the provided function
  * and initial state. `f` must preserve chunking-invariance.
@@ -583,7 +589,7 @@ export declare const foldLeftChunks: <S, In>(s: S, f: (s: S, chunk: Chunk.Chunk<
  * @since 2.0.0
  * @category constructors
  */
-export declare const foldLeftChunksEffect: <S, R, E, In>(s: S, f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<R, E, S>) => Sink<R, E, In, never, S>;
+export declare const foldLeftChunksEffect: <S, In, E, R>(s: S, f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<S, E, R>) => Sink<S, In, never, E, R>;
 /**
  * A sink that effectfully folds its inputs with the provided function and
  * initial state.
@@ -591,7 +597,7 @@ export declare const foldLeftChunksEffect: <S, R, E, In>(s: S, f: (s: S, chunk:
  * @since 2.0.0
  * @category constructors
  */
-export declare const foldLeftEffect: <S, R, E, In>(s: S, f: (s: S, input: In) => Effect.Effect<R, E, S>) => Sink<R, E, In, In, S>;
+export declare const foldLeftEffect: <S, In, E, R>(s: S, f: (s: S, input: In) => Effect.Effect<S, E, R>) => Sink<S, In, In, E, R>;
 /**
  * Creates a sink that folds elements of type `In` into a structure of type
  * `S` until `max` elements have been folded.
@@ -601,7 +607,7 @@ export declare const foldLeftEffect: <S, R, E, In>(s: S, f: (s: S, input: In) =>
  * @since 2.0.0
  * @category constructors
  */
-export declare const foldUntil: <In, S>(s: S, max: number, f: (z: S, input: In) => S) => Sink<never, never, In, In, S>;
+export declare const foldUntil: <In, S>(s: S, max: number, f: (s: S, input: In) => S) => Sink<S, In, In>;
 /**
  * Creates a sink that effectfully folds elements of type `In` into a
  * structure of type `S` until `max` elements have been folded.
@@ -611,7 +617,7 @@ export declare const foldUntil: <In, S>(s: S, max: number, f: (z: S, input: In)
  * @since 2.0.0
  * @category constructors
  */
-export declare const foldUntilEffect: <S, R, E, In>(s: S, max: number, f: (s: S, input: In) => Effect.Effect<R, E, S>) => Sink<R, E, In, In, S>;
+export declare const foldUntilEffect: <S, In, E, R>(s: S, max: number, f: (s: S, input: In) => Effect.Effect<S, E, R>) => Sink<S, In, In, E, R>;
 /**
  * Creates a sink that folds elements of type `In` into a structure of type
  * `S`, until `max` worth of elements (determined by the `costFn`) have been
@@ -630,7 +636,7 @@ export declare const foldWeighted: <S, In>(options: {
     readonly maxCost: number;
     readonly cost: (s: S, input: In) => number;
     readonly body: (s: S, input: In) => S;
-}) => Sink<never, never, In, In, S>;
+}) => Sink<S, In, In>;
 /**
  * Creates a sink that folds elements of type `In` into a structure of type
  * `S`, until `max` worth of elements (determined by the `costFn`) have been
@@ -674,7 +680,7 @@ export declare const foldWeightedDecompose: <S, In>(options: {
     readonly cost: (s: S, input: In) => number;
     readonly decompose: (input: In) => Chunk.Chunk<In>;
     readonly body: (s: S, input: In) => S;
-}) => Sink<never, never, In, In, S>;
+}) => Sink<S, In, In>;
 /**
  * Creates a sink that effectfully folds elements of type `In` into a
  * structure of type `S`, until `max` worth of elements (determined by the
@@ -692,13 +698,13 @@ export declare const foldWeightedDecompose: <S, In>(options: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const foldWeightedDecomposeEffect: <S, In, R, E, R2, E2, R3, E3>(options: {
+export declare const foldWeightedDecomposeEffect: <S, In, E, R, E2, R2, E3, R3>(options: {
     readonly initial: S;
     readonly maxCost: number;
-    readonly cost: (s: S, input: In) => Effect.Effect<R, E, number>;
-    readonly decompose: (input: In) => Effect.Effect<R2, E2, Chunk.Chunk<In>>;
-    readonly body: (s: S, input: In) => Effect.Effect<R3, E3, S>;
-}) => Sink<R | R2 | R3, E | E2 | E3, In, In, S>;
+    readonly cost: (s: S, input: In) => Effect.Effect<number, E, R>;
+    readonly decompose: (input: In) => Effect.Effect<Chunk.Chunk<In>, E2, R2>;
+    readonly body: (s: S, input: In) => Effect.Effect<S, E3, R3>;
+}) => Sink<S, In, In, E | E2 | E3, R | R2 | R3>;
 /**
  * Creates a sink that effectfully folds elements of type `In` into a
  * structure of type `S`, until `max` worth of elements (determined by the
@@ -712,12 +718,12 @@ export declare const foldWeightedDecomposeEffect: <S, In, R, E, R2, E2, R3, E3>(
  * @since 2.0.0
  * @category constructors
  */
-export declare const foldWeightedEffect: <S, In, R, E, R2, E2>(options: {
+export declare const foldWeightedEffect: <S, In, E, R, E2, R2>(options: {
     readonly initial: S;
     readonly maxCost: number;
-    readonly cost: (s: S, input: In) => Effect.Effect<R, E, number>;
-    readonly body: (s: S, input: In) => Effect.Effect<R2, E2, S>;
-}) => Sink<R | R2, E | E2, In, In, S>;
+    readonly cost: (s: S, input: In) => Effect.Effect<number, E, R>;
+    readonly body: (s: S, input: In) => Effect.Effect<S, E2, R2>;
+}) => Sink<S, In, In, E | E2, R | R2>;
 /**
  * A sink that executes the provided effectful function for every element fed
  * to it.
@@ -725,7 +731,7 @@ export declare const foldWeightedEffect: <S, In, R, E, R2, E2>(options: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const forEach: <In, R, E, _>(f: (input: In) => Effect.Effect<R, E, _>) => Sink<R, E, In, never, void>;
+export declare const forEach: <In, _, E, R>(f: (input: In) => Effect.Effect<_, E, R>) => Sink<void, In, never, E, R>;
 /**
  * A sink that executes the provided effectful function for every chunk fed to
  * it.
@@ -733,7 +739,7 @@ export declare const forEach: <In, R, E, _>(f: (input: In) => Effect.Effect<R, E
  * @since 2.0.0
  * @category constructors
  */
-export declare const forEachChunk: <In, R, E, _>(f: (input: Chunk.Chunk<In>) => Effect.Effect<R, E, _>) => Sink<R, E, In, never, void>;
+export declare const forEachChunk: <In, _, E, R>(f: (input: Chunk.Chunk<In>) => Effect.Effect<_, E, R>) => Sink<void, In, never, E, R>;
 /**
  * A sink that executes the provided effectful function for every chunk fed to
  * it until `f` evaluates to `false`.
@@ -741,7 +747,7 @@ export declare const forEachChunk: <In, R, E, _>(f: (input: Chunk.Chunk<In>) =>
  * @since 2.0.0
  * @category constructors
  */
-export declare const forEachChunkWhile: <In, R, E>(f: (input: Chunk.Chunk<In>) => Effect.Effect<R, E, boolean>) => Sink<R, E, In, In, void>;
+export declare const forEachChunkWhile: <In, E, R>(f: (input: Chunk.Chunk<In>) => Effect.Effect<boolean, E, R>) => Sink<void, In, In, E, R>;
 /**
  * A sink that executes the provided effectful function for every element fed
  * to it until `f` evaluates to `false`.
@@ -749,7 +755,7 @@ export declare const forEachChunkWhile: <In, R, E>(f: (input: Chunk.Chunk<In>) =
  * @since 2.0.0
  * @category constructors
  */
-export declare const forEachWhile: <In, R, E>(f: (input: In) => Effect.Effect<R, E, boolean>) => Sink<R, E, In, In, void>;
+export declare const forEachWhile: <In, E, R>(f: (input: In) => Effect.Effect<boolean, E, R>) => Sink<void, In, In, E, R>;
 /**
  * Runs this sink until it yields a result, then uses that result to create
  * another sink from the provided function which will continue to run until it
@@ -761,8 +767,8 @@ export declare const forEachWhile: <In, R, E>(f: (input: In) => Effect.Effect<R,
  * @category sequencing
  */
 export declare const flatMap: {
-    <R1, E1, In, In1 extends In, L, L1, Z, Z1>(f: (z: Z) => Sink<R1, E1, In1, L1, Z1>): <R, E>(self: Sink<R, E, In, L, Z>) => Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>;
-    <R, E, R1, E1, In, In1 extends In, L, L1, Z, Z1>(self: Sink<R, E, In, L, Z>, f: (z: Z) => Sink<R1, E1, In1, L1, Z1>): Sink<R | R1, E | E1, In & In1, L | L1, Z1>;
+    <A, A1, In, In1 extends In, L1, E1, R1>(f: (a: A) => Sink<A1, In1, L1, E1, R1>): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1, In & In1, L1 | L, E1 | E, R1 | R>;
+    <A, In, L, E, R, A1, In1 extends In, L1, E1, R1>(self: Sink<A, In, L, E, R>, f: (a: A) => Sink<A1, In1, L1, E1, R1>): Sink<A1, In & In1, L | L1, E | E1, R | R1>;
 };
 /**
  * Creates a sink from a `Channel`.
@@ -770,21 +776,21 @@ export declare const flatMap: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromChannel: <R, E, In, L, Z>(channel: Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z>) => Sink<R, E, In, L, Z>;
+export declare const fromChannel: <L, In, E, A, R>(channel: Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, A, unknown, R>) => Sink<A, In, L, E, R>;
 /**
  * Creates a `Channel` from a Sink.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const toChannel: <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z>;
+export declare const toChannel: <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, A, unknown, R>;
 /**
  * Creates a single-value sink produced from an effect.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromEffect: <R, E, Z>(effect: Effect.Effect<R, E, Z>) => Sink<R, E, unknown, never, Z>;
+export declare const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Sink<A, unknown, never, E, R>;
 /**
  * Create a sink which publishes each element to the specified `PubSub`.
  *
@@ -794,14 +800,14 @@ export declare const fromEffect: <R, E, Z>(effect: Effect.Effect<R, E, Z>) => Si
  */
 export declare const fromPubSub: <In>(pubsub: PubSub.PubSub<In>, options?: {
     readonly shutdown?: boolean | undefined;
-}) => Sink<never, never, In, never, void>;
+}) => Sink<void, In>;
 /**
  * Creates a sink from a chunk processing function.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromPush: <R, E, In, L, Z>(push: Effect.Effect<R, never, (_: Option.Option<Chunk.Chunk<In>>) => Effect.Effect<R, readonly [Either.Either<E, Z>, Chunk.Chunk<L>], void>>) => Sink<Exclude<R, Scope.Scope>, E, In, L, Z>;
+export declare const fromPush: <In, E, A, L, R>(push: Effect.Effect<(_: Option.Option<Chunk.Chunk<In>>) => Effect.Effect<void, readonly [Either.Either<E, A>, Chunk.Chunk<L>], R>, never, R>) => Sink<A, In, L, E, Exclude<R, Scope.Scope>>;
 /**
  * Create a sink which enqueues each element into the specified queue.
  *
@@ -811,28 +817,28 @@ export declare const fromPush: <R, E, In, L, Z>(push: Effect.Effect<R, never, (_
  */
 export declare const fromQueue: <In>(queue: Queue.Enqueue<In>, options?: {
     readonly shutdown?: boolean | undefined;
-}) => Sink<never, never, In, never, void>;
+}) => Sink<void, In>;
 /**
  * Creates a sink containing the first value.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const head: <In>() => Sink<never, never, In, In, Option.Option<In>>;
+export declare const head: <In>() => Sink<Option.Option<In>, In, In>;
 /**
  * Drains the remaining elements from the stream after the sink finishes
  *
  * @since 2.0.0
  * @category utils
  */
-export declare const ignoreLeftover: <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, never, Z>;
+export declare const ignoreLeftover: <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, never, E, R>;
 /**
  * Creates a sink containing the last value.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const last: <In>() => Sink<never, never, In, In, Option.Option<In>>;
+export declare const last: <In>() => Sink<Option.Option<In>, In, In>;
 /**
  * Creates a sink that does not consume any input but provides the given chunk
  * as its leftovers
@@ -840,7 +846,7 @@ export declare const last: <In>() => Sink<never, never, In, In, Option.Option<In
  * @since 2.0.0
  * @category constructors
  */
-export declare const leftover: <L>(chunk: Chunk.Chunk<L>) => Sink<never, never, unknown, L, void>;
+export declare const leftover: <L>(chunk: Chunk.Chunk<L>) => Sink<void, unknown, L>;
 /**
  * Transforms this sink's result.
  *
@@ -848,8 +854,8 @@ export declare const leftover: <L>(chunk: Chunk.Chunk<L>) => Sink<never, never,
  * @category mapping
  */
 export declare const map: {
-    <Z, Z2>(f: (z: Z) => Z2): <R, E, In, L>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, L, Z2>;
-    <R, E, In, L, Z, Z2>(self: Sink<R, E, In, L, Z>, f: (z: Z) => Z2): Sink<R, E, In, L, Z2>;
+    <A, A2>(f: (a: A) => A2): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E, R>;
+    <A, In, L, E, R, A2>(self: Sink<A, In, L, E, R>, f: (a: A) => A2): Sink<A2, In, L, E, R>;
 };
 /**
  * Effectfully transforms this sink's result.
@@ -858,8 +864,8 @@ export declare const map: {
  * @category mapping
  */
 export declare const mapEffect: {
-    <Z, R2, E2, Z2>(f: (z: Z) => Effect.Effect<R2, E2, Z2>): <R, E, In, L>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In, L, Z2>;
-    <R, E, In, L, Z, R2, E2, Z2>(self: Sink<R, E, In, L, Z>, f: (z: Z) => Effect.Effect<R2, E2, Z2>): Sink<R | R2, E | E2, In, L, Z2>;
+    <A, A2, E2, R2>(f: (a: A) => Effect.Effect<A2, E2, R2>): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E2 | E, R2 | R>;
+    <A, In, L, E, R, A2, E2, R2>(self: Sink<A, In, L, E, R>, f: (a: A) => Effect.Effect<A2, E2, R2>): Sink<A2, In, L, E | E2, R | R2>;
 };
 /**
  * Transforms the errors emitted by this sink using `f`.
@@ -868,8 +874,8 @@ export declare const mapEffect: {
  * @category mapping
  */
 export declare const mapError: {
-    <E, E2>(f: (error: E) => E2): <R, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E2, In, L, Z>;
-    <R, In, L, Z, E, E2>(self: Sink<R, E, In, L, Z>, f: (error: E) => E2): Sink<R, E2, In, L, Z>;
+    <E, E2>(f: (error: E) => E2): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>;
+    <A, In, L, E, R, E2>(self: Sink<A, In, L, E, R>, f: (error: E) => E2): Sink<A, In, L, E2, R>;
 };
 /**
  * Transforms the leftovers emitted by this sink using `f`.
@@ -878,8 +884,8 @@ export declare const mapError: {
  * @category mapping
  */
 export declare const mapLeftover: {
-    <L, L2>(f: (leftover: L) => L2): <R, E, In, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, L2, Z>;
-    <R, E, In, Z, L, L2>(self: Sink<R, E, In, L, Z>, f: (leftover: L) => L2): Sink<R, E, In, L2, Z>;
+    <L, L2>(f: (leftover: L) => L2): <A, In, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L2, E, R>;
+    <A, In, L, E, R, L2>(self: Sink<A, In, L, E, R>, f: (leftover: L) => L2): Sink<A, In, L2, E, R>;
 };
 /**
  * Creates a sink which transforms it's inputs into a string.
@@ -887,14 +893,14 @@ export declare const mapLeftover: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const mkString: Sink<never, never, unknown, never, string>;
+export declare const mkString: Sink<string, unknown>;
 /**
  * Creates a sink which never terminates.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const never: Sink<never, never, unknown, never, never>;
+export declare const never: Sink<never, unknown>;
 /**
  * Switch to another sink in case of failure
  *
@@ -902,8 +908,8 @@ export declare const never: Sink<never, never, unknown, never, never>;
  * @category error handling
  */
 export declare const orElse: {
-    <R2, E2, In2, L2, Z2>(that: LazyArg<Sink<R2, E2, In2, L2, Z2>>): <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In & In2, L2 | L, Z2 | Z>;
-    <R, E, In, L, Z, R2, E2, In2, L2, Z2>(self: Sink<R, E, In, L, Z>, that: LazyArg<Sink<R2, E2, In2, L2, Z2>>): Sink<R | R2, E | E2, In & In2, L | L2, Z | Z2>;
+    <A2, In2, L2, E2, R2>(that: LazyArg<Sink<A2, In2, L2, E2, R2>>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2 | A, In & In2, L2 | L, E2 | E, R2 | R>;
+    <A, In, L, E, R, A2, In2, L2, E2, R2>(self: Sink<A, In, L, E, R>, that: LazyArg<Sink<A2, In2, L2, E2, R2>>): Sink<A | A2, In & In2, L | L2, E | E2, R | R2>;
 };
 /**
  * Provides the sink with its required context, which eliminates its
@@ -913,8 +919,8 @@ export declare const orElse: {
  * @category context
  */
 export declare const provideContext: {
-    <R>(context: Context.Context<R>): <E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<never, E, In, L, Z>;
-    <E, In, L, Z, R>(self: Sink<R, E, In, L, Z>, context: Context.Context<R>): Sink<never, E, In, L, Z>;
+    <R>(context: Context.Context<R>): <A, In, L, E>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, never>;
+    <A, In, L, E, R>(self: Sink<A, In, L, E, R>, context: Context.Context<R>): Sink<A, In, L, E, never>;
 };
 /**
  * Runs both sinks in parallel on the input, , returning the result or the
@@ -924,8 +930,8 @@ export declare const provideContext: {
  * @category utils
  */
 export declare const race: {
-    <R1, E1, In1, L1, Z1>(that: Sink<R1, E1, In1, L1, Z1>): <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R1 | R, E1 | E, In & In1, L1 | L, Z1 | Z>;
-    <R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Sink<R1, E1, In1, L1, Z1>): Sink<R | R1, E | E1, In & In1, L | L1, Z | Z1>;
+    <R1, E1, In1, L1, A1>(that: Sink<A1, In1, L1, E1, R1>): <R, E, In, L, A>(self: Sink<A, In, L, E, R>) => Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>;
+    <A, In, L, E, R, A1, In1, L1, E1, R1>(self: Sink<A, In, L, E, R>, that: Sink<A1, In1, L1, E1, R1>): Sink<A | A1, In & In1, L | L1, E | E1, R | R1>;
 };
 /**
  * Runs both sinks in parallel on the input, returning the result or the error
@@ -935,12 +941,12 @@ export declare const race: {
  * @category utils
  */
 export declare const raceBoth: {
-    <R1, E1, In1, L1, Z1>(that: Sink<R1, E1, In1, L1, Z1>, options?: {
+    <A1, In1, L1, E1, R1>(that: Sink<A1, In1, L1, E1, R1>, options?: {
         readonly capacity?: number | undefined;
-    }): <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R1 | R, E1 | E, In & In1, L1 | L, Either.Either<Z, Z1>>;
-    <R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Sink<R1, E1, In1, L1, Z1>, options?: {
+    } | undefined): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<Either.Either<A, A1>, In & In1, L1 | L, E1 | E, R1 | R>;
+    <A, In, L, E, R, A1, In1, L1, E1, R1>(self: Sink<A, In, L, E, R>, that: Sink<A1, In1, L1, E1, R1>, options?: {
         readonly capacity?: number | undefined;
-    }): Sink<R | R1, E | E1, In & In1, L | L1, Either.Either<Z, Z1>>;
+    } | undefined): Sink<Either.Either<A, A1>, In & In1, L | L1, E | E1, R | R1>;
 };
 /**
  * Runs both sinks in parallel on the input, using the specified merge
@@ -950,39 +956,42 @@ export declare const raceBoth: {
  * @category utils
  */
 export declare const raceWith: {
-    <R2, E2, In2, L2, Z2, E, Z, Z3, Z4>(options: {
-        readonly other: Sink<R2, E2, In2, L2, Z2>;
-        readonly onSelfDone: (exit: Exit.Exit<E, Z>) => MergeDecision.MergeDecision<R2, E2, Z2, E2 | E, Z3>;
-        readonly onOtherDone: (exit: Exit.Exit<E2, Z2>) => MergeDecision.MergeDecision<R2, E, Z, E2 | E, Z4>;
+    <A2, In2, L2, E2, R2, A, E, A3, A4>(options: {
+        readonly other: Sink<A2, In2, L2, E2, R2>;
+        readonly onSelfDone: (exit: Exit.Exit<A, E>) => MergeDecision.MergeDecision<R2, E2, A2, E2 | E, A3>;
+        readonly onOtherDone: (exit: Exit.Exit<A2, E2>) => MergeDecision.MergeDecision<R2, E, A, E2 | E, A4>;
         readonly capacity?: number | undefined;
-    }): <R, In, L>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In & In2, L2 | L, Z3 | Z4>;
-    <R, In, L, R2, E2, In2, L2, Z2, E, Z, Z3, Z4>(self: Sink<R, E, In, L, Z>, options: {
-        readonly other: Sink<R2, E2, In2, L2, Z2>;
-        readonly onSelfDone: (exit: Exit.Exit<E, Z>) => MergeDecision.MergeDecision<R2, E2, Z2, E2 | E, Z3>;
-        readonly onOtherDone: (exit: Exit.Exit<E2, Z2>) => MergeDecision.MergeDecision<R2, E, Z, E2 | E, Z4>;
+    }): <In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A3 | A4, In & In2, L2 | L, E2 | E, R2 | R>;
+    <A, In, L, E, R, A2, In2, L2, E2, R2, A3, A4>(self: Sink<A, In, L, E, R>, options: {
+        readonly other: Sink<A2, In2, L2, E2, R2>;
+        readonly onSelfDone: (exit: Exit.Exit<A, E>) => MergeDecision.MergeDecision<R2, E2, A2, E | E2, A3>;
+        readonly onOtherDone: (exit: Exit.Exit<A2, E2>) => MergeDecision.MergeDecision<R2, E, A, E | E2, A4>;
         readonly capacity?: number | undefined;
-    }): Sink<R | R2, E2 | E, In & In2, L | L2, Z3 | Z4>;
+    }): Sink<A3 | A4, In & In2, L | L2, E | E2, R | R2>;
 };
 /**
  * @since 2.0.0
  * @category error handling
  */
 export declare const refineOrDie: {
-    <E, E2>(pf: (error: E) => Option.Option<E2>): <R, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E2, In, L, Z>;
-    <R, In, L, Z, E, E2>(self: Sink<R, E, In, L, Z>, pf: (error: E) => Option.Option<E2>): Sink<R, E2, In, L, Z>;
+    <E, E2>(pf: (error: E) => Option.Option<E2>): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>;
+    <A, In, L, E, R, E2>(self: Sink<A, In, L, E, R>, pf: (error: E) => Option.Option<E2>): Sink<A, In, L, E2, R>;
 };
 /**
  * @since 2.0.0
  * @category error handling
  */
-export declare const refineOrDieWith: <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown) => <R, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E2, In, L, Z>;
+export declare const refineOrDieWith: {
+    <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>;
+    <A, In, L, E, R, E2>(self: Sink<A, In, L, E, R>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): Sink<A, In, L, E2, R>;
+};
 /**
  * A sink that returns whether an element satisfies the specified predicate.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const some: <In>(predicate: Predicate<In>) => Sink<never, never, In, In, boolean>;
+export declare const some: <In>(predicate: Predicate<In>) => Sink<boolean, In, In>;
 /**
  * Splits the sink on the specified predicate, returning a new sink that
  * consumes elements until an element after the first satisfies the specified
@@ -992,8 +1001,8 @@ export declare const some: <In>(predicate: Predicate<In>) => Sink<never, never,
  * @category utils
  */
 export declare const splitWhere: {
-    <In>(f: Predicate<In>): <R, E, L extends In, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, In, Z>;
-    <R, E, L extends In, Z, In>(self: Sink<R, E, In, L, Z>, f: Predicate<In>): Sink<R, E, In, In, Z>;
+    <In>(f: Predicate<In>): <A, L extends In, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, In, E, R>;
+    <A, In, L extends In, E, R>(self: Sink<A, In, L, E, R>, f: Predicate<In>): Sink<A, In, In, E, R>;
 };
 /**
  * A sink that immediately ends with the specified value.
@@ -1001,14 +1010,14 @@ export declare const splitWhere: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const succeed: <Z>(z: Z) => Sink<never, never, unknown, never, Z>;
+export declare const succeed: <A>(a: A) => Sink<A, unknown>;
 /**
  * A sink that sums incoming numeric values.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const sum: Sink<never, never, number, never, number>;
+export declare const sum: Sink<number, number>;
 /**
  * Summarize a sink by running an effect when the sink starts and again when
  * it completes.
@@ -1017,8 +1026,8 @@ export declare const sum: Sink<never, never, number, never, number>;
  * @category utils
  */
 export declare const summarized: {
-    <R2, E2, Z2, Z3>(summary: Effect.Effect<R2, E2, Z2>, f: (start: Z2, end: Z2) => Z3): <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In, L, [Z, Z3]>;
-    <R, E, In, L, Z, R2, E2, Z2, Z3>(self: Sink<R, E, In, L, Z>, summary: Effect.Effect<R2, E2, Z2>, f: (start: Z2, end: Z2) => Z3): Sink<R | R2, E | E2, In, L, [Z, Z3]>;
+    <A2, E2, R2, A3>(summary: Effect.Effect<A2, E2, R2>, f: (start: A2, end: A2) => A3): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, A3], In, L, E2 | E, R2 | R>;
+    <A, In, L, E, R, A2, E2, R2, A3>(self: Sink<A, In, L, E, R>, summary: Effect.Effect<A2, E2, R2>, f: (start: A2, end: A2) => A3): Sink<[A, A3], In, L, E | E2, R | R2>;
 };
 /**
  * Returns a lazily constructed sink that may require effects for its
@@ -1027,47 +1036,47 @@ export declare const summarized: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const suspend: <R, E, In, L, Z>(evaluate: LazyArg<Sink<R, E, In, L, Z>>) => Sink<R, E, In, L, Z>;
+export declare const suspend: <A, In, L, E, R>(evaluate: LazyArg<Sink<A, In, L, E, R>>) => Sink<A, In, L, E, R>;
 /**
  * A sink that immediately ends with the specified lazy value.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const sync: <Z>(evaluate: LazyArg<Z>) => Sink<never, never, unknown, never, Z>;
+export declare const sync: <A>(evaluate: LazyArg<A>) => Sink<A, unknown>;
 /**
  * A sink that takes the specified number of values.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const take: <In>(n: number) => Sink<never, never, In, In, Chunk.Chunk<In>>;
+export declare const take: <In>(n: number) => Sink<Chunk.Chunk<In>, In, In>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const timed: Sink<never, never, unknown, never, Duration.Duration>;
+export declare const timed: Sink<Duration.Duration, unknown>;
 /**
  * Creates a sink produced from an effect.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const unwrap: <R, E, R2, E2, In, L, Z>(effect: Effect.Effect<R, E, Sink<R2, E2, In, L, Z>>) => Sink<R | R2, E | E2, In, L, Z>;
+export declare const unwrap: <A, In, L, E2, R2, E, R>(effect: Effect.Effect<Sink<A, In, L, E2, R2>, E, R>) => Sink<A, In, L, E2 | E, R2 | R>;
 /**
  * Creates a sink produced from a scoped effect.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const unwrapScoped: <R, E, In, L, Z>(effect: Effect.Effect<R, E, Sink<R, E, In, L, Z>>) => Sink<Exclude<R, Scope.Scope>, E, In, L, Z>;
+export declare const unwrapScoped: <A, In, L, E, R>(effect: Effect.Effect<Sink<A, In, L, E, R>, E, R>) => Sink<A, In, L, E, Exclude<R, Scope.Scope>>;
 /**
  * Returns the sink that executes this one and times its execution.
  *
  * @since 2.0.0
  * @category utils
  */
-export declare const withDuration: <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, L, [Z, Duration.Duration]>;
+export declare const withDuration: <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, Duration.Duration], In, L, E, R>;
 /**
  * Feeds inputs to this sink until it yields a result, then switches over to
  * the provided sink until it yields a result, finally combining the two
@@ -1077,12 +1086,12 @@ export declare const withDuration: <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>)
  * @category zipping
  */
 export declare const zip: {
-    <R2, E2, In, In2 extends In, L, L2, Z, Z2>(that: Sink<R2, E2, In2, L2, Z2>, options?: {
+    <A2, In, In2 extends In, L2, E2, R2>(that: Sink<A2, In2, L2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
-    }): <R, E>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In & In2, L | L2, [Z, Z2]>;
-    <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2>(self: Sink<R, E, In, L, Z>, that: Sink<R2, E2, In2, L2, Z2>, options?: {
+    } | undefined): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, A2], In & In2, L2 | L, E2 | E, R2 | R>;
+    <A, In, L, E, R, A2, In2 extends In, L2, E2, R2>(self: Sink<A, In, L, E, R>, that: Sink<A2, In2, L2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
-    }): Sink<R | R2, E | E2, In & In2, L | L2, [Z, Z2]>;
+    } | undefined): Sink<[A, A2], In & In2, L | L2, E | E2, R | R2>;
 };
 /**
  * Like `Sink.zip` but keeps only the result from this sink.
@@ -1091,12 +1100,12 @@ export declare const zip: {
  * @category zipping
  */
 export declare const zipLeft: {
-    <R2, E2, In, In2 extends In, L, L2, Z, Z2>(that: Sink<R2, E2, In2, L2, Z2>, options?: {
+    <A2, In, In2 extends In, L2, E2, R2>(that: Sink<A2, In2, L2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
-    }): <R, E>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In & In2, L | L2, Z>;
-    <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2>(self: Sink<R, E, In, L, Z>, that: Sink<R2, E2, In2, L2, Z2>, options?: {
+    } | undefined): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In & In2, L2 | L, E2 | E, R2 | R>;
+    <A, In, L, E, R, A2, In2 extends In, L2, E2, R2>(self: Sink<A, In, L, E, R>, that: Sink<A2, In2, L2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
-    }): Sink<R | R2, E | E2, In & In2, L | L2, Z>;
+    } | undefined): Sink<A, In & In2, L | L2, E | E2, R | R2>;
 };
 /**
  * Like `Sink.zip` but keeps only the result from `that` sink.
@@ -1105,12 +1114,12 @@ export declare const zipLeft: {
  * @category zipping
  */
 export declare const zipRight: {
-    <R2, E2, In, In2 extends In, L, L2, Z, Z2>(that: Sink<R2, E2, In2, L2, Z2>, options?: {
+    <A2, In, In2 extends In, L2, E2, R2>(that: Sink<A2, In2, L2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
-    }): <R, E>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In & In2, L | L2, Z2>;
-    <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2>(self: Sink<R, E, In, L, Z>, that: Sink<R2, E2, In2, L2, Z2>, options?: {
+    } | undefined): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In & In2, L2 | L, E2 | E, R2 | R>;
+    <A, In, L, E, R, A2, In2 extends In, L2, E2, R2>(self: Sink<A, In, L, E, R>, that: Sink<A2, In2, L2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
-    }): Sink<R | R2, E | E2, In & In2, L | L2, Z2>;
+    } | undefined): Sink<A2, In & In2, L | L2, E | E2, R | R2>;
 };
 /**
  * Feeds inputs to this sink until it yields a result, then switches over to
@@ -1121,11 +1130,11 @@ export declare const zipRight: {
  * @category zipping
  */
 export declare const zipWith: {
-    <R2, E2, In, In2 extends In, L, L2, Z, Z2, Z3>(that: Sink<R2, E2, In2, L2, Z2>, f: (z: Z, z1: Z2) => Z3, options?: {
+    <A2, In, In2 extends In, L2, E2, R2, A, A3>(that: Sink<A2, In2, L2, E2, R2>, f: (a: A, a2: A2) => A3, options?: {
         readonly concurrent?: boolean | undefined;
-    }): <R, E>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In & In2, L | L2, Z3>;
-    <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2, Z3>(self: Sink<R, E, In, L, Z>, that: Sink<R2, E2, In2, L2, Z2>, f: (z: Z, z1: Z2) => Z3, options?: {
+    } | undefined): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A3, In & In2, L2 | L, E2 | E, R2 | R>;
+    <A, In, L, E, R, A2, In2 extends In, L2, E2, R2, A3>(self: Sink<A, In, L, E, R>, that: Sink<A2, In2, L2, E2, R2>, f: (a: A, a2: A2) => A3, options?: {
         readonly concurrent?: boolean | undefined;
-    }): Sink<R | R2, E | E2, In & In2, L | L2, Z3>;
+    } | undefined): Sink<A3, In & In2, L | L2, E | E2, R | R2>;
 };
 //# sourceMappingURL=Sink.d.ts.map