effect 3.8.4 → 3.9.0

package/dist/dts/Sink.d.ts

@@ -100,7 +100,19 @@ export declare namespace Sink {
  * @category mapping
  */
 export declare const as: {
+    /**
+     * Replaces this sink's result with the provided value.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A2>(a: A2): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E, R>;
+    /**
+     * Replaces this sink's result with the provided value.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, In, L, E, R, A2>(self: Sink<A, In, L, E, R>, a: A2): Sink<A2, In, L, E, R>;
 };
 /**
@@ -180,7 +192,21 @@ export declare const collectAllUntilEffect: <In, E, R>(p: (input: In) => Effect.
  * @category constructors
  */
 export declare const collectAllWhile: {
+    /**
+     * Accumulates incoming elements into a chunk as long as they verify predicate
+     * `p`.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <In, Out extends In>(refinement: Refinement<In, Out>): Sink<Chunk.Chunk<Out>, In, In>;
+    /**
+     * Accumulates incoming elements into a chunk as long as they verify predicate
+     * `p`.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <In>(predicate: Predicate<In>): Sink<Chunk.Chunk<In>, In, In>;
 };
 /**
@@ -199,11 +225,25 @@ export declare const collectAllWhileEffect: <In, E, R>(predicate: (input: In) =>
  * @category utils
  */
 export declare const collectAllWhileWith: {
+    /**
+     * 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`.
+     *
+     * @since 2.0.0
+     * @category utils
+     */
     <A, S>(options: {
         readonly initial: S;
         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>;
+    /**
+     * 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`.
+     *
+     * @since 2.0.0
+     * @category utils
+     */
     <A, In, L extends In, E, R, S>(self: Sink<A, In, L, E, R>, options: {
         readonly initial: S;
         readonly while: Predicate<A>;
@@ -225,7 +265,19 @@ export declare const collectLeftover: <A, In, L, E, R>(self: Sink<A, In, L, E, R
  * @category mapping
  */
 export declare const mapInput: {
+    /**
+     * Transforms this sink's input elements.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <In0, In>(f: (input: In0) => In): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E, R>;
+    /**
+     * Transforms this sink's input elements.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, In, L, E, R, In0>(self: Sink<A, In, L, E, R>, f: (input: In0) => In): Sink<A, In0, L, E, R>;
 };
 /**
@@ -235,7 +287,19 @@ export declare const mapInput: {
  * @category mapping
  */
 export declare const mapInputEffect: {
+    /**
+     * Effectfully transforms this sink's input elements.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <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>;
+    /**
+     * Effectfully transforms this sink's input elements.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <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>;
 };
 /**
@@ -245,7 +309,19 @@ export declare const mapInputEffect: {
  * @category mapping
  */
 export declare const mapInputChunks: {
+    /**
+     * Transforms this sink's input chunks. `f` must preserve chunking-invariance.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <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>;
+    /**
+     * Transforms this sink's input chunks. `f` must preserve chunking-invariance.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <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>;
 };
 /**
@@ -256,7 +332,21 @@ export declare const mapInputChunks: {
  * @category mapping
  */
 export declare const mapInputChunksEffect: {
+    /**
+     * Effectfully transforms this sink's input chunks. `f` must preserve
+     * chunking-invariance.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <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>;
+    /**
+     * Effectfully transforms this sink's input chunks. `f` must preserve
+     * chunking-invariance.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <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>;
 };
 /**
@@ -296,10 +386,24 @@ export declare const dieSync: (evaluate: LazyArg<unknown>) => Sink<never, unknow
  * @category mapping
  */
 export declare const dimap: {
+    /**
+     * Transforms both inputs and result of this sink using the provided
+     * functions.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <In0, In, A, A2>(options: {
         readonly onInput: (input: In0) => In;
         readonly onDone: (a: A) => A2;
     }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E, R>;
+    /**
+     * Transforms both inputs and result of this sink using the provided
+     * functions.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, In, L, E, R, In0, A2>(self: Sink<A, In, L, E, R>, options: {
         readonly onInput: (input: In0) => In;
         readonly onDone: (a: A) => A2;
@@ -313,10 +417,24 @@ export declare const dimap: {
  * @category mapping
  */
 export declare const dimapEffect: {
+    /**
+     * Effectfully transforms both inputs and result of this sink using the
+     * provided functions.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <In0, In, E2, R2, A, A2, E3, R3>(options: {
         readonly onInput: (input: In0) => Effect.Effect<In, E2, R2>;
         readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
     }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>;
+    /**
+     * Effectfully transforms both inputs and result of this sink using the
+     * provided functions.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <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>;
@@ -330,10 +448,24 @@ export declare const dimapEffect: {
  * @category mapping
  */
 export declare const dimapChunks: {
+    /**
+     * Transforms both input chunks and result of this sink using the provided
+     * functions.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <In0, In, A, A2>(options: {
         readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>;
         readonly onDone: (a: A) => A2;
     }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E, R>;
+    /**
+     * Transforms both input chunks and result of this sink using the provided
+     * functions.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <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: (a: A) => A2;
@@ -347,10 +479,24 @@ export declare const dimapChunks: {
  * @category mapping
  */
 export declare const dimapChunksEffect: {
+    /**
+     * Effectfully transforms both input chunks and result of this sink using the
+     * provided functions. `f` and `g` must preserve chunking-invariance.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <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>;
     }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>;
+    /**
+     * Effectfully transforms both input chunks and result of this sink using the
+     * provided functions. `f` and `g` must preserve chunking-invariance.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <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>;
@@ -407,7 +553,23 @@ export declare const dropWhileEffect: <In, E, R>(predicate: (input: In) => Effec
  * @category finalization
  */
 export declare const ensuring: {
+    /**
+     * 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
+     * whether or not it completes).
+     *
+     * @since 2.0.0
+     * @category finalization
+     */
     <X, R2>(finalizer: Effect.Effect<X, never, R2>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | 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
+     * whether or not it completes).
+     *
+     * @since 2.0.0
+     * @category finalization
+     */
     <A, In, L, E, R, X, R2>(self: Sink<A, In, L, E, R>, finalizer: Effect.Effect<X, never, R2>): Sink<A, In, L, E, R | R2>;
 };
 /**
@@ -419,7 +581,23 @@ export declare const ensuring: {
  * @category finalization
  */
 export declare const ensuringWith: {
+    /**
+     * 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
+     * whether or not it completes).
+     *
+     * @since 2.0.0
+     * @category finalization
+     */
     <A, E, X, R2>(finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<X, never, R2>): <In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | 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
+     * whether or not it completes).
+     *
+     * @since 2.0.0
+     * @category finalization
+     */
     <A, In, L, E, R, X, R2>(self: Sink<A, In, L, E, R>, finalizer: (exit: Exit.Exit<A, E>) => Effect.Effect<X, never, R2>): Sink<A, In, L, E, R | R2>;
 };
 /**
@@ -492,7 +670,19 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Si
  * @category filtering
  */
 export declare const filterInput: {
+    /**
+     * Filters the sink's input with the given predicate.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <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>;
+    /**
+     * Filters the sink's input with the given predicate.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <In, In1 extends In>(f: Predicate<In1>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In1, L, E, R>;
 };
 /**
@@ -502,7 +692,19 @@ export declare const filterInput: {
  * @category filtering
  */
 export declare const filterInputEffect: {
+    /**
+     * Effectfully filter the input of this sink using the specified predicate.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <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>;
+    /**
+     * Effectfully filter the input of this sink using the specified predicate.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <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>;
 };
 /**
@@ -512,7 +714,19 @@ export declare const filterInputEffect: {
  * @category elements
  */
 export declare const findEffect: {
+    /**
+     * Creates a sink that produces values until one verifies the predicate `f`.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     <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>;
+    /**
+     * Creates a sink that produces values until one verifies the predicate `f`.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     <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>;
 };
 /**
@@ -530,10 +744,22 @@ export declare const fold: <S, In>(s: S, contFn: Predicate<S>, f: (s: S, input:
  * @category folding
  */
 export declare const foldSink: {
+    /**
+     * Folds over the result of the sink
+     *
+     * @since 2.0.0
+     * @category folding
+     */
     <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>;
+    /**
+     * Folds over the result of the sink
+     *
+     * @since 2.0.0
+     * @category folding
+     */
     <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>;
@@ -767,7 +993,27 @@ export declare const forEachWhile: <In, E, R>(f: (input: In) => Effect.Effect<bo
  * @category sequencing
  */
 export declare const flatMap: {
+    /**
+     * 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
+     * yields a result.
+     *
+     * This function essentially runs sinks in sequence.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <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>;
+    /**
+     * 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
+     * yields a result.
+     *
+     * This function essentially runs sinks in sequence.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <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>;
 };
 /**
@@ -854,7 +1100,19 @@ export declare const leftover: <L>(chunk: Chunk.Chunk<L>) => Sink<void, unknown,
  * @category mapping
  */
 export declare const map: {
+    /**
+     * Transforms this sink's result.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, A2>(f: (a: A) => A2): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E, R>;
+    /**
+     * Transforms this sink's result.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, In, L, E, R, A2>(self: Sink<A, In, L, E, R>, f: (a: A) => A2): Sink<A2, In, L, E, R>;
 };
 /**
@@ -864,7 +1122,19 @@ export declare const map: {
  * @category mapping
  */
 export declare const mapEffect: {
+    /**
+     * Effectfully transforms this sink's result.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <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>;
+    /**
+     * Effectfully transforms this sink's result.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <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>;
 };
 /**
@@ -874,7 +1144,19 @@ export declare const mapEffect: {
  * @category mapping
  */
 export declare const mapError: {
+    /**
+     * Transforms the errors emitted by this sink using `f`.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <E, E2>(f: (error: E) => E2): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>;
+    /**
+     * Transforms the errors emitted by this sink using `f`.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, In, L, E, R, E2>(self: Sink<A, In, L, E, R>, f: (error: E) => E2): Sink<A, In, L, E2, R>;
 };
 /**
@@ -884,7 +1166,19 @@ export declare const mapError: {
  * @category mapping
  */
 export declare const mapLeftover: {
+    /**
+     * Transforms the leftovers emitted by this sink using `f`.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <L, L2>(f: (leftover: L) => L2): <A, In, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L2, E, R>;
+    /**
+     * Transforms the leftovers emitted by this sink using `f`.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, In, L, E, R, L2>(self: Sink<A, In, L, E, R>, f: (leftover: L) => L2): Sink<A, In, L2, E, R>;
 };
 /**
@@ -908,7 +1202,19 @@ export declare const never: Sink<never, unknown>;
  * @category error handling
  */
 export declare const orElse: {
+    /**
+     * Switch to another sink in case of failure
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <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>;
+    /**
+     * Switch to another sink in case of failure
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <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>;
 };
 /**
@@ -919,7 +1225,21 @@ export declare const orElse: {
  * @category context
  */
 export declare const provideContext: {
+    /**
+     * Provides the sink with its required context, which eliminates its
+     * dependency on `R`.
+     *
+     * @since 2.0.0
+     * @category context
+     */
     <R>(context: Context.Context<R>): <A, In, L, E>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, never>;
+    /**
+     * Provides the sink with its required context, which eliminates its
+     * dependency on `R`.
+     *
+     * @since 2.0.0
+     * @category context
+     */
     <A, In, L, E, R>(self: Sink<A, In, L, E, R>, context: Context.Context<R>): Sink<A, In, L, E, never>;
 };
 /**
@@ -930,7 +1250,21 @@ export declare const provideContext: {
  * @category utils
  */
 export declare const race: {
+    /**
+     * Runs both sinks in parallel on the input, , returning the result or the
+     * error from the one that finishes first.
+     *
+     * @since 2.0.0
+     * @category utils
+     */
     <R1, E1, In1, L1, A1>(that: Sink<A1, In1, L1, E1, R1>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>;
+    /**
+     * Runs both sinks in parallel on the input, , returning the result or the
+     * error from the one that finishes first.
+     *
+     * @since 2.0.0
+     * @category utils
+     */
     <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>;
 };
 /**
@@ -941,9 +1275,23 @@ export declare const race: {
  * @category utils
  */
 export declare const raceBoth: {
+    /**
+     * Runs both sinks in parallel on the input, returning the result or the error
+     * from the one that finishes first.
+     *
+     * @since 2.0.0
+     * @category utils
+     */
     <A1, In1, L1, E1, R1>(that: Sink<A1, In1, L1, E1, R1>, options?: {
         readonly capacity?: number | undefined;
     } | undefined): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<Either.Either<A1, A>, In & In1, L1 | L, E1 | E, R1 | R>;
+    /**
+     * Runs both sinks in parallel on the input, returning the result or the error
+     * from the one that finishes first.
+     *
+     * @since 2.0.0
+     * @category utils
+     */
     <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;
     } | undefined): Sink<Either.Either<A1, A>, In & In1, L | L1, E | E1, R | R1>;
@@ -956,12 +1304,26 @@ export declare const raceBoth: {
  * @category utils
  */
 export declare const raceWith: {
+    /**
+     * Runs both sinks in parallel on the input, using the specified merge
+     * function as soon as one result or the other has been computed.
+     *
+     * @since 2.0.0
+     * @category utils
+     */
     <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;
     }): <In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A3 | A4, In & In2, L2 | L, E2 | E, R2 | R>;
+    /**
+     * Runs both sinks in parallel on the input, using the specified merge
+     * function as soon as one result or the other has been computed.
+     *
+     * @since 2.0.0
+     * @category utils
+     */
     <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>;
@@ -974,7 +1336,15 @@ export declare const raceWith: {
  * @category error handling
  */
 export declare const refineOrDie: {
+    /**
+     * @since 2.0.0
+     * @category error handling
+     */
     <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>;
+    /**
+     * @since 2.0.0
+     * @category error handling
+     */
     <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>;
 };
 /**
@@ -982,7 +1352,15 @@ export declare const refineOrDie: {
  * @category error handling
  */
 export declare const refineOrDieWith: {
+    /**
+     * @since 2.0.0
+     * @category error handling
+     */
     <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>;
+    /**
+     * @since 2.0.0
+     * @category error handling
+     */
     <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>;
 };
 /**
@@ -1001,7 +1379,23 @@ export declare const some: <In>(predicate: Predicate<In>) => Sink<boolean, In, I
  * @category utils
  */
 export declare const splitWhere: {
+    /**
+     * Splits the sink on the specified predicate, returning a new sink that
+     * consumes elements until an element after the first satisfies the specified
+     * predicate.
+     *
+     * @since 2.0.0
+     * @category utils
+     */
     <In>(f: Predicate<In>): <A, L extends In, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, In, E, R>;
+    /**
+     * Splits the sink on the specified predicate, returning a new sink that
+     * consumes elements until an element after the first satisfies the specified
+     * predicate.
+     *
+     * @since 2.0.0
+     * @category utils
+     */
     <A, In, L extends In, E, R>(self: Sink<A, In, L, E, R>, f: Predicate<In>): Sink<A, In, In, E, R>;
 };
 /**
@@ -1026,7 +1420,21 @@ export declare const sum: Sink<number, number>;
  * @category utils
  */
 export declare const summarized: {
+    /**
+     * Summarize a sink by running an effect when the sink starts and again when
+     * it completes.
+     *
+     * @since 2.0.0
+     * @category utils
+     */
     <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>;
+    /**
+     * Summarize a sink by running an effect when the sink starts and again when
+     * it completes.
+     *
+     * @since 2.0.0
+     * @category utils
+     */
     <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>;
 };
 /**
@@ -1086,9 +1494,25 @@ export declare const withDuration: <A, In, L, E, R>(self: Sink<A, In, L, E, R>)
  * @category zipping
  */
 export declare const zip: {
+    /**
+     * 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
+     * results into a tuple.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A2, In, In2 extends In, L2, E2, R2>(that: Sink<A2, In2, L2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
     } | undefined): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, A2], In & In2, L2 | L, E2 | E, R2 | 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
+     * results into a tuple.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <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;
     } | undefined): Sink<[A, A2], In & In2, L | L2, E | E2, R | R2>;
@@ -1100,9 +1524,21 @@ export declare const zip: {
  * @category zipping
  */
 export declare const zipLeft: {
+    /**
+     * Like `Sink.zip` but keeps only the result from this sink.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A2, In, In2 extends In, L2, E2, R2>(that: Sink<A2, In2, L2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
     } | undefined): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In & In2, L2 | L, E2 | E, R2 | R>;
+    /**
+     * Like `Sink.zip` but keeps only the result from this sink.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <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;
     } | undefined): Sink<A, In & In2, L | L2, E | E2, R | R2>;
@@ -1114,9 +1550,21 @@ export declare const zipLeft: {
  * @category zipping
  */
 export declare const zipRight: {
+    /**
+     * Like `Sink.zip` but keeps only the result from `that` sink.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A2, In, In2 extends In, L2, E2, R2>(that: Sink<A2, In2, L2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
     } | undefined): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In & In2, L2 | L, E2 | E, R2 | R>;
+    /**
+     * Like `Sink.zip` but keeps only the result from `that` sink.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <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;
     } | undefined): Sink<A2, In & In2, L | L2, E | E2, R | R2>;
@@ -1130,9 +1578,25 @@ export declare const zipRight: {
  * @category zipping
  */
 export declare const zipWith: {
+    /**
+     * 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
+     * results with `f`.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <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;
     } | undefined): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A3, In & In2, L2 | L, E2 | E, R2 | 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
+     * results with `f`.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <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;
     } | undefined): Sink<A3, In & In2, L | L2, E | E2, R | R2>;