effect 3.13.0 → 3.13.2

package/src/Stream.ts

@@ -571,10 +571,7 @@ export const branchAfter: {
    * @since 2.0.0
    * @category sequencing
    */
-  <A, A2, E2, R2>(
-    n: number,
-    f: (input: Chunk.Chunk<A>) => Stream<A2, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <A, A2, E2, R2>(n: number, f: (input: Chunk.Chunk<A>) => Stream<A2, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   /**
    * Returns a `Stream` that first collects `n` elements from the input `Stream`,
    * and then creates a new `Stream` using the specified function, and sends all
@@ -1265,9 +1262,7 @@ export const catchAllCause: {
    * @since 2.0.0
    * @category error handling
    */
-  <E, A2, E2, R2>(
-    f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>
-  ): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2, R2 | R>
+  <E, A2, E2, R2>(f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2, R2 | R>
   /**
    * Switches over to the stream produced by the provided function in case this
    * one fails. Allows recovery from all causes of failure, including
@@ -1276,10 +1271,7 @@ export const catchAllCause: {
    * @since 2.0.0
    * @category error handling
    */
-  <A, E, R, A2, E2, R2>(
-    self: Stream<A, E, R>,
-    f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>
-  ): Stream<A | A2, E2, R | R2>
+  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>): Stream<A | A2, E2, R | R2>
 } = internal.catchAllCause
 
 /**
@@ -1297,9 +1289,7 @@ export const catchSome: {
    * @since 2.0.0
    * @category error handling
    */
-  <E, A2, E2, R2>(
-    pf: (error: E) => Option.Option<Stream<A2, E2, R2>>
-  ): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A, E | E2, R2 | R>
+  <E, A2, E2, R2>(pf: (error: E) => Option.Option<Stream<A2, E2, R2>>): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A, E | E2, R2 | R>
   /**
    * Switches over to the stream produced by the provided function in case this
    * one fails with some typed error.
@@ -1307,10 +1297,7 @@ export const catchSome: {
    * @since 2.0.0
    * @category error handling
    */
-  <A, E, R, A2, E2, R2>(
-    self: Stream<A, E, R>,
-    pf: (error: E) => Option.Option<Stream<A2, E2, R2>>
-  ): Stream<A | A2, E | E2, R | R2>
+  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, pf: (error: E) => Option.Option<Stream<A2, E2, R2>>): Stream<A | A2, E | E2, R | R2>
 } = internal.catchSome
 
 /**
@@ -1328,10 +1315,7 @@ export const catchTag: {
    * @since 2.0.0
    * @category error handling
    */
-  <K extends E["_tag"] & string, E extends { _tag: string }, A1, E1, R1>(
-    k: K,
-    f: (e: Extract<E, { _tag: K }>) => Stream<A1, E1, R1>
-  ): <A, R>(self: Stream<A, E, R>) => Stream<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
+  <K extends E["_tag"] & string, E extends { _tag: string }, A1, E1, R1>(k: K, f: (e: Extract<E, { _tag: K }>) => Stream<A1, E1, R1>): <A, R>(self: Stream<A, E, R>) => Stream<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
   /**
    * Switches over to the stream produced by the provided function in case this
    * one fails with an error matching the given `_tag`.
@@ -1431,9 +1415,7 @@ export const catchSomeCause: {
    * @since 2.0.0
    * @category error handling
    */
-  <E, A2, E2, R2>(
-    pf: (cause: Cause.Cause<E>) => Option.Option<Stream<A2, E2, R2>>
-  ): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A, E | E2, R2 | R>
+  <E, A2, E2, R2>(pf: (cause: Cause.Cause<E>) => Option.Option<Stream<A2, E2, R2>>): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A, E | E2, R2 | R>
   /**
    * Switches over to the stream produced by the provided function in case this
    * one fails with some errors. Allows recovery from all causes of failure,
@@ -1514,9 +1496,7 @@ export const changesWithEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A, E2, R2>(
-    f: (x: A, y: A) => Effect.Effect<boolean, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <A, E2, R2>(f: (x: A, y: A) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   /**
    * Returns a new stream that only emits elements that are not equal to the
    * previous element emitted, using the specified effectual function to
@@ -1960,10 +1940,7 @@ export const crossWith: {
    * @since 2.0.0
    * @category utils
    */
-  <AR, ER, RR, AL, A>(
-    right: Stream<AR, ER, RR>,
-    f: (left: AL, right: AR) => A
-  ): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>
+  <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: AL, right: AR) => A): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>
   /**
    * Composes this stream with the specified stream to create a cartesian
    * product of elements with a specified function. The `right` stream would be
@@ -2414,9 +2391,7 @@ export const dropUntilEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A, E2, R2>(
-    predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <A, E2, R2>(predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   /**
    * Drops all elements of the stream until the specified effectful predicate
    * evaluates to `true`.
@@ -2471,9 +2446,7 @@ export const dropWhileEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A, E2, R2>(
-    predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <A, E2, R2>(predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   /**
    * Drops all elements of the stream for as long as the specified predicate
    * produces an effect that evalutates to `true`
@@ -2481,10 +2454,7 @@ export const dropWhileEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A, E, R, E2, R2>(
-    self: Stream<A, E, R>,
-    predicate: (a: A) => Effect.Effect<boolean, E2, R2>
-  ): Stream<A, E | E2, R | R2>
+  <A, E, R, E2, R2>(self: Stream<A, E, R>, predicate: (a: A) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.dropWhileEffect
 
 /**
@@ -2812,9 +2782,7 @@ export const filterEffect: {
    * @since 2.0.0
    * @category filtering
    */
-  <A, E2, R2>(
-    f: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <A, E2, R2>(f: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   /**
    * Effectfully filters the elements emitted by this stream.
    *
@@ -2860,9 +2828,7 @@ export const filterMapEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A, A2, E2, R2>(
-    pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <A, A2, E2, R2>(pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   /**
    * Performs an effectful filter and map in a single step.
    *
@@ -2916,9 +2882,7 @@ export const filterMapWhileEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A, A2, E2, R2>(
-    pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <A, A2, E2, R2>(pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   /**
    * Effectfully transforms all elements of the stream for as long as the
    * specified partial function is defined.
@@ -3023,9 +2987,7 @@ export const findEffect: {
    * @since 2.0.0
    * @category elements
    */
-  <A, E2, R2>(
-    predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <A, E2, R2>(predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   /**
    * Finds the first element emitted by this stream that satisfies the provided
    * effectful predicate.
@@ -4053,10 +4015,7 @@ export const groupedWithin: {
    * @since 2.0.0
    * @category grouping
    */
-  (
-    chunkSize: number,
-    duration: Duration.DurationInput
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>
+  (chunkSize: number, duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>
   /**
    * Partitions the stream with the specified `chunkSize` or until the specified
    * `duration` has passed, whichever is satisfied first.
@@ -4357,10 +4316,7 @@ export const interleaveWith: {
    * @since 2.0.0
    * @category utils
    */
-  <A2, E2, R2, E3, R3>(
-    that: Stream<A2, E2, R2>,
-    decider: Stream<boolean, E3, R3>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E3 | E, R2 | R3 | R>
+  <A2, E2, R2, E3, R3>(that: Stream<A2, E2, R2>, decider: Stream<boolean, E3, R3>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E3 | E, R2 | R3 | R>
   /**
    * Combines this stream and the specified stream deterministically using the
    * stream of boolean values `pull` to control which stream to pull from next.
@@ -4531,9 +4487,7 @@ export const intersperseAffixes: {
    * @since 2.0.0
    * @category utils
    */
-  <A2, A3, A4>(
-    options: { readonly start: A2; readonly middle: A3; readonly end: A4 }
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A3 | A4 | A, E, R>
+  <A2, A3, A4>(options: { readonly start: A2; readonly middle: A3; readonly end: A4 }): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A3 | A4 | A, E, R>
   /**
    * Intersperse the specified element, also adding a prefix and a suffix.
    *
@@ -4842,10 +4796,7 @@ export const mapAccumEffect: {
    * @since 2.0.0
    * @category mapping
    */
-  <S, A, A2, E2, R2>(
-    s: S,
-    f: (s: S, a: A) => Effect.Effect<readonly [S, A2], E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <S, A, A2, E2, R2>(s: S, f: (s: S, a: A) => Effect.Effect<readonly [S, A2], E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   /**
    * Statefully and effectfully maps over the elements of this stream to produce
    * new elements.
@@ -4927,9 +4878,7 @@ export const mapChunksEffect: {
    * @since 2.0.0
    * @category mapping
    */
-  <A, B, E2, R2>(
-    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<Chunk.Chunk<B>, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<B, E2 | E, R2 | R>
+  <A, B, E2, R2>(f: (chunk: Chunk.Chunk<A>) => Effect.Effect<Chunk.Chunk<B>, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<B, E2 | E, R2 | R>
   /**
    * Effectfully transforms the chunks emitted by this stream.
    *
@@ -5048,9 +4997,7 @@ export const mapConcatChunkEffect: {
    * @since 2.0.0
    * @category mapping
    */
-  <A, A2, E2, R2>(
-    f: (a: A) => Effect.Effect<Chunk.Chunk<A2>, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <A, A2, E2, R2>(f: (a: A) => Effect.Effect<Chunk.Chunk<A2>, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   /**
    * Effectfully maps each element to a chunk, and flattens the chunks into the
    * output of this stream.
@@ -5058,10 +5005,7 @@ export const mapConcatChunkEffect: {
    * @since 2.0.0
    * @category mapping
    */
-  <A, E, R, A2, E2, R2>(
-    self: Stream<A, E, R>,
-    f: (a: A) => Effect.Effect<Chunk.Chunk<A2>, E2, R2>
-  ): Stream<A2, E | E2, R | R2>
+  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<Chunk.Chunk<A2>, E2, R2>): Stream<A2, E | E2, R | R2>
 } = internal.mapConcatChunkEffect
 
 /**
@@ -5079,9 +5023,7 @@ export const mapConcatEffect: {
    * @since 2.0.0
    * @category mapping
    */
-  <A, A2, E2, R2>(
-    f: (a: A) => Effect.Effect<Iterable<A2>, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <A, A2, E2, R2>(f: (a: A) => Effect.Effect<Iterable<A2>, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   /**
    * Effectfully maps each element to an iterable, and flattens the iterables
    * into the output of this stream.
@@ -5089,10 +5031,7 @@ export const mapConcatEffect: {
    * @since 2.0.0
    * @category mapping
    */
-  <A, E, R, A2, E2, R2>(
-    self: Stream<A, E, R>,
-    f: (a: A) => Effect.Effect<Iterable<A2>, E2, R2>
-  ): Stream<A2, E | E2, R | R2>
+  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<Iterable<A2>, E2, R2>): Stream<A2, E | E2, R | R2>
 } = internal.mapConcatEffect
 
 /**
@@ -5580,9 +5519,7 @@ export const mergeEither: {
    * @since 2.0.0
    * @category utils
    */
-  <A2, E2, R2>(
-    that: Stream<A2, E2, R2>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A2, A>, E2 | E, R2 | R>
+  <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A2, A>, E2 | E, R2 | R>
   /**
    * Merges this stream and the specified stream together to produce a stream of
    * eithers.
@@ -5760,9 +5697,7 @@ export const onError: {
    * @since 2.0.0
    * @category utils
    */
-  <E, X, R2>(
-    cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>
-  ): <A, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <E, X, R2>(cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
   /**
    * Runs the specified effect if this stream fails, providing the error to the
    * effect if it exists.
@@ -5960,9 +5895,7 @@ export const orElseEither: {
    * @since 2.0.0
    * @category error handling
    */
-  <A2, E2, R2>(
-    that: LazyArg<Stream<A2, E2, R2>>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A2, A>, E2, R2 | R>
+  <A2, E2, R2>(that: LazyArg<Stream<A2, E2, R2>>): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A2, A>, E2, R2 | R>
   /**
    * Switches to the provided stream in case this one fails with a typed error.
    *
@@ -5971,10 +5904,7 @@ export const orElseEither: {
    * @since 2.0.0
    * @category error handling
    */
-  <A, E, R, A2, E2, R2>(
-    self: Stream<A, E, R>,
-    that: LazyArg<Stream<A2, E2, R2>>
-  ): Stream<Either.Either<A2, A>, E2, R | R2>
+  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: LazyArg<Stream<A2, E2, R2>>): Stream<Either.Either<A2, A>, E2, R | R2>
 } = internal.orElseEither
 
 /**
@@ -6550,9 +6480,7 @@ export const peel: {
    * @since 2.0.0
    * @category utils
    */
-  <A2, A, E2, R2>(
-    sink: Sink.Sink<A2, A, A, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[A2, Stream<A, E, never>], E2 | E, Scope.Scope | R2 | R>
+  <A2, A, E2, R2>(sink: Sink.Sink<A2, A, A, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[A2, Stream<A, E, never>], E2 | E, Scope.Scope | R2 | R>
   /**
    * Peels off enough material from the stream to construct a `Z` using the
    * provided `Sink` and then returns both the `Z` and the rest of the
@@ -6562,10 +6490,7 @@ export const peel: {
    * @since 2.0.0
    * @category utils
    */
-  <A, E, R, A2, E2, R2>(
-    self: Stream<A, E, R>,
-    sink: Sink.Sink<A2, A, A, E2, R2>
-  ): Effect.Effect<[A2, Stream<A, E, never>], E | E2, Scope.Scope | R | R2>
+  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<A2, A, A, E2, R2>): Effect.Effect<[A2, Stream<A, E, never>], E | E2, Scope.Scope | R | R2>
 } = internal.peel
 
 /**
@@ -6769,10 +6694,7 @@ export const provideServiceEffect: {
    * @since 2.0.0
    * @category context
    */
-  <I, S, E2, R2>(
-    tag: Context.Tag<I, S>,
-    effect: Effect.Effect<NoInfer<S>, E2, R2>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, I>>
+  <I, S, E2, R2>(tag: Context.Tag<I, S>, effect: Effect.Effect<NoInfer<S>, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, I>>
   /**
    * Provides the stream with the single service it requires. If the stream
    * requires more than one service use `Stream.provideContext` instead.
@@ -6802,10 +6724,7 @@ export const provideServiceStream: {
    * @since 2.0.0
    * @category context
    */
-  <I, S, E2, R2>(
-    tag: Context.Tag<I, S>,
-    stream: Stream<NoInfer<S>, E2, R2>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, I>>
+  <I, S, E2, R2>(tag: Context.Tag<I, S>, stream: Stream<NoInfer<S>, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, I>>
   /**
    * Provides the stream with the single service it requires. If the stream
    * requires more than one service use `Stream.provideContext` instead.
@@ -6861,9 +6780,7 @@ export const provideSomeLayer: {
    * @since 2.0.0
    * @category context
    */
-  <RIn, E2, ROut>(
-    layer: Layer.Layer<ROut, E2, RIn>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, RIn | Exclude<R, ROut>>
+  <RIn, E2, ROut>(layer: Layer.Layer<ROut, E2, RIn>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, RIn | Exclude<R, ROut>>
   /**
    * Splits the context into two parts, providing one part using the
    * specified layer and leaving the remainder `R0`.
@@ -6871,10 +6788,7 @@ export const provideSomeLayer: {
    * @since 2.0.0
    * @category context
    */
-  <A, E, R, RIn, E2, ROut>(
-    self: Stream<A, E, R>,
-    layer: Layer.Layer<ROut, E2, RIn>
-  ): Stream<A, E | E2, RIn | Exclude<R, ROut>>
+  <A, E, R, RIn, E2, ROut>(self: Stream<A, E, R>, layer: Layer.Layer<ROut, E2, RIn>): Stream<A, E | E2, RIn | Exclude<R, ROut>>
 } = internal.provideSomeLayer
 
 /**
@@ -7085,10 +6999,7 @@ export const refineOrDieWith: {
    * @since 2.0.0
    * @category error handling
    */
-  <E, E2>(
-    pf: (error: E) => Option.Option<E2>,
-    f: (error: E) => unknown
-  ): <A, R>(self: Stream<A, E, R>) => Stream<A, E2, R>
+  <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <A, R>(self: Stream<A, E, R>) => Stream<A, E2, R>
   /**
    * Keeps some of the errors, and terminates the fiber with the rest, using the
    * specified function to convert the `E` into a defect.
@@ -7256,9 +7167,7 @@ export const repeatEither: {
    * @since 2.0.0
    * @category utils
    */
-  <B, R2>(
-    schedule: Schedule.Schedule<B, unknown, R2>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A, B>, E, R2 | R>
+  <B, R2>(schedule: Schedule.Schedule<B, unknown, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A, B>, E, R2 | R>
   /**
    * Repeats the entire stream using the specified schedule. The stream will
    * execute normally, and then repeat again according to the provided schedule.
@@ -7267,10 +7176,7 @@ export const repeatEither: {
    * @since 2.0.0
    * @category utils
    */
-  <A, E, R, B, R2>(
-    self: Stream<A, E, R>,
-    schedule: Schedule.Schedule<B, unknown, R2>
-  ): Stream<Either.Either<A, B>, E, R | R2>
+  <A, E, R, B, R2>(self: Stream<A, E, R>, schedule: Schedule.Schedule<B, unknown, R2>): Stream<Either.Either<A, B>, E, R | R2>
 } = internal.repeatEither
 
 /**
@@ -7449,9 +7355,7 @@ export const retry: {
    * @since 2.0.0
    * @category utils
    */
-  <E0 extends E, R2, E, X>(
-    schedule: Schedule.Schedule<X, E0, R2>
-  ): <A, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <E0 extends E, R2, E, X>(schedule: Schedule.Schedule<X, E0, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
   /**
    * When the stream fails, retry it according to the given schedule
    *
@@ -7481,19 +7385,14 @@ export const run: {
    * @since 2.0.0
    * @category destructors
    */
-  <A2, A, E2, R2>(
-    sink: Sink.Sink<A2, A, unknown, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<A2, E2 | E, Exclude<R | R2, Scope.Scope>>
+  <A2, A, E2, R2>(sink: Sink.Sink<A2, A, unknown, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<A2, E2 | E, Exclude<R | R2, Scope.Scope>>
   /**
    * Runs the sink on the stream to produce either the sink's result or an error.
    *
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, A2, E2, R2>(
-    self: Stream<A, E, R>,
-    sink: Sink.Sink<A2, A, unknown, E2, R2>
-  ): Effect.Effect<A2, E | E2, Exclude<R | R2, Scope.Scope>>
+  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<A2, A, unknown, E2, R2>): Effect.Effect<A2, E | E2, Exclude<R | R2, Scope.Scope>>
 } = internal.run
 
 /**
@@ -7559,21 +7458,14 @@ export const runFoldEffect: {
    * @since 2.0.0
    * @category destructors
    */
-  <S, A, E2, R2>(
-    s: S,
-    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>>
+  <S, A, E2, R2>(s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>>
   /**
    * Executes an effectful fold over the stream of values.
    *
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, S, E2, R2>(
-    self: Stream<A, E, R>,
-    s: S,
-    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ): Effect.Effect<S, E | E2, Exclude<R | R2, Scope.Scope>>
+  <A, E, R, S, E2, R2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, Exclude<R | R2, Scope.Scope>>
 } = internal.runFoldEffect
 
 /**
@@ -7617,10 +7509,7 @@ export const runFoldScopedEffect: {
    * @since 2.0.0
    * @category destructors
    */
-  <S, A, E2, R2>(
-    s: S,
-    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Scope.Scope | R2 | R>
+  <S, A, E2, R2>(s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Scope.Scope | R2 | R>
   /**
    * Executes an effectful fold over the stream of values. Returns a scoped
    * value that represents the scope of the stream.
@@ -7628,11 +7517,7 @@ export const runFoldScopedEffect: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, S, E2, R2>(
-    self: Stream<A, E, R>,
-    s: S,
-    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ): Effect.Effect<S, E | E2, Scope.Scope | R | R2>
+  <A, E, R, S, E2, R2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, Scope.Scope | R | R2>
 } = internal.runFoldScopedEffect
 
 /**
@@ -7676,11 +7561,7 @@ export const runFoldWhileEffect: {
    * @since 2.0.0
    * @category destructors
    */
-  <S, A, E2, R2>(
-    s: S,
-    cont: Predicate<S>,
-    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>>
+  <S, A, E2, R2>(s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>>
   /**
    * Executes an effectful fold over the stream of values. Stops the fold early
    * when the condition is not fulfilled.
@@ -7713,11 +7594,7 @@ export const runFoldWhileScoped: {
    * @since 2.0.0
    * @category destructors
    */
-  <S, A>(
-    s: S,
-    cont: Predicate<S>,
-    f: (s: S, a: A) => S
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, Scope.Scope | R>
+  <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, Scope.Scope | R>
   /**
    * Executes a pure fold over the stream of values. Returns a scoped value that
    * represents the scope of the stream. Stops the fold early when the condition
@@ -7726,12 +7603,7 @@ export const runFoldWhileScoped: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, S>(
-    self: Stream<A, E, R>,
-    s: S,
-    cont: Predicate<S>,
-    f: (s: S, a: A) => S
-  ): Effect.Effect<S, E, Scope.Scope | R>
+  <A, E, R, S>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<S, E, Scope.Scope | R>
 } = internal.runFoldWhileScoped
 
 /**
@@ -7751,11 +7623,7 @@ export const runFoldWhileScopedEffect: {
    * @since 2.0.0
    * @category destructors
    */
-  <S, A, E2, R2>(
-    s: S,
-    cont: Predicate<S>,
-    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R | Scope.Scope>
+  <S, A, E2, R2>(s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R | Scope.Scope>
   /**
    * Executes an effectful fold over the stream of values. Returns a scoped
    * value that represents the scope of the stream. Stops the fold early when
@@ -7787,9 +7655,7 @@ export const runForEach: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, X, E2, R2>(
-    f: (a: A) => Effect.Effect<X, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>
+  <A, X, E2, R2>(f: (a: A) => Effect.Effect<X, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>
   /**
    * Consumes all elements of the stream, passing them to the specified
    * callback.
@@ -7797,10 +7663,7 @@ export const runForEach: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, X, E2, R2>(
-    self: Stream<A, E, R>,
-    f: (a: A) => Effect.Effect<X, E2, R2>
-  ): Effect.Effect<void, E | E2, R | R2>
+  <A, E, R, X, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<X, E2, R2>): Effect.Effect<void, E | E2, R | R2>
 } = internal.runForEach
 
 /**
@@ -7818,9 +7681,7 @@ export const runForEachChunk: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, X, E2, R2>(
-    f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>
+  <A, X, E2, R2>(f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>
   /**
    * Consumes all elements of the stream, passing them to the specified
    * callback.
@@ -7828,10 +7689,7 @@ export const runForEachChunk: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, X, E2, R2>(
-    self: Stream<A, E, R>,
-    f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>
-  ): Effect.Effect<void, E | E2, R | R2>
+  <A, E, R, X, E2, R2>(self: Stream<A, E, R>, f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>): Effect.Effect<void, E | E2, R | R2>
 } = internal.runForEachChunk
 
 /**
@@ -7849,9 +7707,7 @@ export const runForEachChunkScoped: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, X, E2, R2>(
-    f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>
+  <A, X, E2, R2>(f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>
   /**
    * Like `Stream.runForEachChunk`, but returns a scoped effect so the
    * finalization order can be controlled.
@@ -7859,10 +7715,7 @@ export const runForEachChunkScoped: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, X, E2, R2>(
-    self: Stream<A, E, R>,
-    f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>
-  ): Effect.Effect<void, E | E2, Scope.Scope | R | R2>
+  <A, E, R, X, E2, R2>(self: Stream<A, E, R>, f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>): Effect.Effect<void, E | E2, Scope.Scope | R | R2>
 } = internal.runForEachChunkScoped
 
 /**
@@ -7880,9 +7733,7 @@ export const runForEachScoped: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, X, E2, R2>(
-    f: (a: A) => Effect.Effect<X, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>
+  <A, X, E2, R2>(f: (a: A) => Effect.Effect<X, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>
   /**
    * Like `Stream.forEach`, but returns a scoped effect so the finalization
    * order can be controlled.
@@ -7890,10 +7741,7 @@ export const runForEachScoped: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, X, E2, R2>(
-    self: Stream<A, E, R>,
-    f: (a: A) => Effect.Effect<X, E2, R2>
-  ): Effect.Effect<void, E | E2, Scope.Scope | R | R2>
+  <A, E, R, X, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<X, E2, R2>): Effect.Effect<void, E | E2, Scope.Scope | R | R2>
 } = internal.runForEachScoped
 
 /**
@@ -7911,9 +7759,7 @@ export const runForEachWhile: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E2, R2>(
-    f: (a: A) => Effect.Effect<boolean, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>
+  <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>
   /**
    * Consumes elements of the stream, passing them to the specified callback,
    * and terminating consumption when the callback returns `false`.
@@ -7921,10 +7767,7 @@ export const runForEachWhile: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, E2, R2>(
-    self: Stream<A, E, R>,
-    f: (a: A) => Effect.Effect<boolean, E2, R2>
-  ): Effect.Effect<void, E | E2, R | R2>
+  <A, E, R, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Effect.Effect<void, E | E2, R | R2>
 } = internal.runForEachWhile
 
 /**
@@ -7942,9 +7785,7 @@ export const runForEachWhileScoped: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E2, R2>(
-    f: (a: A) => Effect.Effect<boolean, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>
+  <A, E2, R2>(f: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>
   /**
    * Like `Stream.runForEachWhile`, but returns a scoped effect so the
    * finalization order can be controlled.
@@ -7952,10 +7793,7 @@ export const runForEachWhileScoped: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, E2, R2>(
-    self: Stream<A, E, R>,
-    f: (a: A) => Effect.Effect<boolean, E2, R2>
-  ): Effect.Effect<void, E | E2, Scope.Scope | R | R2>
+  <A, E, R, E2, R2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Effect.Effect<void, E | E2, Scope.Scope | R | R2>
 } = internal.runForEachWhileScoped
 
 /**
@@ -8008,9 +7846,7 @@ export const runIntoPubSubScoped: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E>(
-    pubsub: PubSub.PubSub<Take.Take<A, E>>
-  ): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>
+  <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>
   /**
    * Like `Stream.runIntoPubSub`, but provides the result as a scoped effect to
    * allow for scope composition.
@@ -8062,9 +7898,7 @@ export const runIntoQueueElementsScoped: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E>(
-    queue: Queue.Enqueue<Exit.Exit<A, Option.Option<E>>>
-  ): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>
+  <A, E>(queue: Queue.Enqueue<Exit.Exit<A, Option.Option<E>>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>
   /**
    * Like `Stream.runIntoQueue`, but provides the result as a scoped [[ZIO]]
    * to allow for scope composition.
@@ -8093,9 +7927,7 @@ export const runIntoQueueScoped: {
    * @since 2.0.0
    * @category destructors
    */
-  <A, E>(
-    queue: Queue.Enqueue<Take.Take<A, E>>
-  ): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>
+  <A, E>(queue: Queue.Enqueue<Take.Take<A, E>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>
   /**
    * Like `Stream.runIntoQueue`, but provides the result as a scoped effect
    * to allow for scope composition.
@@ -8124,17 +7956,12 @@ export const runScoped: {
    * @since 2.0.0
    * @category destructors
    */
-  <A2, A, E2, R2>(
-    sink: Sink.Sink<A2, A, unknown, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<A2, E2 | E, Scope.Scope | R2 | R>
+  <A2, A, E2, R2>(sink: Sink.Sink<A2, A, unknown, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<A2, E2 | E, Scope.Scope | R2 | R>
   /**
    * @since 2.0.0
    * @category destructors
    */
-  <A, E, R, A2, E2, R2>(
-    self: Stream<A, E, R>,
-    sink: Sink.Sink<A2, A, unknown, E2, R2>
-  ): Effect.Effect<A2, E | E2, Scope.Scope | R | R2>
+  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<A2, A, unknown, E2, R2>): Effect.Effect<A2, E | E2, Scope.Scope | R | R2>
 } = internal.runScoped
 
 /**
@@ -8216,10 +8043,7 @@ export const scanEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <S, A, E2, R2>(
-    s: S,
-    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<S, E2 | E, R2 | R>
+  <S, A, E2, R2>(s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<S, E2 | E, R2 | R>
   /**
    * Statefully and effectfully maps over the elements of this stream to produce
    * all intermediate results of type `S` given an initial S.
@@ -8227,11 +8051,7 @@ export const scanEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A, E, R, S, E2, R2>(
-    self: Stream<A, E, R>,
-    s: S,
-    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ): Stream<S, E | E2, R | R2>
+  <A, E, R, S, E2, R2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Stream<S, E | E2, R | R2>
 } = internal.scanEffect
 
 /**
@@ -8285,9 +8105,7 @@ export const scanReduceEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A2, A, E2, R2>(
-    f: (a2: A2 | A, a: A) => Effect.Effect<A2 | A, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>
+  <A2, A, E2, R2>(f: (a2: A2 | A, a: A) => Effect.Effect<A2 | A, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>
   /**
    * Statefully and effectfully maps over the elements of this stream to produce
    * all intermediate results.
@@ -8316,9 +8134,7 @@ export const schedule: {
    * @since 2.0.0
    * @category utils
    */
-  <X, A0 extends A, R2, A>(
-    schedule: Schedule.Schedule<X, A0, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <X, A0 extends A, R2, A>(schedule: Schedule.Schedule<X, A0, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
   /**
    * Schedules the output of the stream using the provided `schedule`.
    *
@@ -8578,9 +8394,7 @@ export const split: {
    * @since 2.0.0
    * @category utils
    */
-  <A, B extends A>(
-    refinement: Refinement<NoInfer<A>, B>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<Exclude<A, B>>, E, R>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<Exclude<A, B>>, E, R>
   /**
    * Splits elements based on a predicate or refinement.
    *
@@ -8884,9 +8698,7 @@ export const takeUntilEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A, E2, R2>(
-    predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <A, E2, R2>(predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   /**
    * Takes all elements of the stream until the specified effectual predicate
    * evaluates to `true`.
@@ -8894,10 +8706,7 @@ export const takeUntilEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A, E, R, E2, R2>(
-    self: Stream<A, E, R>,
-    predicate: (a: A) => Effect.Effect<boolean, E2, R2>
-  ): Stream<A, E | E2, R | R2>
+  <A, E, R, E2, R2>(self: Stream<A, E, R>, predicate: (a: A) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.takeUntilEffect
 
 /**
@@ -9045,9 +8854,7 @@ export const tap: {
    * @since 2.0.0
    * @category sequencing
    */
-  <A, X, E2, R2>(
-    f: (a: NoInfer<A>) => Effect.Effect<X, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <A, X, E2, R2>(f: (a: NoInfer<A>) => Effect.Effect<X, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   /**
    * Adds an effect to consumption of every element of the stream.
    *
@@ -9127,9 +8934,7 @@ export const tapError: {
    * @since 2.0.0
    * @category sequencing
    */
-  <E, X, E2, R2>(
-    f: (error: NoInfer<E>) => Effect.Effect<X, E2, R2>
-  ): <A, R>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>
+  <E, X, E2, R2>(f: (error: NoInfer<E>) => Effect.Effect<X, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>
   /**
    * Returns a stream that effectfully "peeks" at the failure of the stream.
    *
@@ -9154,9 +8959,7 @@ export const tapErrorCause: {
    * @since 2.0.0
    * @category utils
    */
-  <E, X, E2, R2>(
-    f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<X, E2, R2>
-  ): <A, R>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>
+  <E, X, E2, R2>(f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<X, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>
   /**
    * Returns a stream that effectfully "peeks" at the cause of failure of the
    * stream.
@@ -9552,10 +9355,7 @@ export const timeoutFailCause: {
    * @since 2.0.0
    * @category utils
    */
-  <E2>(
-    cause: LazyArg<Cause.Cause<E2>>,
-    duration: Duration.DurationInput
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R>
+  <E2>(cause: LazyArg<Cause.Cause<E2>>, duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R>
   /**
    * Fails the stream with given cause if it does not produce a value after d
    * duration.
@@ -9585,10 +9385,7 @@ export const timeoutTo: {
    * @since 2.0.0
    * @category utils
    */
-  <A2, E2, R2>(
-    duration: Duration.DurationInput,
-    that: Stream<A2, E2, R2>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>
+  <A2, E2, R2>(duration: Duration.DurationInput, that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>
   /**
    * Switches the stream if it does not produce a value after the specified
    * duration.
@@ -10021,10 +9818,7 @@ export const updateService: {
    * @since 2.0.0
    * @category context
    */
-  <I, S>(
-    tag: Context.Tag<I, S>,
-    f: (service: NoInfer<S>) => NoInfer<S>
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, I | R>
+  <I, S>(tag: Context.Tag<I, S>, f: (service: NoInfer<S>) => NoInfer<S>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, I | R>
   /**
    * Updates the specified service within the context of the `Stream`.
    *
@@ -10091,9 +9885,7 @@ export const whenCaseEffect: {
    * @since 2.0.0
    * @category utils
    */
-  <A, A2, E2, R2>(
-    pf: (a: A) => Option.Option<Stream<A2, E2, R2>>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <A, A2, E2, R2>(pf: (a: A) => Option.Option<Stream<A2, E2, R2>>): <E, R>(self: Effect.Effect<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   /**
    * Returns the stream when the given partial function is defined for the given
    * effectful value, otherwise returns an empty stream.
@@ -10146,10 +9938,7 @@ export const withSpan: {
    * @since 2.0.0
    * @category tracing
    */
-  (
-    name: string,
-    options?: Tracer.SpanOptions | undefined
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, Tracer.ParentSpan>>
+  (name: string, options?: Tracer.SpanOptions | undefined): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, Tracer.ParentSpan>>
   /**
    * Wraps the stream with a new span for tracing.
    *
@@ -10256,9 +10045,7 @@ export const zipFlatten: {
    * @since 2.0.0
    * @category zipping
    */
-  <A2, E2, R2>(
-    that: Stream<A2, E2, R2>
-  ): <A extends ReadonlyArray<any>, E, R>(self: Stream<A, E, R>) => Stream<[...A, A2], E2 | E, R2 | R>
+  <A2, E2, R2>(that: Stream<A2, E2, R2>): <A extends ReadonlyArray<any>, E, R>(self: Stream<A, E, R>) => Stream<[...A, A2], E2 | E, R2 | R>
   /**
    * Zips this stream with another point-wise and emits tuples of elements from
    * both streams.
@@ -10268,10 +10055,7 @@ export const zipFlatten: {
    * @since 2.0.0
    * @category zipping
    */
-  <A extends ReadonlyArray<any>, E, R, A2, E2, R2>(
-    self: Stream<A, E, R>,
-    that: Stream<A2, E2, R2>
-  ): Stream<[...A, A2], E | E2, R | R2>
+  <A extends ReadonlyArray<any>, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[...A, A2], E | E2, R | R2>
 } = internal.zipFlatten
 
 /**
@@ -10412,10 +10196,7 @@ export const zipAllRight: {
    * @since 2.0.0
    * @category zipping
    */
-  <A2, E2, R2>(
-    that: Stream<A2, E2, R2>,
-    defaultRight: A2
-  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <A2, E2, R2>(that: Stream<A2, E2, R2>, defaultRight: A2): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   /**
    * Zips this stream with another point-wise, and keeps only elements from the
    * other stream.
@@ -10925,10 +10706,7 @@ export const zipLatestWith: {
    * @since 2.0.0
    * @category zipping
    */
-  <AR, ER, RR, AL, A>(
-    right: Stream<AR, ER, RR>,
-    f: (left: AL, right: AR) => A
-  ): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>
+  <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: AL, right: AR) => A): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>
   /**
    * Zips the two streams so that when a value is emitted by either of the two
    * streams, it is combined with the latest value from the other stream to
@@ -11061,10 +10839,7 @@ export const zipWith: {
    * @since 2.0.0
    * @category zipping
    */
-  <AR, ER, RR, AL, A>(
-    right: Stream<AR, ER, RR>,
-    f: (left: AL, right: AR) => A
-  ): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>
+  <AR, ER, RR, AL, A>(right: Stream<AR, ER, RR>, f: (left: AL, right: AR) => A): <EL, RL>(left: Stream<AL, EL, RL>) => Stream<A, EL | ER, RL | RR>
   /**
    * Zips this stream with another point-wise and applies the function to the
    * paired elements.