effect 2.0.0-next.35 → 2.0.0-next.37

package/dist/declarations/src/Stream.d.ts

@@ -0,0 +1,3577 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Cause from "./Cause.js";
+import type * as Channel from "./Channel.js";
+import type * as Chunk from "./Chunk.js";
+import type * as Context from "./Context.js";
+import type * as Deferred from "./Deferred.js";
+import type * as Duration from "./Duration.js";
+import type * as Effect from "./Effect.js";
+import type * as Either from "./Either.js";
+import type * as Exit from "./Exit.js";
+import type { LazyArg } from "./Function.js";
+import type * as GroupBy from "./GroupBy.js";
+import type { TypeLambda } from "./HKT.js";
+import type * as Hub from "./Hub.js";
+import type * as Layer from "./Layer.js";
+import type * as Option from "./Option.js";
+import type * as Order from "./Order.js";
+import type { Pipeable } from "./Pipeable.js";
+import type { Predicate, Refinement } from "./Predicate.js";
+import type * as Queue from "./Queue.js";
+import type * as Schedule from "./Schedule.js";
+import type * as Scope from "./Scope.js";
+import type * as Sink from "./Sink.js";
+import type * as Emit from "./StreamEmit.js";
+import type * as HaltStrategy from "./StreamHaltStrategy.js";
+import type * as Take from "./Take.js";
+import type * as Tracer from "./Tracer.js";
+import type * as Unify from "./Unify.js";
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export declare const StreamTypeId: unique symbol;
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export type StreamTypeId = typeof StreamTypeId;
+/**
+ * A `Stream<R, E, A>` is a description of a program that, when evaluated, may
+ * emit zero or more values of type `A`, may fail with errors of type `E`, and
+ * uses an context of type `R`. One way to think of `Stream` is as a
+ * `Effect` program that could emit multiple values.
+ *
+ * `Stream` is a purely functional *pull* based stream. Pull based streams offer
+ * inherent laziness and backpressure, relieving users of the need to manage
+ * buffers between operators. As an optimization, `Stream` does not emit
+ * single values, but rather an array of values. This allows the cost of effect
+ * evaluation to be amortized.
+ *
+ * `Stream` forms a monad on its `A` type parameter, and has error management
+ * facilities for its `E` type parameter, modeled similarly to `Effect` (with
+ * some adjustments for the multiple-valued nature of `Stream`). These aspects
+ * allow for rich and expressive composition of streams.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Stream<R, E, A> extends Stream.Variance<R, E, A>, Pipeable {
+    [Unify.typeSymbol]?: unknown;
+    [Unify.unifySymbol]?: StreamUnify<this>;
+    [Unify.blacklistSymbol]?: StreamUnifyBlacklist;
+}
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface StreamUnify<A extends {
+    [Unify.typeSymbol]?: any;
+}> extends Effect.EffectUnify<A> {
+    Stream?: () => A[Unify.typeSymbol] extends Stream<infer R0, infer E0, infer A0> | infer _ ? Stream<R0, E0, A0> : never;
+}
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export interface StreamUnifyBlacklist extends Effect.EffectUnifyBlacklist {
+    Effect?: true;
+}
+/**
+ * @since 1.0.0
+ * @category models
+ */
+declare module "./Effect" {
+    interface Effect<R, E, A> extends Stream<R, E, A> {
+    }
+    interface EffectUnifyBlacklist {
+        Stream?: true;
+    }
+}
+/**
+ * @category type lambdas
+ * @since 1.0.0
+ */
+export interface StreamTypeLambda extends TypeLambda {
+    readonly type: Stream<this["Out2"], this["Out1"], this["Target"]>;
+}
+/**
+ * @since 1.0.0
+ */
+export declare namespace Stream {
+    /**
+     * @since 1.0.0
+     * @category models
+     */
+    interface Variance<R, E, A> {
+        readonly [StreamTypeId]: {
+            _R: (_: never) => R;
+            _E: (_: never) => E;
+            _A: (_: never) => A;
+        };
+    }
+    /**
+     * @since 1.0.0
+     * @category models
+     */
+    type DynamicTuple<T, N extends number> = N extends N ? number extends N ? Array<T> : DynamicTupleOf<T, N, []> : never;
+    /**
+     * @since 1.0.0
+     * @category models
+     */
+    type DynamicTupleOf<T, N extends number, R extends Array<unknown>> = R["length"] extends N ? R : DynamicTupleOf<T, N, [T, ...R]>;
+}
+/**
+ * The default chunk size used by the various combinators and constructors of
+ * `Stream`.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const DefaultChunkSize: number;
+/**
+ * Creates a stream from a single value that will get cleaned up after the
+ * stream is consumed.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const acquireRelease: <R, E, A, R2, _>(acquire: Effect.Effect<R, E, A>, release: (resource: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R2, never, _>) => Stream<R | R2, E, A>;
+/**
+ * Aggregates elements of this stream using the provided sink for as long as
+ * the downstream operators on the stream are busy.
+ *
+ * This operator divides the stream into two asynchronous "islands". Operators
+ * upstream of this operator run on one fiber, while downstream operators run
+ * on another. Whenever the downstream fiber is busy processing elements, the
+ * upstream fiber will feed elements into the sink until it signals
+ * completion.
+ *
+ * Any sink can be used here, but see `Sink.foldWeightedEffect` and
+ * `Sink.foldUntilEffect` for sinks that cover the common usecases.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const aggregate: {
+    <R2, E2, A, A2, B>(sink: Sink.Sink<R2, E2, A | A2, A2, B>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, B>;
+    <R, E, R2, E2, A, A2, B>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A | A2, A2, B>): Stream<R | R2, E | E2, B>;
+};
+/**
+ * Like `aggregateWithinEither`, but only returns the `Right` results.
+ *
+ * @param sink A `Sink` used to perform the aggregation.
+ * @param schedule A `Schedule` used to signal when to stop the aggregation.
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const aggregateWithin: {
+    <R2, E2, A, A2, B, R3, C>(sink: Sink.Sink<R2, E2, A | A2, A2, B>, schedule: Schedule.Schedule<R3, Option.Option<B>, C>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R3 | R, E2 | E, B>;
+    <R, E, R2, E2, A, A2, B, R3, C>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A | A2, A2, B>, schedule: Schedule.Schedule<R3, Option.Option<B>, C>): Stream<R | R2 | R3, E | E2, B>;
+};
+/**
+ * Aggregates elements using the provided sink until it completes, or until
+ * the delay signalled by the schedule has passed.
+ *
+ * This operator divides the stream into two asynchronous islands. Operators
+ * upstream of this operator run on one fiber, while downstream operators run
+ * on another. Elements will be aggregated by the sink until the downstream
+ * fiber pulls the aggregated value, or until the schedule's delay has passed.
+ *
+ * Aggregated elements will be fed into the schedule to determine the delays
+ * between pulls.
+ *
+ * @param sink A `Sink` used to perform the aggregation.
+ * @param schedule A `Schedule` used to signal when to stop the aggregation.
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const aggregateWithinEither: {
+    <R2, E2, A, A2, B, R3, C>(sink: Sink.Sink<R2, E2, A | A2, A2, B>, schedule: Schedule.Schedule<R3, Option.Option<B>, C>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R3 | R, E2 | E, Either.Either<C, B>>;
+    <R, E, R2, E2, A, A2, B, R3, C>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A | A2, A2, B>, schedule: Schedule.Schedule<R3, Option.Option<B>, C>): Stream<R | R2 | R3, E | E2, Either.Either<C, B>>;
+};
+/**
+ * Maps the success values of this stream to the specified constant value.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const as: {
+    <B>(value: B): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, B>;
+    <R, E, A, B>(self: Stream<R, E, A>, value: B): Stream<R, E, B>;
+};
+declare const _async: <R, E, A>(register: (emit: Emit.Emit<R, E, A, void>) => void, outputBuffer?: number) => Stream<R, E, A>;
+export { 
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times. The optionality of the error type `E` can be used to signal the end
+ * of the stream, by setting it to `None`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+_async as async };
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times The registration of the callback itself returns an effect. The
+ * optionality of the error type `E` can be used to signal the end of the
+ * stream, by setting it to `None`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const asyncEffect: <R, E, A>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<R, E, unknown>, outputBuffer?: number) => Stream<R, E, A>;
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times. The registration of the callback returns either a canceler or
+ * synchronously returns a stream. The optionality of the error type `E` can
+ * be used to signal the end of the stream, by setting it to `None`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const asyncInterrupt: <R, E, A>(register: (emit: Emit.Emit<R, E, A, void>) => Either.Either<Effect.Effect<R, never, unknown>, Stream<R, E, A>>, outputBuffer?: number) => Stream<R, E, A>;
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times. The registration of the callback can possibly return the stream
+ * synchronously. The optionality of the error type `E` can be used to signal
+ * the end of the stream, by setting it to `None`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const asyncOption: <R, E, A>(register: (emit: Emit.Emit<R, E, A, void>) => Option.Option<Stream<R, E, A>>, outputBuffer?: number) => Stream<R, E, A>;
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times. The registration of the callback itself returns an a scoped
+ * resource. The optionality of the error type `E` can be used to signal the
+ * end of the stream, by setting it to `None`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const asyncScoped: <R, E, A>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<R, E, unknown>, outputBuffer?: number) => Stream<Exclude<R, Scope.Scope>, E, A>;
+/**
+ * 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
+ * the following elements through that.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const branchAfter: {
+    <A, R2, E2, A2>(n: number, f: (input: Chunk.Chunk<A>) => Stream<R2, E2, A2>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, n: number, f: (input: Chunk.Chunk<A>) => Stream<R2, E2, A2>): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Fan out the stream, producing a list of streams that have the same elements
+ * as this stream. The driver stream will only ever advance the `maximumLag`
+ * chunks before the slowest downstream stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const broadcast: {
+    <N extends number>(n: N, maximumLag: number): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Stream<never, E, A>, N>>;
+    <R, E, A, N extends number>(self: Stream<R, E, A>, n: N, maximumLag: number): Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Stream<never, E, A>, N>>;
+};
+/**
+ * Fan out the stream, producing a dynamic number of streams that have the
+ * same elements as this stream. The driver stream will only ever advance the
+ * `maximumLag` chunks before the slowest downstream stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const broadcastDynamic: {
+    (maximumLag: number): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Stream<never, E, A>>;
+    <R, E, A>(self: Stream<R, E, A>, maximumLag: number): Effect.Effect<Scope.Scope | R, never, Stream<never, E, A>>;
+};
+/**
+ * Converts the stream to a scoped list of queues. Every value will be
+ * replicated to every queue with the slowest queue being allowed to buffer
+ * `maximumLag` chunks before the driver is back pressured.
+ *
+ * Queues can unsubscribe from upstream by shutting down.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const broadcastedQueues: {
+    <N extends number>(n: N, maximumLag: number): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Queue.Dequeue<Take.Take<E, A>>, N>>;
+    <R, E, A, N extends number>(self: Stream<R, E, A>, n: N, maximumLag: number): Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Queue.Dequeue<Take.Take<E, A>>, N>>;
+};
+/**
+ * Converts the stream to a scoped dynamic amount of queues. Every chunk will
+ * be replicated to every queue with the slowest queue being allowed to buffer
+ * `maximumLag` chunks before the driver is back pressured.
+ *
+ * Queues can unsubscribe from upstream by shutting down.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const broadcastedQueuesDynamic: {
+    (maximumLag: number): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Effect.Effect<Scope.Scope, never, Queue.Dequeue<Take.Take<E, A>>>>;
+    <R, E, A>(self: Stream<R, E, A>, maximumLag: number): Effect.Effect<Scope.Scope | R, never, Effect.Effect<Scope.Scope, never, Queue.Dequeue<Take.Take<E, A>>>>;
+};
+/**
+ * Allows a faster producer to progress independently of a slower consumer by
+ * buffering up to `capacity` elements in a queue.
+ *
+ * @note This combinator destroys the chunking structure. It's recommended to
+ *       use rechunk afterwards. Additionally, prefer capacities that are powers
+ *       of 2 for better performance.
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const buffer: {
+    (options: {
+        readonly capacity: "unbounded";
+    } | {
+        readonly capacity: number;
+        readonly strategy?: "dropping" | "sliding" | "suspend";
+    }): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, options: {
+        readonly capacity: "unbounded";
+    } | {
+        readonly capacity: number;
+        readonly strategy?: "dropping" | "sliding" | "suspend";
+    }): Stream<R, E, A>;
+};
+/**
+ * Allows a faster producer to progress independently of a slower consumer by
+ * buffering up to `capacity` chunks in a queue.
+ *
+ * @note Prefer capacities that are powers of 2 for better performance.
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const bufferChunks: {
+    (options: {
+        readonly capacity: number;
+        readonly strategy?: "dropping" | "sliding" | "suspend";
+    }): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, options: {
+        readonly capacity: number;
+        readonly strategy?: "dropping" | "sliding" | "suspend";
+    }): Stream<R, E, A>;
+};
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails with a typed error.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchAll: {
+    <E, R2, E2, A2>(f: (error: E) => Stream<R2, E2, A2>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2, A2 | A>;
+    <R, A, E, R2, E2, A2>(self: Stream<R, E, A>, f: (error: E) => Stream<R2, E2, A2>): Stream<R | R2, E2, A | A2>;
+};
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails. Allows recovery from all causes of failure, including
+ * interruption if the stream is uninterruptible.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchAllCause: {
+    <E, R2, E2, A2>(f: (cause: Cause.Cause<E>) => Stream<R2, E2, A2>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2, A2 | A>;
+    <R, A, E, R2, E2, A2>(self: Stream<R, E, A>, f: (cause: Cause.Cause<E>) => Stream<R2, E2, A2>): Stream<R | R2, E2, A | A2>;
+};
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails with some typed error.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchSome: {
+    <E, R2, E2, A2>(pf: (error: E) => Option.Option<Stream<R2, E2, A2>>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A2 | A>;
+    <R, A, E, R2, E2, A2>(self: Stream<R, E, A>, pf: (error: E) => Option.Option<Stream<R2, E2, A2>>): Stream<R | R2, E | E2, A | A2>;
+};
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails with an error matching the given `_tag`.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchTag: {
+    <K extends E["_tag"] & string, E extends {
+        _tag: string;
+    }, R1, E1, A1>(k: K, f: (e: Extract<E, {
+        _tag: K;
+    }>) => Stream<R1, E1, A1>): <R, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | Exclude<E, {
+        _tag: K;
+    }>, A1 | A>;
+    <R, E extends {
+        _tag: string;
+    }, A, K extends E["_tag"] & string, R1, E1, A1>(self: Stream<R, E, A>, k: K, f: (e: Extract<E, {
+        _tag: K;
+    }>) => Stream<R1, E1, A1>): Stream<R | R1, E1 | Exclude<E, {
+        _tag: K;
+    }>, A | A1>;
+};
+/**
+ * Switches over to the stream produced by one of the provided functions, in
+ * case this one fails with an error matching one of the given `_tag`'s.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchTags: {
+    <E extends {
+        _tag: string;
+    }, Cases extends {
+        [K in E["_tag"]]+?: ((error: Extract<E, {
+            _tag: K;
+        }>) => Stream<any, any, any>) | undefined;
+    }>(cases: Cases): <R, A>(self: Stream<R, E, A>) => Stream<R | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer R, infer _E, infer _A> ? R : never;
+    }[keyof Cases], Exclude<E, {
+        _tag: keyof Cases;
+    }> | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer E, infer _A> ? E : never;
+    }[keyof Cases], A | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer _E, infer A> ? A : never;
+    }[keyof Cases]>;
+    <R, E extends {
+        _tag: string;
+    }, A, Cases extends {
+        [K in E["_tag"]]+?: ((error: Extract<E, {
+            _tag: K;
+        }>) => Stream<any, any, any>) | undefined;
+    }>(self: Stream<R, E, A>, cases: Cases): Stream<R | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer R, infer _E, infer _A> ? R : never;
+    }[keyof Cases], Exclude<E, {
+        _tag: keyof Cases;
+    }> | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer E, infer _A> ? E : never;
+    }[keyof Cases], A | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer _E, infer A> ? A : never;
+    }[keyof Cases]>;
+};
+/**
+ * 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,
+ * including interruption if the stream is uninterruptible.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchSomeCause: {
+    <E, R2, E2, A2>(pf: (cause: Cause.Cause<E>) => Option.Option<Stream<R2, E2, A2>>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A2 | A>;
+    <R, A, E, R2, E2, A2>(self: Stream<R, E, A>, pf: (cause: Cause.Cause<E>) => Option.Option<Stream<R2, E2, A2>>): Stream<R | R2, E | E2, A | A2>;
+};
+/**
+ * Returns a new stream that only emits elements that are not equal to the
+ * previous element emitted, using natural equality to determine whether two
+ * elements are equal.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const changes: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+/**
+ * Returns a new stream that only emits elements that are not equal to the
+ * previous element emitted, using the specified function to determine whether
+ * two elements are equal.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const changesWith: {
+    <A>(f: (x: A, y: A) => boolean): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, f: (x: A, y: A) => boolean): Stream<R, E, A>;
+};
+/**
+ * Returns a new stream that only emits elements that are not equal to the
+ * previous element emitted, using the specified effectual function to
+ * determine whether two elements are equal.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const changesWithEffect: {
+    <A, R2, E2>(f: (x: A, y: A) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2>(self: Stream<R, E, A>, f: (x: A, y: A) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Exposes the underlying chunks of the stream as a stream of chunks of
+ * elements.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const chunks: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
+/**
+ * Performs the specified stream transformation with the chunk structure of
+ * the stream exposed.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const chunksWith: <R, E, A, R2, E2, A2>(f: (stream: Stream<R, E, Chunk.Chunk<A>>) => Stream<R2, E2, Chunk.Chunk<A2>>) => (self: Stream<R, E, A>) => Stream<R | R2, E | E2, A2>;
+/**
+ * Combines the elements from this stream and the specified stream by
+ * repeatedly applying the function `f` to extract an element using both sides
+ * and conceptually "offer" it to the destination stream. `f` can maintain
+ * some internal state to control the combining process, with the initial
+ * state being specified by `s`.
+ *
+ * Where possible, prefer `Stream.combineChunks` for a more efficient
+ * implementation.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const combine: {
+    <R2, E2, A2, S, R3, E, A, R4, R5, A3>(that: Stream<R2, E2, A2>, s: S, f: (s: S, pullLeft: Effect.Effect<R3, Option.Option<E>, A>, pullRight: Effect.Effect<R4, Option.Option<E2>, A2>) => Effect.Effect<R5, never, Exit.Exit<Option.Option<E2 | E>, readonly [A3, S]>>): <R>(self: Stream<R, E, A>) => Stream<R2 | R3 | R4 | R5 | R, E2 | E, A3>;
+    <R, R2, E2, A2, S, R3, E, A, R4, R5, A3>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, s: S, f: (s: S, pullLeft: Effect.Effect<R3, Option.Option<E>, A>, pullRight: Effect.Effect<R4, Option.Option<E2>, A2>) => Effect.Effect<R5, never, Exit.Exit<Option.Option<E2 | E>, readonly [A3, S]>>): Stream<R | R2 | R3 | R4 | R5, E2 | E, A3>;
+};
+/**
+ * Combines the chunks from this stream and the specified stream by repeatedly
+ * applying the function `f` to extract a chunk using both sides and
+ * conceptually "offer" it to the destination stream. `f` can maintain some
+ * internal state to control the combining process, with the initial state
+ * being specified by `s`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const combineChunks: {
+    <R2, E2, A2, S, R3, E, A, R4, R5, A3>(that: Stream<R2, E2, A2>, s: S, f: (s: S, pullLeft: Effect.Effect<R3, Option.Option<E>, Chunk.Chunk<A>>, pullRight: Effect.Effect<R4, Option.Option<E2>, Chunk.Chunk<A2>>) => Effect.Effect<R5, never, Exit.Exit<Option.Option<E2 | E>, readonly [Chunk.Chunk<A3>, S]>>): <R>(self: Stream<R, E, A>) => Stream<R2 | R3 | R4 | R5 | R, E2 | E, A3>;
+    <R, R2, E2, A2, S, R3, E, A, R4, R5, A3>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, s: S, f: (s: S, pullLeft: Effect.Effect<R3, Option.Option<E>, Chunk.Chunk<A>>, pullRight: Effect.Effect<R4, Option.Option<E2>, Chunk.Chunk<A2>>) => Effect.Effect<R5, never, Exit.Exit<Option.Option<E2 | E>, readonly [Chunk.Chunk<A3>, S]>>): Stream<R | R2 | R3 | R4 | R5, E2 | E, A3>;
+};
+/**
+ * Concatenates the specified stream with this stream, resulting in a stream
+ * that emits the elements from this stream and then the elements from the
+ * specified stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const concat: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A | A2>;
+};
+/**
+ * Concatenates all of the streams in the chunk to one stream.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const concatAll: <R, E, A>(streams: Chunk.Chunk<Stream<R, E, A>>) => Stream<R, E, A>;
+/**
+ * Composes this stream with the specified stream to create a cartesian
+ * product of elements. The `that` stream would be run multiple times, for
+ * every element in the `this` stream.
+ *
+ * See also `Stream.zip` for the more common point-wise variant.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const cross: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, readonly [A, A2]>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, readonly [A, A2]>;
+};
+/**
+ * Composes this stream with the specified stream to create a cartesian
+ * product of elements, but keeps only elements from this stream. The `that`
+ * stream would be run multiple times, for every element in the `this` stream.
+ *
+ * See also `Stream.zipLeft` for the more common point-wise variant.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const crossLeft: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Composes this stream with the specified stream to create a cartesian
+ * product of elements, but keeps only elements from the other stream. The
+ * `that` stream would be run multiple times, for every element in the `this`
+ * stream.
+ *
+ * See also `Stream.zipRight` for the more common point-wise variant.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const crossRight: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Composes this stream with the specified stream to create a cartesian
+ * product of elements with a specified function. The `that` stream would be
+ * run multiple times, for every element in the `this` stream.
+ *
+ * See also `Stream.zipWith` for the more common point-wise variant.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const crossWith: {
+    <R2, E2, B, A, C>(that: Stream<R2, E2, B>, f: (a: A, b: B) => C): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, C>;
+    <R, E, R2, E2, B, A, C>(self: Stream<R, E, A>, that: Stream<R2, E2, B>, f: (a: A, b: B) => C): Stream<R | R2, E | E2, C>;
+};
+/**
+ * Delays the emission of values by holding new values for a set duration. If
+ * no new values arrive during that time the value is emitted, however if a
+ * new value is received during the holding period the previous value is
+ * discarded and the process is repeated with the new value.
+ *
+ * This operator is useful if you have a stream of "bursty" events which
+ * eventually settle down and you only need the final event of the burst. For
+ * example, a search engine may only want to initiate a search after a user
+ * has paused typing so as to not prematurely recommend results.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const debounce: {
+    (duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, duration: Duration.DurationInput): Stream<R, E, A>;
+};
+/**
+ * The stream that dies with the specified defect.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const die: (defect: unknown) => Stream<never, never, never>;
+/**
+ * The stream that dies with the specified lazily evaluated defect.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const dieSync: (evaluate: LazyArg<unknown>) => Stream<never, never, never>;
+/**
+ * The stream that dies with an exception described by `message`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const dieMessage: (message: string) => Stream<never, never, never>;
+/**
+ * More powerful version of `Stream.broadcast`. Allows to provide a function
+ * that determines what queues should receive which elements. The decide
+ * function will receive the indices of the queues in the resulting list.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const distributedWith: {
+    <N extends number, A>(options: {
+        readonly size: N;
+        readonly maximumLag: number;
+        readonly decide: (a: A) => Effect.Effect<never, never, Predicate<number>>;
+    }): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>, N>>;
+    <R, E, N extends number, A>(self: Stream<R, E, A>, options: {
+        readonly size: N;
+        readonly maximumLag: number;
+        readonly decide: (a: A) => Effect.Effect<never, never, Predicate<number>>;
+    }): Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>, N>>;
+};
+/**
+ * More powerful version of `Stream.distributedWith`. This returns a function
+ * that will produce new queues and corresponding indices. You can also
+ * provide a function that will be executed after the final events are
+ * enqueued in all queues. Shutdown of the queues is handled by the driver.
+ * Downstream users can also shutdown queues manually. In this case the driver
+ * will continue but no longer backpressure on them.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const distributedWithDynamic: {
+    <E, A, _>(options: {
+        readonly maximumLag: number;
+        readonly decide: (a: A) => Effect.Effect<never, never, Predicate<number>>;
+    }): <R>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Effect.Effect<never, never, readonly [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>>;
+    <R, E, A, _>(self: Stream<R, E, A>, options: {
+        readonly maximumLag: number;
+        readonly decide: (a: A) => Effect.Effect<never, never, Predicate<number>>;
+    }): Effect.Effect<Scope.Scope | R, never, Effect.Effect<never, never, readonly [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>>;
+};
+/**
+ * Converts this stream to a stream that executes its effects but emits no
+ * elements. Useful for sequencing effects using streams:
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const drain: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, never>;
+/**
+ * Drains the provided stream in the background for as long as this stream is
+ * running. If this stream ends before `other`, `other` will be interrupted.
+ * If `other` fails, this stream will fail with that error.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const drainFork: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Drops the specified number of elements from this stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const drop: {
+    (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>;
+};
+/**
+ * Drops the last specified number of elements from this stream.
+ *
+ * @note This combinator keeps `n` elements in memory. Be careful with big
+ *       numbers.
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const dropRight: {
+    (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>;
+};
+/**
+ * Drops all elements of the stream until the specified predicate evaluates to
+ * `true`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const dropUntil: {
+    <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A, X extends A>(self: Stream<R, E, A>, predicate: Predicate<X>): Stream<R, E, A>;
+};
+/**
+ * Drops all elements of the stream until the specified effectful predicate
+ * evaluates to `true`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const dropUntilEffect: {
+    <A, X extends A, R2, E2>(predicate: (a: X) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, X extends A, R2, E2>(self: Stream<R, E, A>, predicate: (a: X) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Drops all elements of the stream for as long as the specified predicate
+ * evaluates to `true`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const dropWhile: {
+    <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A, X extends A>(self: Stream<R, E, A>, predicate: Predicate<X>): Stream<R, E, A>;
+};
+/**
+ * Drops all elements of the stream for as long as the specified predicate
+ * produces an effect that evalutates to `true`
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const dropWhileEffect: {
+    <A, X extends A, R2, E2>(predicate: (a: X) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, X extends A, R2, E2>(self: Stream<R, E, A>, predicate: (a: X) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Returns a stream whose failures and successes have been lifted into an
+ * `Either`. The resulting stream cannot fail, because the failures have been
+ * exposed as part of the `Either` success case.
+ *
+ * @note The stream will end as soon as the first error occurs.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const either: <R, E, A>(self: Stream<R, E, A>) => Stream<R, never, Either.Either<E, A>>;
+/**
+ * The empty stream.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const empty: Stream<never, never, never>;
+/**
+ * Executes the provided finalizer after this stream's finalizers run.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const ensuring: {
+    <R2, _>(finalizer: Effect.Effect<R2, never, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
+    <R, E, A, R2, _>(self: Stream<R, E, A>, finalizer: Effect.Effect<R2, never, _>): Stream<R | R2, E, A>;
+};
+/**
+ * Executes the provided finalizer after this stream's finalizers run.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const ensuringWith: {
+    <E, R2>(finalizer: (exit: Exit.Exit<E, unknown>) => Effect.Effect<R2, never, unknown>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
+    <R, E, A, R2>(self: Stream<R, E, A>, finalizer: (exit: Exit.Exit<E, unknown>) => Effect.Effect<R2, never, unknown>): Stream<R | R2, E, A>;
+};
+/**
+ * Accesses the whole context of the stream.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const context: <R>() => Stream<R, never, Context.Context<R>>;
+/**
+ * Accesses the context of the stream.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const contextWith: <R, A>(f: (env: Context.Context<R>) => A) => Stream<R, never, A>;
+/**
+ * Accesses the context of the stream in the context of an effect.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const contextWithEffect: <R0, R, E, A>(f: (env: Context.Context<R0>) => Effect.Effect<R, E, A>) => Stream<R0 | R, E, A>;
+/**
+ * Accesses the context of the stream in the context of a stream.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const contextWithStream: <R0, R, E, A>(f: (env: Context.Context<R0>) => Stream<R, E, A>) => Stream<R0 | R, E, A>;
+/**
+ * Creates a stream that executes the specified effect but emits no elements.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const execute: <R, E, _>(effect: Effect.Effect<R, E, _>) => Stream<R, E, never>;
+/**
+ * Terminates with the specified error.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fail: <E>(error: E) => Stream<never, E, never>;
+/**
+ * Terminates with the specified lazily evaluated error.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const failSync: <E>(evaluate: LazyArg<E>) => Stream<never, E, never>;
+/**
+ * The stream that always fails with the specified `Cause`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const failCause: <E>(cause: Cause.Cause<E>) => Stream<never, E, never>;
+/**
+ * The stream that always fails with the specified lazily evaluated `Cause`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Stream<never, E, never>;
+/**
+ * Filters the elements emitted by this stream using the provided function.
+ *
+ * @since 1.0.0
+ * @category filtering
+ */
+export declare const filter: {
+    <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
+    <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>;
+    <R, E, A, X extends A>(self: Stream<R, E, A>, predicate: Predicate<X>): Stream<R, E, A>;
+};
+/**
+ * Effectfully filters the elements emitted by this stream.
+ *
+ * @since 1.0.0
+ * @category filtering
+ */
+export declare const filterEffect: {
+    <A, X extends A, R2, E2>(f: (a: X) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, X extends A, R2, E2>(self: Stream<R, E, A>, f: (a: X) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Performs a filter and map in a single step.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const filterMap: {
+    <A, B>(pf: (a: A) => Option.Option<B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
+    <R, E, A, B>(self: Stream<R, E, A>, pf: (a: A) => Option.Option<B>): Stream<R, E, B>;
+};
+/**
+ * Performs an effectful filter and map in a single step.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const filterMapEffect: {
+    <A, R2, E2, A2>(pf: (a: A) => Option.Option<Effect.Effect<R2, E2, A2>>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, pf: (a: A) => Option.Option<Effect.Effect<R2, E2, A2>>): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Transforms all elements of the stream for as long as the specified partial
+ * function is defined.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const filterMapWhile: {
+    <A, A2>(pf: (a: A) => Option.Option<A2>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2>;
+    <R, E, A, A2>(self: Stream<R, E, A>, pf: (a: A) => Option.Option<A2>): Stream<R, E, A2>;
+};
+/**
+ * Effectfully transforms all elements of the stream for as long as the
+ * specified partial function is defined.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const filterMapWhileEffect: {
+    <A, R2, E2, A2>(pf: (a: A) => Option.Option<Effect.Effect<R2, E2, A2>>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, pf: (a: A) => Option.Option<Effect.Effect<R2, E2, A2>>): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Creates a one-element stream that never fails and executes the finalizer
+ * when it ends.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const finalizer: <R, _>(finalizer: Effect.Effect<R, never, _>) => Stream<R, never, void>;
+/**
+ * Finds the first element emitted by this stream that satisfies the provided
+ * predicate.
+ *
+ * @since 1.0.0
+ * @category elements
+ */
+export declare const find: {
+    <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
+    <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>;
+    <R, E, A, X extends A>(self: Stream<R, E, A>, predicate: Predicate<X>): Stream<R, E, A>;
+};
+/**
+ * Finds the first element emitted by this stream that satisfies the provided
+ * effectful predicate.
+ *
+ * @since 1.0.0
+ * @category elements
+ */
+export declare const findEffect: {
+    <A, X extends A, R2, E2>(predicate: (a: X) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, X extends A, R2, E2>(self: Stream<R, E, A>, predicate: (a: X) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Returns a stream made of the concatenation in strict order of all the
+ * streams produced by passing each element of this stream to `f0`
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const flatMap: {
+    <A, R2, E2, A2>(f: (a: A) => Stream<R2, E2, A2>, options?: {
+        readonly concurrency?: number | "unbounded";
+        readonly bufferSize?: number;
+        readonly switch?: boolean;
+    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, f: (a: A) => Stream<R2, E2, A2>, options?: {
+        readonly concurrency?: number | "unbounded";
+        readonly bufferSize?: number;
+        readonly switch?: boolean;
+    }): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Flattens this stream-of-streams into a stream made of the concatenation in
+ * strict order of all the streams.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const flatten: {
+    (options?: {
+        readonly concurrency?: number | "unbounded";
+        readonly bufferSize?: number;
+    }): <R, E, R2, E2, A>(self: Stream<R, E, Stream<R2, E2, A>>) => Stream<R | R2, E | E2, A>;
+    <R, E, R2, E2, A>(self: Stream<R, E, Stream<R2, E2, A>>, options?: {
+        readonly concurrency?: number | "unbounded";
+        readonly bufferSize?: number;
+    }): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Submerges the chunks carried by this stream into the stream's structure,
+ * while still preserving them.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const flattenChunks: <R, E, A>(self: Stream<R, E, Chunk.Chunk<A>>) => Stream<R, E, A>;
+/**
+ * Flattens `Effect` values into the stream's structure, preserving all
+ * information about the effect.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const flattenEffect: {
+    (options?: {
+        readonly concurrency?: number | "unbounded";
+        readonly unordered?: boolean;
+    }): <R, E, R2, E2, A>(self: Stream<R, E, Effect.Effect<R2, E2, A>>) => Stream<R | R2, E | E2, A>;
+    <R, E, R2, E2, A>(self: Stream<R, E, Effect.Effect<R2, E2, A>>, options?: {
+        readonly concurrency?: number | "unbounded";
+        readonly unordered?: boolean;
+    }): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Unwraps `Exit` values that also signify end-of-stream by failing with `None`.
+ *
+ * For `Exit` values that do not signal end-of-stream, prefer:
+ *
+ * ```ts
+ * stream.mapZIO(ZIO.done(_))
+ * ```
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const flattenExitOption: <R, E, E2, A>(self: Stream<R, E, Exit.Exit<Option.Option<E2>, A>>) => Stream<R, E | E2, A>;
+/**
+ * Submerges the iterables carried by this stream into the stream's structure,
+ * while still preserving them.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const flattenIterables: <R, E, A>(self: Stream<R, E, Iterable<A>>) => Stream<R, E, A>;
+/**
+ * Unwraps `Exit` values and flatten chunks that also signify end-of-stream
+ * by failing with `None`.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const flattenTake: <R, E, E2, A>(self: Stream<R, E, Take.Take<E2, A>>) => Stream<R, E | E2, A>;
+/**
+ * Repeats this stream forever.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const forever: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+/**
+ * Creates a stream from an `AsyncIterable`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromAsyncIterable: <E, A>(iterable: AsyncIterable<A>, onError: (e: unknown) => E) => Stream<never, E, A>;
+/**
+ * Creates a stream from a `Channel`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromChannel: <R, E, A>(channel: Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>) => Stream<R, E, A>;
+/**
+ * Creates a channel from a `Stream`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const toChannel: <R, E, A>(stream: Stream<R, E, A>) => Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>;
+/**
+ * Creates a stream from a `Chunk` of values.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromChunk: <A>(chunk: Chunk.Chunk<A>) => Stream<never, never, A>;
+/**
+ * Creates a stream from a subscription to a `Hub`.
+ *
+ * @param shutdown If `true`, the hub will be shutdown after the stream is evaluated (defaults to `false`)
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromChunkHub: {
+    <A>(hub: Hub.Hub<Chunk.Chunk<A>>, options: {
+        readonly scoped: true;
+        readonly shutdown?: boolean;
+    }): Effect.Effect<Scope.Scope, never, Stream<never, never, A>>;
+    <A>(hub: Hub.Hub<Chunk.Chunk<A>>, options?: {
+        readonly scoped?: false;
+        readonly shutdown?: boolean;
+    }): Stream<never, never, A>;
+};
+/**
+ * Creates a stream from a `Queue` of values.
+ *
+ * @param shutdown If `true`, the queue will be shutdown after the stream is evaluated (defaults to `false`)
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromChunkQueue: <A>(queue: Queue.Dequeue<Chunk.Chunk<A>>, options?: {
+    readonly shutdown?: boolean;
+}) => Stream<never, never, A>;
+/**
+ * Creates a stream from an arbitrary number of chunks.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromChunks: <A>(...chunks: Array<Chunk.Chunk<A>>) => Stream<never, never, A>;
+/**
+ * Either emits the success value of this effect or terminates the stream
+ * with the failure value of this effect.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream<R, E, A>;
+/**
+ * Creates a stream from an effect producing a value of type `A` or an empty
+ * `Stream`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromEffectOption: <R, E, A>(effect: Effect.Effect<R, Option.Option<E>, A>) => Stream<R, E, A>;
+/**
+ * Creates a stream from a subscription to a `Hub`.
+ *
+ * @param shutdown If `true`, the hub will be shutdown after the stream is evaluated (defaults to `false`)
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromHub: {
+    <A>(hub: Hub.Hub<A>, options: {
+        readonly scoped: true;
+        readonly maxChunkSize?: number;
+        readonly shutdown?: boolean;
+    }): Effect.Effect<Scope.Scope, never, Stream<never, never, A>>;
+    <A>(hub: Hub.Hub<A>, options?: {
+        readonly scoped?: false;
+        readonly maxChunkSize?: number;
+        readonly shutdown?: boolean;
+    }): Stream<never, never, A>;
+};
+/**
+ * Creates a stream from an `Iterable` collection of values.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromIterable: <A>(iterable: Iterable<A>) => Stream<never, never, A>;
+/**
+ * Creates a stream from an effect producing a value of type `Iterable<A>`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromIterableEffect: <R, E, A>(effect: Effect.Effect<R, E, Iterable<A>>) => Stream<R, E, A>;
+/**
+ * Creates a stream from an iterator
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromIteratorSucceed: <A>(iterator: IterableIterator<A>, maxChunkSize?: number) => Stream<never, never, A>;
+/**
+ * Creates a stream from an effect that pulls elements from another stream.
+ *
+ * See `Stream.toPull` for reference.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromPull: <R, R2, E, A>(effect: Effect.Effect<Scope.Scope | R, never, Effect.Effect<R2, Option.Option<E>, Chunk.Chunk<A>>>) => Stream<Exclude<R, Scope.Scope> | R2, E, A>;
+/**
+ * Creates a stream from a queue of values
+ *
+ * @param maxChunkSize The maximum number of queued elements to put in one chunk in the stream
+ * @param shutdown If `true`, the queue will be shutdown after the stream is evaluated (defaults to `false`)
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromQueue: <A>(queue: Queue.Dequeue<A>, options?: {
+    readonly maxChunkSize?: number;
+    readonly shutdown?: boolean;
+}) => Stream<never, never, A>;
+/**
+ * Creates a stream from a `ReadableStream`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromReadableStream: <A, E>(evaluate: LazyArg<ReadableStream<A>>, onError: (error: unknown) => E) => Stream<never, E, A>;
+/**
+ * Creates a stream from a `ReadableStreamBYOBReader`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamBYOBReader.
+ *
+ * @param allocSize Controls the size of the underlying `ArrayBuffer` (defaults to `4096`).
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromReadableStreamByob: <E>(evaluate: LazyArg<ReadableStream<Uint8Array>>, onError: (error: unknown) => E, allocSize?: number) => Stream<never, E, Uint8Array>;
+/**
+ * Creates a stream from a `Schedule` that does not require any further
+ * input. The stream will emit an element for each value output from the
+ * schedule, continuing for as long as the schedule continues.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fromSchedule: <R, A>(schedule: Schedule.Schedule<R, unknown, A>) => Stream<R, never, A>;
+/**
+ * Creates a pipeline that groups on adjacent keys, calculated by the
+ * specified function.
+ *
+ * @since 1.0.0
+ * @category grouping
+ */
+export declare const groupAdjacentBy: {
+    <A, K>(f: (a: A) => K): <R, E>(self: Stream<R, E, A>) => Stream<R, E, readonly [K, Chunk.NonEmptyChunk<A>]>;
+    <R, E, A, K>(self: Stream<R, E, A>, f: (a: A) => K): Stream<R, E, readonly [K, Chunk.NonEmptyChunk<A>]>;
+};
+/**
+ * More powerful version of `Stream.groupByKey`.
+ *
+ * @since 1.0.0
+ * @category grouping
+ */
+export declare const groupBy: {
+    <A, R2, E2, K, V>(f: (a: A) => Effect.Effect<R2, E2, readonly [K, V]>, options?: {
+        readonly bufferSize?: number;
+    }): <R, E>(self: Stream<R, E, A>) => GroupBy.GroupBy<R2 | R, E2 | E, K, V>;
+    <R, E, A, R2, E2, K, V>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, readonly [K, V]>, options?: {
+        readonly bufferSize?: number;
+    }): GroupBy.GroupBy<R | R2, E | E2, K, V>;
+};
+/**
+ * Partition a stream using a function and process each stream individually.
+ * This returns a data structure that can be used to further filter down which
+ * groups shall be processed.
+ *
+ * After calling apply on the GroupBy object, the remaining groups will be
+ * processed in parallel and the resulting streams merged in a
+ * nondeterministic fashion.
+ *
+ * Up to `buffer` elements may be buffered in any group stream before the
+ * producer is backpressured. Take care to consume from all streams in order
+ * to prevent deadlocks.
+ *
+ * For example, to collect the first 2 words for every starting letter from a
+ * stream of words:
+ *
+ * ```ts
+ * import * as GroupBy from "./GroupBy"
+ * import * as Stream from "./Stream"
+ * import { pipe } from "./Function"
+ *
+ * pipe(
+ *   Stream.fromIterable(["hello", "world", "hi", "holla"]),
+ *   Stream.groupByKey((word) => word[0]),
+ *   GroupBy.evaluate((key, stream) =>
+ *     pipe(
+ *       stream,
+ *       Stream.take(2),
+ *       Stream.map((words) => [key, words] as const)
+ *     )
+ *   )
+ * )
+ * ```
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const groupByKey: {
+    <A, K>(f: (a: A) => K, options?: {
+        readonly bufferSize?: number;
+    }): <R, E>(self: Stream<R, E, A>) => GroupBy.GroupBy<R, E, K, A>;
+    <R, E, A, K>(self: Stream<R, E, A>, f: (a: A) => K, options?: {
+        readonly bufferSize?: number;
+    }): GroupBy.GroupBy<R, E, K, A>;
+};
+/**
+ * Partitions the stream with specified `chunkSize`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const grouped: {
+    (chunkSize: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
+    <R, E, A>(self: Stream<R, E, A>, chunkSize: number): Stream<R, E, Chunk.Chunk<A>>;
+};
+/**
+ * Partitions the stream with the specified `chunkSize` or until the specified
+ * `duration` has passed, whichever is satisfied first.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const groupedWithin: {
+    (chunkSize: number, duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
+    <R, E, A>(self: Stream<R, E, A>, chunkSize: number, duration: Duration.DurationInput): Stream<R, E, Chunk.Chunk<A>>;
+};
+/**
+ * Specialized version of haltWhen which halts the evaluation of this stream
+ * after the given duration.
+ *
+ * An element in the process of being pulled will not be interrupted when the
+ * given duration completes. See `interruptAfter` for this behavior.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const haltAfter: {
+    (duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, duration: Duration.DurationInput): Stream<R, E, A>;
+};
+/**
+ * Halts the evaluation of this stream when the provided effect completes. The
+ * given effect will be forked as part of the returned stream, and its success
+ * will be discarded.
+ *
+ * An element in the process of being pulled will not be interrupted when the
+ * effect completes. See `interruptWhen` for this behavior.
+ *
+ * If the effect completes with a failure, the stream will emit that failure.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const haltWhen: {
+    <R2, E2, _>(effect: Effect.Effect<R2, E2, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, effect: Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Halts the evaluation of this stream when the provided promise resolves.
+ *
+ * If the promise completes with a failure, the stream will emit that failure.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const haltWhenDeferred: {
+    <E2, _>(deferred: Deferred.Deferred<E2, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, A>;
+    <R, E, A, E2, _>(self: Stream<R, E, A>, deferred: Deferred.Deferred<E2, _>): Stream<R, E | E2, A>;
+};
+/**
+ * The identity pipeline, which does not modify streams in any way.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const identity: <R, E, A>() => Stream<R, E, A>;
+/**
+ * Interleaves this stream and the specified stream deterministically by
+ * alternating pulling values from this stream and the specified stream. When
+ * one stream is exhausted all remaining values in the other stream will be
+ * pulled.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const interleave: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A | A2>;
+};
+/**
+ * Combines this stream and the specified stream deterministically using the
+ * stream of boolean values `pull` to control which stream to pull from next.
+ * A value of `true` indicates to pull from this stream and a value of `false`
+ * indicates to pull from the specified stream. Only consumes as many elements
+ * as requested by the `pull` stream. If either this stream or the specified
+ * stream are exhausted further requests for values from that stream will be
+ * ignored.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const interleaveWith: {
+    <R2, E2, A2, R3, E3>(that: Stream<R2, E2, A2>, decider: Stream<R3, E3, boolean>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R3 | R, E2 | E3 | E, A2 | A>;
+    <R, E, A, R2, E2, A2, R3, E3>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, decider: Stream<R3, E3, boolean>): Stream<R | R2 | R3, E | E2 | E3, A | A2>;
+};
+/**
+ * Intersperse stream with provided `element`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const intersperse: {
+    <A2>(element: A2): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A2 | A>;
+    <R, E, A, A2>(self: Stream<R, E, A>, element: A2): Stream<R, E, A | A2>;
+};
+/**
+ * Intersperse the specified element, also adding a prefix and a suffix.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const intersperseAffixes: {
+    <A2, A3, A4>(options: {
+        readonly start: A2;
+        readonly middle: A3;
+        readonly end: A4;
+    }): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A2 | A3 | A4 | A>;
+    <R, E, A, A2, A3, A4>(self: Stream<R, E, A>, options: {
+        readonly start: A2;
+        readonly middle: A3;
+        readonly end: A4;
+    }): Stream<R, E, A | A2 | A3 | A4>;
+};
+/**
+ * Specialized version of `Stream.interruptWhen` which interrupts the
+ * evaluation of this stream after the given `Duration`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const interruptAfter: {
+    (duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, duration: Duration.DurationInput): Stream<R, E, A>;
+};
+/**
+ * Interrupts the evaluation of this stream when the provided effect
+ * completes. The given effect will be forked as part of this stream, and its
+ * success will be discarded. This combinator will also interrupt any
+ * in-progress element being pulled from upstream.
+ *
+ * If the effect completes with a failure before the stream completes, the
+ * returned stream will emit that failure.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const interruptWhen: {
+    <R2, E2, _>(effect: Effect.Effect<R2, E2, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, effect: Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Interrupts the evaluation of this stream when the provided promise
+ * resolves. This combinator will also interrupt any in-progress element being
+ * pulled from upstream.
+ *
+ * If the promise completes with a failure, the stream will emit that failure.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const interruptWhenDeferred: {
+    <E2, _>(deferred: Deferred.Deferred<E2, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, A>;
+    <R, E, A, E2, _>(self: Stream<R, E, A>, deferred: Deferred.Deferred<E2, _>): Stream<R, E | E2, A>;
+};
+/**
+ * The infinite stream of iterative function application: a, f(a), f(f(a)),
+ * f(f(f(a))), ...
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const iterate: <A>(value: A, next: (value: A) => A) => Stream<never, never, A>;
+/**
+ * Creates a stream from an sequence of values.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const make: <As extends Array<any>>(...as: As) => Stream<never, never, As[number]>;
+/**
+ * Transforms the elements of this stream using the supplied function.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const map: {
+    <A, B>(f: (a: A) => B): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
+    <R, E, A, B>(self: Stream<R, E, A>, f: (a: A) => B): Stream<R, E, B>;
+};
+/**
+ * Statefully maps over the elements of this stream to produce new elements.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapAccum: {
+    <S, A, A2>(s: S, f: (s: S, a: A) => readonly [S, A2]): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2>;
+    <R, E, S, A, A2>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => readonly [S, A2]): Stream<R, E, A2>;
+};
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * new elements.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapAccumEffect: {
+    <S, A, R2, E2, A2>(s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, readonly [S, A2]>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, S, A, R2, E2, A2>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, readonly [S, A2]>): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Returns a stream whose failure and success channels have been mapped by the
+ * specified `onFailure` and `onSuccess` functions.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const mapBoth: {
+    <E, E2, A, A2>(options: {
+        readonly onFailure: (e: E) => E2;
+        readonly onSuccess: (a: A) => A2;
+    }): <R>(self: Stream<R, E, A>) => Stream<R, E2, A2>;
+    <R, E, E2, A, A2>(self: Stream<R, E, A>, options: {
+        readonly onFailure: (e: E) => E2;
+        readonly onSuccess: (a: A) => A2;
+    }): Stream<R, E2, A2>;
+};
+/**
+ * Transforms the chunks emitted by this stream.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapChunks: {
+    <A, B>(f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
+    <R, E, A, B>(self: Stream<R, E, A>, f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<B>): Stream<R, E, B>;
+};
+/**
+ * Effectfully transforms the chunks emitted by this stream.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapChunksEffect: {
+    <A, R2, E2, B>(f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, Chunk.Chunk<B>>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, B>;
+    <R, E, A, R2, E2, B>(self: Stream<R, E, A>, f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, Chunk.Chunk<B>>): Stream<R | R2, E | E2, B>;
+};
+/**
+ * Maps each element to an iterable, and flattens the iterables into the
+ * output of this stream.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapConcat: {
+    <A, A2>(f: (a: A) => Iterable<A2>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2>;
+    <R, E, A, A2>(self: Stream<R, E, A>, f: (a: A) => Iterable<A2>): Stream<R, E, A2>;
+};
+/**
+ * Maps each element to a chunk, and flattens the chunks into the output of
+ * this stream.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapConcatChunk: {
+    <A, A2>(f: (a: A) => Chunk.Chunk<A2>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2>;
+    <R, E, A, A2>(self: Stream<R, E, A>, f: (a: A) => Chunk.Chunk<A2>): Stream<R, E, A2>;
+};
+/**
+ * Effectfully maps each element to a chunk, and flattens the chunks into the
+ * output of this stream.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapConcatChunkEffect: {
+    <A, R2, E2, A2>(f: (a: A) => Effect.Effect<R2, E2, Chunk.Chunk<A2>>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, Chunk.Chunk<A2>>): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Effectfully maps each element to an iterable, and flattens the iterables
+ * into the output of this stream.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapConcatEffect: {
+    <A, R2, E2, A2>(f: (a: A) => Effect.Effect<R2, E2, Iterable<A2>>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, Iterable<A2>>): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Maps over elements of the stream with the specified effectful function.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapEffect: {
+    <A, R2, E2, A2>(f: (a: A) => Effect.Effect<R2, E2, A2>, options?: {
+        readonly concurrency?: number | "unbounded";
+        readonly unordered?: boolean;
+    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <A, R2, E2, A2, K>(f: (a: A) => Effect.Effect<R2, E2, A2>, options: {
+        readonly key: (a: A) => K;
+        readonly bufferSize?: number;
+    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, A2>, options?: {
+        readonly concurrency?: number | "unbounded";
+        readonly unordered?: boolean;
+    }): Stream<R | R2, E | E2, A2>;
+    <R, E, A, R2, E2, A2, K>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, A2>, options: {
+        readonly key: (a: A) => K;
+        readonly bufferSize?: number;
+    }): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Transforms the errors emitted by this stream using `f`.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapError: {
+    <E, E2>(f: (error: E) => E2): <R, A>(self: Stream<R, E, A>) => Stream<R, E2, A>;
+    <R, A, E, E2>(self: Stream<R, E, A>, f: (error: E) => E2): Stream<R, E2, A>;
+};
+/**
+ * Transforms the full causes of failures emitted by this stream.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapErrorCause: {
+    <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(self: Stream<R, E, A>) => Stream<R, E2, A>;
+    <R, A, E, E2>(self: Stream<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Stream<R, E2, A>;
+};
+/**
+ * Merges this stream and the specified stream together.
+ *
+ * New produced stream will terminate when both specified stream terminate if
+ * no termination strategy is specified.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const merge: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>, options?: {
+        readonly haltStrategy?: HaltStrategy.HaltStrategyInput;
+    }): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, options?: {
+        readonly haltStrategy?: HaltStrategy.HaltStrategyInput;
+    }): Stream<R | R2, E | E2, A | A2>;
+};
+/**
+ * Merges a variable list of streams in a non-deterministic fashion. Up to `n`
+ * streams may be consumed in parallel and up to `outputBuffer` chunks may be
+ * buffered by this operator.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const mergeAll: {
+    (options: {
+        readonly concurrency: number | "unbounded";
+        readonly bufferSize?: number;
+    }): <R, E, A>(streams: Iterable<Stream<R, E, A>>) => Stream<R, E, A>;
+    <R, E, A>(streams: Iterable<Stream<R, E, A>>, options: {
+        readonly concurrency: number | "unbounded";
+        readonly bufferSize?: number;
+    }): Stream<R, E, A>;
+};
+/**
+ * Merges this stream and the specified stream together to a common element
+ * type with the specified mapping functions.
+ *
+ * New produced stream will terminate when both specified stream terminate if
+ * no termination strategy is specified.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const mergeWith: {
+    <R2, E2, A2, A, A3, A4>(other: Stream<R2, E2, A2>, options: {
+        readonly onSelf: (a: A) => A3;
+        readonly onOther: (a2: A2) => A4;
+        readonly haltStrategy?: HaltStrategy.HaltStrategyInput;
+    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A3 | A4>;
+    <R, E, R2, E2, A2, A, A3, A4>(self: Stream<R, E, A>, other: Stream<R2, E2, A2>, options: {
+        readonly onSelf: (a: A) => A3;
+        readonly onOther: (a2: A2) => A4;
+        readonly haltStrategy?: HaltStrategy.HaltStrategyInput;
+    }): Stream<R | R2, E | E2, A3 | A4>;
+};
+/**
+ * Merges this stream and the specified stream together to produce a stream of
+ * eithers.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const mergeEither: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, Either.Either<A, A2>>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, Either.Either<A, A2>>;
+};
+/**
+ * Merges this stream and the specified stream together, discarding the values
+ * from the right stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const mergeLeft: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Merges this stream and the specified stream together, discarding the values
+ * from the left stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const mergeRight: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Returns a combined string resulting from concatenating each of the values
+ * from the stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const mkString: <R, E>(self: Stream<R, E, string>) => Effect.Effect<R, E, string>;
+/**
+ * The stream that never produces any value or fails with any error.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const never: Stream<never, never, never>;
+/**
+ * Runs the specified effect if this stream fails, providing the error to the
+ * effect if it exists.
+ *
+ * Note: Unlike `Effect.onError` there is no guarantee that the provided
+ * effect will not be interrupted.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const onError: {
+    <E, R2, _>(cleanup: (cause: Cause.Cause<E>) => Effect.Effect<R2, never, _>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
+    <R, A, E, R2, _>(self: Stream<R, E, A>, cleanup: (cause: Cause.Cause<E>) => Effect.Effect<R2, never, _>): Stream<R | R2, E, A>;
+};
+/**
+ * Runs the specified effect if this stream ends.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const onDone: {
+    <R2, _>(cleanup: () => Effect.Effect<R2, never, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
+    <R, E, A, R2, _>(self: Stream<R, E, A>, cleanup: () => Effect.Effect<R2, never, _>): Stream<R | R2, E, A>;
+};
+/**
+ * Translates any failure into a stream termination, making the stream
+ * infallible and all failures unchecked.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const orDie: <R, E, A>(self: Stream<R, E, A>) => Stream<R, never, A>;
+/**
+ * Keeps none of the errors, and terminates the stream with them, using the
+ * specified function to convert the `E` into a defect.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const orDieWith: {
+    <E>(f: (e: E) => unknown): <R, A>(self: Stream<R, E, A>) => Stream<R, never, A>;
+    <R, A, E>(self: Stream<R, E, A>, f: (e: E) => unknown): Stream<R, never, A>;
+};
+/**
+ * Switches to the provided stream in case this one fails with a typed error.
+ *
+ * See also `Stream.catchAll`.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const orElse: {
+    <R2, E2, A2>(that: LazyArg<Stream<R2, E2, A2>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2, A2 | A>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: LazyArg<Stream<R2, E2, A2>>): Stream<R | R2, E2, A | A2>;
+};
+/**
+ * Switches to the provided stream in case this one fails with a typed error.
+ *
+ * See also `Stream.catchAll`.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const orElseEither: {
+    <R2, E2, A2>(that: LazyArg<Stream<R2, E2, A2>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2, Either.Either<A, A2>>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: LazyArg<Stream<R2, E2, A2>>): Stream<R | R2, E2, Either.Either<A, A2>>;
+};
+/**
+ * Fails with given error in case this one fails with a typed error.
+ *
+ * See also `Stream.catchAll`.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const orElseFail: {
+    <E2>(error: LazyArg<E2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2, A>;
+    <R, E, A, E2>(self: Stream<R, E, A>, error: LazyArg<E2>): Stream<R, E2, A>;
+};
+/**
+ * Produces the specified element if this stream is empty.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const orElseIfEmpty: {
+    <A2>(element: LazyArg<A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A2 | A>;
+    <R, E, A, A2>(self: Stream<R, E, A>, element: LazyArg<A2>): Stream<R, E, A | A2>;
+};
+/**
+ * Produces the specified chunk if this stream is empty.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const orElseIfEmptyChunk: {
+    <A2>(chunk: LazyArg<Chunk.Chunk<A2>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A2 | A>;
+    <R, E, A, A2>(self: Stream<R, E, A>, chunk: LazyArg<Chunk.Chunk<A2>>): Stream<R, E, A | A2>;
+};
+/**
+ * Switches to the provided stream in case this one is empty.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const orElseIfEmptyStream: {
+    <R2, E2, A2>(stream: LazyArg<Stream<R2, E2, A2>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, stream: LazyArg<Stream<R2, E2, A2>>): Stream<R | R2, E | E2, A | A2>;
+};
+/**
+ * Succeeds with the specified value if this one fails with a typed error.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const orElseSucceed: {
+    <A2>(value: LazyArg<A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, never, A2 | A>;
+    <R, E, A, A2>(self: Stream<R, E, A>, value: LazyArg<A2>): Stream<R, never, A | A2>;
+};
+/**
+ * Like `Stream.unfold`, but allows the emission of values to end one step further
+ * than the unfolding of the state. This is useful for embedding paginated
+ * APIs, hence the name.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const paginate: <S, A>(s: S, f: (s: S) => readonly [A, Option.Option<S>]) => Stream<never, never, A>;
+/**
+ * Like `Stream.unfoldChunk`, but allows the emission of values to end one step
+ * further than the unfolding of the state. This is useful for embedding
+ * paginated APIs, hence the name.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const paginateChunk: <S, A>(s: S, f: (s: S) => readonly [Chunk.Chunk<A>, Option.Option<S>]) => Stream<never, never, A>;
+/**
+ * Like `Stream.unfoldChunkEffect`, but allows the emission of values to end one step
+ * further than the unfolding of the state. This is useful for embedding
+ * paginated APIs, hence the name.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const paginateChunkEffect: <S, R, E, A>(s: S, f: (s: S) => Effect.Effect<R, E, readonly [Chunk.Chunk<A>, Option.Option<S>]>) => Stream<R, E, A>;
+/**
+ * Like `Stream.unfoldEffect` but allows the emission of values to end one step
+ * further than the unfolding of the state. This is useful for embedding
+ * paginated APIs, hence the name.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const paginateEffect: <S, R, E, A>(s: S, f: (s: S) => Effect.Effect<R, E, readonly [A, Option.Option<S>]>) => Stream<R, E, A>;
+/**
+ * Partition a stream using a predicate. The first stream will contain all
+ * element evaluated to true and the second one will contain all element
+ * evaluated to false. The faster stream may advance by up to buffer elements
+ * further than the slower one.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const partition: {
+    <A>(predicate: Predicate<A>, options?: {
+        bufferSize?: number;
+    }): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, E, readonly [Stream<never, E, A>, Stream<never, E, A>]>;
+    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>, options?: {
+        bufferSize?: number;
+    }): Effect.Effect<Scope.Scope | R, E, readonly [Stream<never, E, A>, Stream<never, E, A>]>;
+};
+/**
+ * Split a stream by an effectful predicate. The faster stream may advance by
+ * up to buffer elements further than the slower one.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const partitionEither: {
+    <A, R2, E2, A2, A3>(predicate: (a: A) => Effect.Effect<R2, E2, Either.Either<A2, A3>>, options?: {
+        readonly bufferSize?: number;
+    }): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, readonly [Stream<never, E2 | E, A2>, Stream<never, E2 | E, A3>]>;
+    <R, E, A, R2, E2, A2, A3>(self: Stream<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, Either.Either<A2, A3>>, options?: {
+        readonly bufferSize?: number;
+    }): Effect.Effect<Scope.Scope | R | R2, E | E2, readonly [Stream<never, E | E2, A2>, Stream<never, E | E2, A3>]>;
+};
+/**
+ * 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
+ * `Stream` in a scope. Like all scoped values, the provided stream is
+ * valid only within the scope.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const peel: {
+    <R2, E2, A, Z>(sink: Sink.Sink<R2, E2, A, A, Z>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, readonly [Z, Stream<never, E, A>]>;
+    <R, E, R2, E2, A, Z>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, A, Z>): Effect.Effect<Scope.Scope | R | R2, E | E2, readonly [Z, Stream<never, E, A>]>;
+};
+/**
+ * Pipes all of the values from this stream through the provided sink.
+ *
+ * See also `Stream.transduce`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const pipeThrough: {
+    <R2, E2, A, L, Z>(sink: Sink.Sink<R2, E2, A, L, Z>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, L>;
+    <R, E, R2, E2, A, L, Z>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, L, Z>): Stream<R | R2, E | E2, L>;
+};
+/**
+ * Pipes all the values from this stream through the provided channel.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const pipeThroughChannel: {
+    <R2, E, E2, A, A2>(channel: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>): <R>(self: Stream<R, E, A>) => Stream<R2 | R, E2, A2>;
+    <R, R2, E, E2, A, A2>(self: Stream<R, E, A>, channel: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>): Stream<R | R2, E2, A2>;
+};
+/**
+ * Pipes all values from this stream through the provided channel, passing
+ * through any error emitted by this stream unchanged.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const pipeThroughChannelOrFail: {
+    <R2, E, E2, A, A2>(chan: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>): <R>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A2>;
+    <R, R2, E, E2, A, A2>(self: Stream<R, E, A>, chan: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Emits the provided chunk before emitting any other value.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const prepend: {
+    <B>(values: Chunk.Chunk<B>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, B | A>;
+    <R, E, A, B>(self: Stream<R, E, A>, values: Chunk.Chunk<B>): Stream<R, E, A | B>;
+};
+/**
+ * Provides the stream with its required context, which eliminates its
+ * dependency on `R`.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const provideContext: {
+    <R>(context: Context.Context<R>): <E, A>(self: Stream<R, E, A>) => Stream<never, E, A>;
+    <E, A, R>(self: Stream<R, E, A>, context: Context.Context<R>): Stream<never, E, A>;
+};
+/**
+ * Provides a `Layer` to the stream, which translates it to another level.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const provideLayer: {
+    <RIn, E2, ROut>(layer: Layer.Layer<RIn, E2, ROut>): <E, A>(self: Stream<ROut, E, A>) => Stream<RIn, E2 | E, A>;
+    <E, A, RIn, E2, ROut>(self: Stream<ROut, E, A>, layer: Layer.Layer<RIn, E2, ROut>): Stream<RIn, E | E2, A>;
+};
+/**
+ * Provides the stream with the single service it requires. If the stream
+ * requires more than one service use `Stream.provideContext` instead.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const provideService: {
+    <T extends Context.Tag<any, any>>(tag: T, resource: Context.Tag.Service<T>): <R, E, A>(self: Stream<R, E, A>) => Stream<Exclude<R, Context.Tag.Identifier<T>>, E, A>;
+    <R, E, A, T extends Context.Tag<any, any>>(self: Stream<R, E, A>, tag: T, resource: Context.Tag.Service<T>): Stream<Exclude<R, Context.Tag.Identifier<T>>, E, A>;
+};
+/**
+ * Provides the stream with the single service it requires. If the stream
+ * requires more than one service use `Stream.provideContext` instead.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const provideServiceEffect: {
+    <T extends Context.Tag<any, any>, R2, E2>(tag: T, effect: Effect.Effect<R2, E2, Context.Tag.Service<T>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | Exclude<R, Context.Tag.Identifier<T>>, E2 | E, A>;
+    <R, E, A, T extends Context.Tag<any, any>, R2, E2>(self: Stream<R, E, A>, tag: T, effect: Effect.Effect<R2, E2, Context.Tag.Service<T>>): Stream<R2 | Exclude<R, Context.Tag.Identifier<T>>, E | E2, A>;
+};
+/**
+ * Provides the stream with the single service it requires. If the stream
+ * requires more than one service use `Stream.provideContext` instead.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const provideServiceStream: {
+    <T extends Context.Tag<any, any>, R2, E2>(tag: T, stream: Stream<R2, E2, Context.Tag.Service<T>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | Exclude<R, Context.Tag.Identifier<T>>, E2 | E, A>;
+    <R, E, A, T extends Context.Tag<any, any>, R2, E2>(self: Stream<R, E, A>, tag: T, stream: Stream<R2, E2, Context.Tag.Service<T>>): Stream<R2 | Exclude<R, Context.Tag.Identifier<T>>, E | E2, A>;
+};
+/**
+ * Transforms the context being provided to the stream with the specified
+ * function.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const mapInputContext: {
+    <R0, R>(f: (env: Context.Context<R0>) => Context.Context<R>): <E, A>(self: Stream<R, E, A>) => Stream<R0, E, A>;
+    <E, A, R0, R>(self: Stream<R, E, A>, f: (env: Context.Context<R0>) => Context.Context<R>): Stream<R0, E, A>;
+};
+/**
+ * Splits the context into two parts, providing one part using the
+ * specified layer and leaving the remainder `R0`.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const provideSomeLayer: {
+    <RIn, E2, ROut>(layer: Layer.Layer<RIn, E2, ROut>): <R, E, A>(self: Stream<R, E, A>) => Stream<RIn | Exclude<R, ROut>, E2 | E, A>;
+    <R, E, A, RIn, E2, ROut>(self: Stream<R, E, A>, layer: Layer.Layer<RIn, E2, ROut>): Stream<RIn | Exclude<R, ROut>, E | E2, A>;
+};
+/**
+ * Constructs a stream from a range of integers, including both endpoints.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const range: (min: number, max: number, chunkSize?: number) => Stream<never, never, number>;
+/**
+ * Re-chunks the elements of the stream into chunks of `n` elements each. The
+ * last chunk might contain less than `n` elements.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const rechunk: {
+    (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>;
+};
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const refineOrDie: {
+    <E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: Stream<R, E, A>) => Stream<R, E2, A>;
+    <R, A, E, E2>(self: Stream<R, E, A>, pf: (error: E) => Option.Option<E2>): Stream<R, E2, A>;
+};
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest, using the
+ * specified function to convert the `E` into a defect.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const refineOrDieWith: {
+    <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <R, A>(self: Stream<R, E, A>) => Stream<R, E2, A>;
+    <R, A, E, E2>(self: Stream<R, E, A>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): Stream<R, E2, A>;
+};
+/**
+ * Repeats the entire stream using the specified schedule. The stream will
+ * execute normally, and then repeat again according to the provided schedule.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const repeat: {
+    <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
+    <R, E, A, R2, B>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<R | R2, E, A>;
+};
+/**
+ * Creates a stream from an effect producing a value of type `A` which repeats
+ * forever.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const repeatEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream<R, E, A>;
+/**
+ * Creates a stream from an effect producing chunks of `A` values which
+ * repeats forever.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const repeatEffectChunk: <R, E, A>(effect: Effect.Effect<R, E, Chunk.Chunk<A>>) => Stream<R, E, A>;
+/**
+ * Creates a stream from an effect producing chunks of `A` values until it
+ * fails with `None`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const repeatEffectChunkOption: <R, E, A>(effect: Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>>) => Stream<R, E, A>;
+/**
+ * Creates a stream from an effect producing values of type `A` until it fails
+ * with `None`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const repeatEffectOption: <R, E, A>(effect: Effect.Effect<R, Option.Option<E>, A>) => Stream<R, E, A>;
+/**
+ * Creates a stream from an effect producing a value of type `A`, which is
+ * repeated using the specified schedule.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const repeatEffectWithSchedule: <R, E, A, A0 extends A, R2, _>(effect: Effect.Effect<R, E, A>, schedule: Schedule.Schedule<R2, A0, _>) => Stream<R | R2, E, A>;
+/**
+ * Repeats the entire stream using the specified schedule. The stream will
+ * execute normally, and then repeat again according to the provided schedule.
+ * The schedule output will be emitted at the end of each repetition.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const repeatEither: {
+    <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, Either.Either<B, A>>;
+    <R, E, A, R2, B>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<R | R2, E, Either.Either<B, A>>;
+};
+/**
+ * Repeats each element of the stream using the provided schedule. Repetitions
+ * are done in addition to the first execution, which means using
+ * `Schedule.recurs(1)` actually results in the original effect, plus an
+ * additional recurrence, for a total of two repetitions of each value in the
+ * stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const repeatElements: {
+    <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
+    <R, E, A, R2, B>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<R | R2, E, A>;
+};
+/**
+ * Repeats each element of the stream using the provided schedule. When the
+ * schedule is finished, then the output of the schedule will be emitted into
+ * the stream. Repetitions are done in addition to the first execution, which
+ * means using `Schedule.recurs(1)` actually results in the original effect,
+ * plus an additional recurrence, for a total of two repetitions of each value
+ * in the stream.
+ *
+ * This function accepts two conversion functions, which allow the output of
+ * this stream and the output of the provided schedule to be unified into a
+ * single type. For example, `Either` or similar data type.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const repeatElementsWith: {
+    <R2, B, A, C>(schedule: Schedule.Schedule<R2, unknown, B>, options: {
+        readonly onElement: (a: A) => C;
+        readonly onSchedule: (b: B) => C;
+    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, C>;
+    <R, E, R2, B, A, C>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, unknown, B>, options: {
+        readonly onElement: (a: A) => C;
+        readonly onSchedule: (b: B) => C;
+    }): Stream<R | R2, E, C>;
+};
+/**
+ * Repeats the provided value infinitely.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const repeatValue: <A>(value: A) => Stream<never, never, A>;
+/**
+ * Repeats the entire stream using the specified schedule. The stream will
+ * execute normally, and then repeat again according to the provided schedule.
+ * The schedule output will be emitted at the end of each repetition and can
+ * be unified with the stream elements using the provided functions.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const repeatWith: {
+    <R2, B, A, C>(schedule: Schedule.Schedule<R2, unknown, B>, options: {
+        readonly onElement: (a: A) => C;
+        readonly onSchedule: (b: B) => C;
+    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, C>;
+    <R, E, R2, B, A, C>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, unknown, B>, options: {
+        readonly onElement: (a: A) => C;
+        readonly onSchedule: (b: B) => C;
+    }): Stream<R | R2, E, C>;
+};
+/**
+ * When the stream fails, retry it according to the given schedule
+ *
+ * This retries the entire stream, so will re-execute all of the stream's
+ * acquire operations.
+ *
+ * The schedule is reset as soon as the first element passes through the
+ * stream again.
+ *
+ * @param schedule A `Schedule` receiving as input the errors of the stream.
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const retry: {
+    <R2, E, E0 extends E, _>(schedule: Schedule.Schedule<R2, E0, _>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
+    <R, A, R2, E, E0 extends E, _>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, E0, _>): Stream<R | R2, E, A>;
+};
+/**
+ * Runs the sink on the stream to produce either the sink's result or an error.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const run: {
+    <R2, E2, A, Z>(sink: Sink.Sink<R2, E2, A, unknown, Z>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, Z>;
+    <R, E, R2, E2, A, Z>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, unknown, Z>): Effect.Effect<R | R2, E | E2, Z>;
+};
+/**
+ * Runs the stream and collects all of its elements to a chunk.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runCollect: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>;
+/**
+ * Runs the stream and emits the number of elements processed
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runCount: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, number>;
+/**
+ * Runs the stream only for its effects. The emitted elements are discarded.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runDrain: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, void>;
+/**
+ * Executes a pure fold over the stream of values - reduces all elements in
+ * the stream to a value of type `S`.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runFold: {
+    <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R, E, S>;
+    <R, E, S, A>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => S): Effect.Effect<R, E, S>;
+};
+/**
+ * Executes an effectful fold over the stream of values.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runFoldEffect: {
+    <S, A, R2, E2>(s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, S>;
+    <R, E, S, A, R2, E2>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): Effect.Effect<R | R2, E | E2, S>;
+};
+/**
+ * Executes a pure fold over the stream of values. Returns a scoped value that
+ * represents the scope of the stream.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runFoldScoped: {
+    <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, E, S>;
+    <R, E, S, A>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => S): Effect.Effect<Scope.Scope | R, E, S>;
+};
+/**
+ * Executes an effectful fold over the stream of values. Returns a scoped
+ * value that represents the scope of the stream.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runFoldScopedEffect: {
+    <S, A, R2, E2>(s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, S>;
+    <R, E, S, A, R2, E2>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): Effect.Effect<Scope.Scope | R | R2, E | E2, S>;
+};
+/**
+ * Reduces the elements in the stream to a value of type `S`. Stops the fold
+ * early when the condition is not fulfilled. Example:
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runFoldWhile: {
+    <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R, E, S>;
+    <R, E, S, A>(self: Stream<R, E, A>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<R, E, S>;
+};
+/**
+ * Executes an effectful fold over the stream of values. Stops the fold early
+ * when the condition is not fulfilled.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runFoldWhileEffect: {
+    <S, A, R2, E2>(s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, S>;
+    <R, E, S, A, R2, E2>(self: Stream<R, E, A>, s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): Effect.Effect<R | R2, E | E2, S>;
+};
+/**
+ * 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
+ * is not fulfilled.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runFoldWhileScoped: {
+    <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R | Scope.Scope, E, S>;
+    <R, E, S, A>(self: Stream<R, E, A>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<Scope.Scope | R, E, S>;
+};
+/**
+ * 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
+ * the condition is not fulfilled.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runFoldWhileScopedEffect: {
+    <S, A, R2, E2>(s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, S>;
+    <R, E, S, A, R2, E2>(self: Stream<R, E, A>, s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): Effect.Effect<Scope.Scope | R | R2, E | E2, S>;
+};
+/**
+ * Consumes all elements of the stream, passing them to the specified
+ * callback.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runForEach: {
+    <A, R2, E2, _>(f: (a: A) => Effect.Effect<R2, E2, _>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, void>;
+    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, _>): Effect.Effect<R | R2, E | E2, void>;
+};
+/**
+ * Consumes all elements of the stream, passing them to the specified
+ * callback.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runForEachChunk: {
+    <A, R2, E2, _>(f: (a: Chunk.Chunk<A>) => Effect.Effect<R2, E2, _>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, void>;
+    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, f: (a: Chunk.Chunk<A>) => Effect.Effect<R2, E2, _>): Effect.Effect<R | R2, E | E2, void>;
+};
+/**
+ * Like `Stream.runForEachChunk`, but returns a scoped effect so the
+ * finalization order can be controlled.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runForEachChunkScoped: {
+    <A, R2, E2, _>(f: (a: Chunk.Chunk<A>) => Effect.Effect<R2, E2, _>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, void>;
+    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, f: (a: Chunk.Chunk<A>) => Effect.Effect<R2, E2, _>): Effect.Effect<Scope.Scope | R | R2, E | E2, void>;
+};
+/**
+ * Like `Stream.forEach`, but returns a scoped effect so the finalization
+ * order can be controlled.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runForEachScoped: {
+    <A, R2, E2, _>(f: (a: A) => Effect.Effect<R2, E2, _>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, void>;
+    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, _>): Effect.Effect<Scope.Scope | R | R2, E | E2, void>;
+};
+/**
+ * Consumes elements of the stream, passing them to the specified callback,
+ * and terminating consumption when the callback returns `false`.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runForEachWhile: {
+    <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, void>;
+    <R, E, A, R2, E2>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Effect.Effect<R | R2, E | E2, void>;
+};
+/**
+ * Like `Stream.runForEachWhile`, but returns a scoped effect so the
+ * finalization order can be controlled.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runForEachWhileScoped: {
+    <A, R2, E2>(f: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, void>;
+    <R, E, A, R2, E2>(self: Stream<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, boolean>): Effect.Effect<Scope.Scope | R | R2, E | E2, void>;
+};
+/**
+ * Runs the stream to completion and yields the first value emitted by it,
+ * discarding the rest of the elements.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runHead: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, Option.Option<A>>;
+/**
+ * Publishes elements of this stream to a hub. Stream failure and ending will
+ * also be signalled.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runIntoHub: {
+    <E, A>(hub: Hub.Hub<Take.Take<E, A>>): <R>(self: Stream<R, E, A>) => Effect.Effect<R, never, void>;
+    <R, E, A>(self: Stream<R, E, A>, hub: Hub.Hub<Take.Take<E, A>>): Effect.Effect<R, never, void>;
+};
+/**
+ * Like `Stream.runIntoHub`, but provides the result as a scoped effect to
+ * allow for scope composition.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runIntoHubScoped: {
+    <E, A>(hub: Hub.Hub<Take.Take<E, A>>): <R>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, void>;
+    <R, E, A>(self: Stream<R, E, A>, hub: Hub.Hub<Take.Take<E, A>>): Effect.Effect<Scope.Scope | R, never, void>;
+};
+/**
+ * Enqueues elements of this stream into a queue. Stream failure and ending
+ * will also be signalled.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runIntoQueue: {
+    <E, A>(queue: Queue.Enqueue<Take.Take<E, A>>): <R>(self: Stream<R, E, A>) => Effect.Effect<R, never, void>;
+    <R, E, A>(self: Stream<R, E, A>, queue: Queue.Enqueue<Take.Take<E, A>>): Effect.Effect<R, never, void>;
+};
+/**
+ * Like `Stream.runIntoQueue`, but provides the result as a scoped [[ZIO]]
+ * to allow for scope composition.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runIntoQueueElementsScoped: {
+    <E, A>(queue: Queue.Enqueue<Exit.Exit<Option.Option<E>, A>>): <R>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, void>;
+    <R, E, A>(self: Stream<R, E, A>, queue: Queue.Enqueue<Exit.Exit<Option.Option<E>, A>>): Effect.Effect<Scope.Scope | R, never, void>;
+};
+/**
+ * Like `Stream.runIntoQueue`, but provides the result as a scoped effect
+ * to allow for scope composition.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runIntoQueueScoped: {
+    <E, A>(queue: Queue.Enqueue<Take.Take<E, A>>): <R>(self: Stream<R, E, A>) => Effect.Effect<R | Scope.Scope, never, void>;
+    <R, E, A>(self: Stream<R, E, A>, queue: Queue.Enqueue<Take.Take<E, A>>): Effect.Effect<Scope.Scope | R, never, void>;
+};
+/**
+ * Runs the stream to completion and yields the last value emitted by it,
+ * discarding the rest of the elements.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runLast: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, Option.Option<A>>;
+/**
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runScoped: {
+    <R2, E2, A, A2>(sink: Sink.Sink<R2, E2, A, unknown, A2>): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, A2>;
+    <R, E, R2, E2, A, A2>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, unknown, A2>): Effect.Effect<Scope.Scope | R | R2, E | E2, A2>;
+};
+/**
+ * Runs the stream to a sink which sums elements, provided they are Numeric.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const runSum: <R, E>(self: Stream<R, E, number>) => Effect.Effect<R, E, number>;
+/**
+ * Statefully maps over the elements of this stream to produce all
+ * intermediate results of type `S` given an initial S.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const scan: {
+    <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<R, E, A>) => Stream<R, E, S>;
+    <R, E, S, A>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => S): Stream<R, E, S>;
+};
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * all intermediate results of type `S` given an initial S.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const scanEffect: {
+    <S, A, R2, E2>(s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, S>;
+    <R, E, S, A, R2, E2>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => Effect.Effect<R2, E2, S>): Stream<R | R2, E | E2, S>;
+};
+/**
+ * Statefully maps over the elements of this stream to produce all
+ * intermediate results.
+ *
+ * See also `Stream.scan`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const scanReduce: {
+    <A2, A>(f: (a2: A2 | A, a: A) => A2): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2 | A>;
+    <R, E, A2, A>(self: Stream<R, E, A>, f: (a2: A2 | A, a: A) => A2): Stream<R, E, A2 | A>;
+};
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * all intermediate results.
+ *
+ * See also `Stream.scanEffect`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const scanReduceEffect: <A2, A, R2, E2>(f: (a2: A2 | A, a: A) => Effect.Effect<R2, E2, A2 | A>) => <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>;
+/**
+ * Schedules the output of the stream using the provided `schedule`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const schedule: {
+    <R2, A, A0 extends A, _>(schedule: Schedule.Schedule<R2, A0, _>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>;
+    <R, E, R2, A, A0 extends A, _>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, A0, _>): Stream<R | R2, E, A>;
+};
+/**
+ * Schedules the output of the stream using the provided `schedule` and emits
+ * its output at the end (if `schedule` is finite). Uses the provided function
+ * to align the stream and schedule outputs on the same type.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const scheduleWith: {
+    <R2, A, A0 extends A, B, C>(schedule: Schedule.Schedule<R2, A0, B>, options: {
+        readonly onElement: (a: A) => C;
+        readonly onSchedule: (b: B) => C;
+    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, C>;
+    <R, E, R2, A, A0 extends A, B, C>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, A0, B>, options: {
+        readonly onElement: (a: A) => C;
+        readonly onSchedule: (b: B) => C;
+    }): Stream<R | R2, E, C>;
+};
+/**
+ * Creates a single-valued stream from a scoped resource.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const scoped: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream<Exclude<R, Scope.Scope>, E, A>;
+/**
+ * Emits a sliding window of `n` elements.
+ *
+ * ```ts
+ * import * as Stream from "./Stream"
+ * import { pipe } from "./Function"
+ *
+ * pipe(
+ *   Stream.make(1, 2, 3, 4),
+ *   Stream.sliding(2),
+ *   Stream.runCollect
+ * )
+ * // => Chunk(Chunk(1, 2), Chunk(2, 3), Chunk(3, 4))
+ * ```
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const sliding: {
+    (chunkSize: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
+    <R, E, A>(self: Stream<R, E, A>, chunkSize: number): Stream<R, E, Chunk.Chunk<A>>;
+};
+/**
+ * Like `sliding`, but with a configurable `stepSize` parameter.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const slidingSize: {
+    (chunkSize: number, stepSize: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
+    <R, E, A>(self: Stream<R, E, A>, chunkSize: number, stepSize: number): Stream<R, E, Chunk.Chunk<A>>;
+};
+/**
+ * Converts an option on values into an option on errors.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const some: <R, E, A>(self: Stream<R, E, Option.Option<A>>) => Stream<R, Option.Option<E>, A>;
+/**
+ * Extracts the optional value, or returns the given 'default'.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const someOrElse: {
+    <A2>(fallback: LazyArg<A2>): <R, E, A>(self: Stream<R, E, Option.Option<A>>) => Stream<R, E, A2 | A>;
+    <R, E, A, A2>(self: Stream<R, E, Option.Option<A>>, fallback: LazyArg<A2>): Stream<R, E, A | A2>;
+};
+/**
+ * Extracts the optional value, or fails with the given error 'e'.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const someOrFail: {
+    <E2>(error: LazyArg<E2>): <R, E, A>(self: Stream<R, E, Option.Option<A>>) => Stream<R, E2 | E, A>;
+    <R, E, A, E2>(self: Stream<R, E, Option.Option<A>>, error: LazyArg<E2>): Stream<R, E | E2, A>;
+};
+/**
+ * Splits elements based on a predicate.
+ *
+ * ```ts
+ * import * as Stream from "./Stream"
+ * import { pipe } from "./Function"
+ *
+ * pipe(
+ *   Stream.range(1, 10),
+ *   Stream.split((n) => n % 4 === 0),
+ *   Stream.runCollect
+ * )
+ * // => Chunk(Chunk(1, 2, 3), Chunk(5, 6, 7), Chunk(9))
+ * ```
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const split: {
+    <A>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
+    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, Chunk.Chunk<A>>;
+};
+/**
+ * Splits elements on a delimiter and transforms the splits into desired output.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const splitOnChunk: {
+    <A>(delimiter: Chunk.Chunk<A>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
+    <R, E, A>(self: Stream<R, E, A>, delimiter: Chunk.Chunk<A>): Stream<R, E, Chunk.Chunk<A>>;
+};
+/**
+ * Splits strings on newlines. Handles both Windows newlines (`\r\n`) and UNIX
+ * newlines (`\n`).
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const splitLines: <R, E>(self: Stream<R, E, string>) => Stream<R, E, string>;
+/**
+ * Creates a single-valued pure stream.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const succeed: <A>(value: A) => Stream<never, never, A>;
+/**
+ * Creates a single-valued pure stream.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const sync: <A>(evaluate: LazyArg<A>) => Stream<never, never, A>;
+/**
+ * Returns a lazily constructed stream.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const suspend: <R, E, A>(stream: LazyArg<Stream<R, E, A>>) => Stream<R, E, A>;
+/**
+ * Takes the specified number of elements from this stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const take: {
+    (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>;
+};
+/**
+ * Takes the last specified number of elements from this stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const takeRight: {
+    (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>;
+};
+/**
+ * Takes all elements of the stream until the specified predicate evaluates to
+ * `true`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const takeUntil: {
+    <A>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
+};
+/**
+ * Takes all elements of the stream until the specified effectual predicate
+ * evaluates to `true`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const takeUntilEffect: {
+    <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2>(self: Stream<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Takes all elements of the stream for as long as the specified predicate
+ * evaluates to `true`.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const takeWhile: {
+    <A>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
+};
+/**
+ * Adds an effect to consumption of every element of the stream.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const tap: {
+    <A, X extends A, R2, E2, _>(f: (a: X) => Effect.Effect<R2, E2, _>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, X extends A, R2, E2, _>(self: Stream<R, E, A>, f: (a: X) => Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Returns a stream that effectfully "peeks" at the failure or success of
+ * the stream.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const tapBoth: {
+    <E, XE extends E, A, XA extends A, R2, E2, X, R3, E3, X1>(options: {
+        readonly onFailure: (e: XE) => Effect.Effect<R2, E2, X>;
+        readonly onSuccess: (a: XA) => Effect.Effect<R3, E3, X1>;
+    }): <R>(self: Stream<R, E, A>) => Stream<R | R2 | R3, E | E2 | E3, A>;
+    <R, E, A, XE extends E, XA extends A, R2, E2, X, R3, E3, X1>(self: Stream<R, E, A>, options: {
+        readonly onFailure: (e: XE) => Effect.Effect<R2, E2, X>;
+        readonly onSuccess: (a: XA) => Effect.Effect<R3, E3, X1>;
+    }): Stream<R | R2 | R3, E | E2 | E3, A>;
+};
+/**
+ * Returns a stream that effectfully "peeks" at the failure of the stream.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const tapError: {
+    <E, X extends E, R2, E2, _>(f: (error: X) => Effect.Effect<R2, E2, _>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>;
+    <R, A, E, X extends E, R2, E2, _>(self: Stream<R, E, A>, f: (error: X) => Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Returns a stream that effectfully "peeks" at the cause of failure of the
+ * stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const tapErrorCause: {
+    <E, X extends E, R2, E2, _>(f: (cause: Cause.Cause<X>) => Effect.Effect<R2, E2, _>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>;
+    <R, A, E, X extends E, R2, E2, _>(self: Stream<R, E, A>, f: (cause: Cause.Cause<X>) => Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Sends all elements emitted by this stream to the specified sink in addition
+ * to emitting them.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const tapSink: {
+    <R2, E2, A>(sink: Sink.Sink<R2, E2, A, unknown, unknown>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, R2, E2, A>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, unknown, unknown>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Delays the chunks of this stream according to the given bandwidth
+ * parameters using the token bucket algorithm. Allows for burst in the
+ * processing of elements by allowing the token bucket to accumulate tokens up
+ * to a `units + burst` threshold. The weight of each chunk is determined by
+ * the `costFn` function.
+ *
+ * If using the "enforce" strategy, chunks that do not meet the bandwidth
+ * constraints are dropped. If using the "shape" strategy, chunks are delayed
+ * until they can be emitted without exceeding the bandwidth constraints.
+ *
+ * Defaults to the "shape" strategy.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const throttle: {
+    <A>(options: {
+        readonly cost: (chunk: Chunk.Chunk<A>) => number;
+        readonly units: number;
+        readonly duration: Duration.DurationInput;
+        readonly burst?: number;
+        readonly strategy?: "enforce" | "shape";
+    }): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, options: {
+        readonly cost: (chunk: Chunk.Chunk<A>) => number;
+        readonly units: number;
+        readonly duration: Duration.DurationInput;
+        readonly burst?: number;
+        readonly strategy?: "enforce" | "shape";
+    }): Stream<R, E, A>;
+};
+/**
+ * Delays the chunks of this stream according to the given bandwidth
+ * parameters using the token bucket algorithm. Allows for burst in the
+ * processing of elements by allowing the token bucket to accumulate tokens up
+ * to a `units + burst` threshold. The weight of each chunk is determined by
+ * the effectful `costFn` function.
+ *
+ * If using the "enforce" strategy, chunks that do not meet the bandwidth
+ * constraints are dropped. If using the "shape" strategy, chunks are delayed
+ * until they can be emitted without exceeding the bandwidth constraints.
+ *
+ * Defaults to the "shape" strategy.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const throttleEffect: {
+    <A, R2, E2>(options: {
+        readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, number>;
+        readonly units: number;
+        readonly duration: Duration.DurationInput;
+        readonly burst?: number;
+        readonly strategy?: "enforce" | "shape";
+    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2>(self: Stream<R, E, A>, options: {
+        readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, number>;
+        readonly units: number;
+        readonly duration: Duration.DurationInput;
+        readonly burst?: number;
+        readonly strategy?: "enforce" | "shape";
+    }): Stream<R | R2, E | E2, A>;
+};
+/**
+ * A stream that emits Unit values spaced by the specified duration.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const tick: (interval: Duration.DurationInput) => Stream<never, never, void>;
+/**
+ * Ends the stream if it does not produce a value after the specified duration.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const timeout: {
+    (duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, duration: Duration.DurationInput): Stream<R, E, A>;
+};
+/**
+ * Fails the stream with given error if it does not produce a value after d
+ * duration.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const timeoutFail: {
+    <E2>(error: LazyArg<E2>, duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, A>;
+    <R, E, A, E2>(self: Stream<R, E, A>, error: LazyArg<E2>, duration: Duration.DurationInput): Stream<R, E | E2, A>;
+};
+/**
+ * Fails the stream with given cause if it does not produce a value after d
+ * duration.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const timeoutFailCause: {
+    <E2>(cause: LazyArg<Cause.Cause<E2>>, duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, A>;
+    <R, E, A, E2>(self: Stream<R, E, A>, cause: LazyArg<Cause.Cause<E2>>, duration: Duration.DurationInput): Stream<R, E | E2, A>;
+};
+/**
+ * Switches the stream if it does not produce a value after the specified
+ * duration.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const timeoutTo: {
+    <R2, E2, A2>(duration: Duration.DurationInput, that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, duration: Duration.DurationInput, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A | A2>;
+};
+/**
+ * Converts the stream to a scoped hub of chunks. After the scope is closed,
+ * the hub will never again produce values and should be discarded.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const toHub: {
+    (capacity: number): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Hub.Hub<Take.Take<E, A>>>;
+    <R, E, A>(self: Stream<R, E, A>, capacity: number): Effect.Effect<Scope.Scope | R, never, Hub.Hub<Take.Take<E, A>>>;
+};
+/**
+ * Returns in a scope a ZIO effect that can be used to repeatedly pull chunks
+ * from the stream. The pull effect fails with None when the stream is
+ * finished, or with Some error if it fails, otherwise it returns a chunk of
+ * the stream's output.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const toPull: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>>>;
+/**
+ * Converts the stream to a scoped queue of chunks. After the scope is closed,
+ * the queue will never again produce values and should be discarded.
+ *
+ * Defaults to the "suspend" back pressure strategy with a capacity of 2.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const toQueue: {
+    (options?: {
+        readonly strategy?: "dropping" | "sliding" | "suspend";
+        readonly capacity?: number;
+    } | {
+        readonly strategy: "unbounded";
+    }): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Queue.Dequeue<Take.Take<E, A>>>;
+    <R, E, A>(self: Stream<R, E, A>, options?: {
+        readonly strategy?: "dropping" | "sliding" | "suspend";
+        readonly capacity?: number;
+    } | {
+        readonly strategy: "unbounded";
+    }): Effect.Effect<Scope.Scope | R, never, Queue.Dequeue<Take.Take<E, A>>>;
+};
+/**
+ * Converts the stream to a scoped queue of elements. After the scope is
+ * closed, the queue will never again produce values and should be discarded.
+ *
+ * Defaults to a capacity of 2.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const toQueueOfElements: {
+    (options?: {
+        readonly capacity?: number;
+    }): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>>;
+    <R, E, A>(self: Stream<R, E, A>, options?: {
+        readonly capacity?: number;
+    }): Effect.Effect<Scope.Scope | R, never, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>>;
+};
+/**
+ * Converts the stream to a `ReadableStream`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+ *
+ * @since 1.0.0
+ * @category destructors
+ */
+export declare const toReadableStream: <E, A>(source: Stream<never, E, A>) => ReadableStream<A>;
+/**
+ * Applies the transducer to the stream and emits its outputs.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const transduce: {
+    <R2, E2, A, Z>(sink: Sink.Sink<R2, E2, A, A, Z>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, Z>;
+    <R, E, R2, E2, A, Z>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, A, Z>): Stream<R | R2, E | E2, Z>;
+};
+/**
+ * Creates a stream by peeling off the "layers" of a value of type `S`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const unfold: <S, A>(s: S, f: (s: S) => Option.Option<readonly [A, S]>) => Stream<never, never, A>;
+/**
+ * Creates a stream by peeling off the "layers" of a value of type `S`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const unfoldChunk: <S, A>(s: S, f: (s: S) => Option.Option<readonly [Chunk.Chunk<A>, S]>) => Stream<never, never, A>;
+/**
+ * Creates a stream by effectfully peeling off the "layers" of a value of type
+ * `S`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const unfoldChunkEffect: <R, E, A, S>(s: S, f: (s: S) => Effect.Effect<R, E, Option.Option<readonly [Chunk.Chunk<A>, S]>>) => Stream<R, E, A>;
+/**
+ * Creates a stream by effectfully peeling off the "layers" of a value of type
+ * `S`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const unfoldEffect: <S, R, E, A>(s: S, f: (s: S) => Effect.Effect<R, E, Option.Option<readonly [A, S]>>) => Stream<R, E, A>;
+/**
+ * A stream that contains a single `Unit` value.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const unit: Stream<never, never, void>;
+/**
+ * Creates a stream produced from an `Effect`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const unwrap: <R, E, R2, E2, A>(effect: Effect.Effect<R, E, Stream<R2, E2, A>>) => Stream<R | R2, E | E2, A>;
+/**
+ * Creates a stream produced from a scoped `Effect`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const unwrapScoped: <R, E, R2, E2, A>(effect: Effect.Effect<R, E, Stream<R2, E2, A>>) => Stream<R2 | Exclude<R, Scope.Scope>, E | E2, A>;
+/**
+ * Updates the specified service within the context of the `Stream`.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const updateService: (<T extends Context.Tag<any, any>>(tag: T, f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>) => <R, E, A>(self: Stream<R, E, A>) => Stream<T | R, E, A>) & (<R_1, E_1, A_1, T_1 extends Context.Tag<any, any>>(self: Stream<R_1, E_1, A_1>, tag: T_1, f: (service: Context.Tag.Service<T_1>) => Context.Tag.Service<T_1>) => Stream<R_1 | T_1, E_1, A_1>);
+/**
+ * Returns the specified stream if the given condition is satisfied, otherwise
+ * returns an empty stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const when: {
+    (predicate: LazyArg<boolean>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, predicate: LazyArg<boolean>): Stream<R, E, A>;
+};
+/**
+ * Returns the resulting stream when the given `PartialFunction` is defined
+ * for the given value, otherwise returns an empty stream.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const whenCase: <A, R, E, A2>(evaluate: LazyArg<A>, pf: (a: A) => Option.Option<Stream<R, E, A2>>) => Stream<R, E, A2>;
+/**
+ * Returns the stream when the given partial function is defined for the given
+ * effectful value, otherwise returns an empty stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const whenCaseEffect: {
+    <A, R2, E2, A2>(pf: (a: A) => Option.Option<Stream<R2, E2, A2>>): <R, E>(self: Effect.Effect<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Effect.Effect<R, E, A>, pf: (a: A) => Option.Option<Stream<R2, E2, A2>>): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Returns the stream if the given effectful condition is satisfied, otherwise
+ * returns an empty stream.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const whenEffect: {
+    <R2, E2>(effect: Effect.Effect<R2, E2, boolean>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2>(self: Stream<R, E, A>, effect: Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Wraps the stream with a new span for tracing.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const withSpan: {
+    (name: string, options?: {
+        readonly attributes?: Record<string, Tracer.AttributeValue>;
+        readonly links?: ReadonlyArray<Tracer.SpanLink>;
+        readonly parent?: Tracer.ParentSpan;
+        readonly root?: boolean;
+        readonly context?: Context.Context<never>;
+    }): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, name: string, options?: {
+        readonly attributes?: Record<string, Tracer.AttributeValue>;
+        readonly links?: ReadonlyArray<Tracer.SpanLink>;
+        readonly parent?: Tracer.ParentSpan;
+        readonly root?: boolean;
+        readonly context?: Context.Context<never>;
+    }): Stream<R, E, A>;
+};
+/**
+ * Zips this stream with another point-wise and emits tuples of elements from
+ * both streams.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zip: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, readonly [A, A2]>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, readonly [A, A2]>;
+};
+/**
+ * Zips this stream with another point-wise and emits tuples of elements from
+ * both streams.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipFlatten: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A extends ReadonlyArray<any>>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, readonly [...A, A2]>;
+    <R, E, A extends ReadonlyArray<any>, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, readonly [...A, A2]>;
+};
+/**
+ * Zips this stream with another point-wise, creating a new stream of pairs of
+ * elements from both sides.
+ *
+ * The defaults `defaultLeft` and `defaultRight` will be used if the streams
+ * have different lengths and one of the streams has ended before the other.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipAll: {
+    <R2, E2, A2, A>(options: {
+        readonly other: Stream<R2, E2, A2>;
+        readonly defaultSelf: A;
+        readonly defaultOther: A2;
+    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, readonly [A, A2]>;
+    <R, E, R2, E2, A2, A>(self: Stream<R, E, A>, options: {
+        readonly other: Stream<R2, E2, A2>;
+        readonly defaultSelf: A;
+        readonly defaultOther: A2;
+    }): Stream<R | R2, E | E2, readonly [A, A2]>;
+};
+/**
+ * Zips this stream with another point-wise, and keeps only elements from this
+ * stream.
+ *
+ * The provided default value will be used if the other stream ends before
+ * this one.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipAllLeft: {
+    <R2, E2, A2, A>(that: Stream<R2, E2, A2>, defaultLeft: A): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, R2, E2, A2, A>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, defaultLeft: A): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Zips this stream with another point-wise, and keeps only elements from the
+ * other stream.
+ *
+ * The provided default value will be used if this stream ends before the
+ * other one.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipAllRight: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>, defaultRight: A2): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, defaultRight: A2): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Zips this stream that is sorted by distinct keys and the specified stream
+ * that is sorted by distinct keys to produce a new stream that is sorted by
+ * distinct keys. Combines values associated with each key into a tuple,
+ * using the specified values `defaultLeft` and `defaultRight` to fill in
+ * missing values.
+ *
+ * This allows zipping potentially unbounded streams of data by key in
+ * constant space but the caller is responsible for ensuring that the
+ * streams are sorted by distinct keys.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipAllSortedByKey: {
+    <R2, E2, A2, A, K>(options: {
+        readonly other: Stream<R2, E2, readonly [K, A2]>;
+        readonly defaultSelf: A;
+        readonly defaultOther: A2;
+        readonly order: Order.Order<K>;
+    }): <R, E>(self: Stream<R, E, readonly [K, A]>) => Stream<R2 | R, E2 | E, readonly [K, readonly [A, A2]]>;
+    <R, E, R2, E2, A2, A, K>(self: Stream<R, E, readonly [K, A]>, options: {
+        readonly other: Stream<R2, E2, readonly [K, A2]>;
+        readonly defaultSelf: A;
+        readonly defaultOther: A2;
+        readonly order: Order.Order<K>;
+    }): Stream<R | R2, E | E2, readonly [K, readonly [A, A2]]>;
+};
+/**
+ * Zips this stream that is sorted by distinct keys and the specified stream
+ * that is sorted by distinct keys to produce a new stream that is sorted by
+ * distinct keys. Keeps only values from this stream, using the specified
+ * value `default` to fill in missing values.
+ *
+ * This allows zipping potentially unbounded streams of data by key in
+ * constant space but the caller is responsible for ensuring that the
+ * streams are sorted by distinct keys.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipAllSortedByKeyLeft: {
+    <R2, E2, A2, A, K>(options: {
+        readonly other: Stream<R2, E2, readonly [K, A2]>;
+        readonly defaultSelf: A;
+        readonly order: Order.Order<K>;
+    }): <R, E>(self: Stream<R, E, readonly [K, A]>) => Stream<R2 | R, E2 | E, readonly [K, A]>;
+    <R, E, R2, E2, A2, A, K>(self: Stream<R, E, readonly [K, A]>, options: {
+        readonly other: Stream<R2, E2, readonly [K, A2]>;
+        readonly defaultSelf: A;
+        readonly order: Order.Order<K>;
+    }): Stream<R | R2, E | E2, readonly [K, A]>;
+};
+/**
+ * Zips this stream that is sorted by distinct keys and the specified stream
+ * that is sorted by distinct keys to produce a new stream that is sorted by
+ * distinct keys. Keeps only values from that stream, using the specified
+ * value `default` to fill in missing values.
+ *
+ * This allows zipping potentially unbounded streams of data by key in
+ * constant space but the caller is responsible for ensuring that the
+ * streams are sorted by distinct keys.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipAllSortedByKeyRight: {
+    <R2, E2, A2, K>(options: {
+        readonly other: Stream<R2, E2, readonly [K, A2]>;
+        readonly defaultOther: A2;
+        readonly order: Order.Order<K>;
+    }): <R, E, A>(self: Stream<R, E, readonly [K, A]>) => Stream<R2 | R, E2 | E, readonly [K, A2]>;
+    <R, E, A, R2, E2, A2, K>(self: Stream<R, E, readonly [K, A]>, options: {
+        readonly other: Stream<R2, E2, readonly [K, A2]>;
+        readonly defaultOther: A2;
+        readonly order: Order.Order<K>;
+    }): Stream<R | R2, E | E2, readonly [K, A2]>;
+};
+/**
+ * Zips this stream that is sorted by distinct keys and the specified stream
+ * that is sorted by distinct keys to produce a new stream that is sorted by
+ * distinct keys. Uses the functions `left`, `right`, and `both` to handle
+ * the cases where a key and value exist in this stream, that stream, or
+ * both streams.
+ *
+ * This allows zipping potentially unbounded streams of data by key in
+ * constant space but the caller is responsible for ensuring that the
+ * streams are sorted by distinct keys.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipAllSortedByKeyWith: {
+    <R2, E2, A, A3, A2, K>(options: {
+        readonly other: Stream<R2, E2, readonly [K, A2]>;
+        readonly onSelf: (a: A) => A3;
+        readonly onOther: (a2: A2) => A3;
+        readonly onBoth: (a: A, a2: A2) => A3;
+        readonly order: Order.Order<K>;
+    }): <R, E>(self: Stream<R, E, readonly [K, A]>) => Stream<R2 | R, E2 | E, readonly [K, A3]>;
+    <R, E, R2, E2, A, A3, A2, K>(self: Stream<R, E, readonly [K, A]>, options: {
+        readonly other: Stream<R2, E2, readonly [K, A2]>;
+        readonly onSelf: (a: A) => A3;
+        readonly onOther: (a2: A2) => A3;
+        readonly onBoth: (a: A, a2: A2) => A3;
+        readonly order: Order.Order<K>;
+    }): Stream<R | R2, E | E2, readonly [K, A3]>;
+};
+/**
+ * Zips this stream with another point-wise. The provided functions will be
+ * used to create elements for the composed stream.
+ *
+ * The functions `left` and `right` will be used if the streams have different
+ * lengths and one of the streams has ended before the other.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipAllWith: {
+    <R2, E2, A2, A, A3>(options: {
+        readonly other: Stream<R2, E2, A2>;
+        readonly onSelf: (a: A) => A3;
+        readonly onOther: (a2: A2) => A3;
+        readonly onBoth: (a: A, a2: A2) => A3;
+    }): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A3>;
+    <R, E, R2, E2, A2, A, A3>(self: Stream<R, E, A>, options: {
+        readonly other: Stream<R2, E2, A2>;
+        readonly onSelf: (a: A) => A3;
+        readonly onOther: (a2: A2) => A3;
+        readonly onBoth: (a: A, a2: A2) => A3;
+    }): Stream<R | R2, E | E2, A3>;
+};
+/**
+ * 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
+ * produce a result.
+ *
+ * Note: tracking the latest value is done on a per-chunk basis. That means
+ * that emitted elements that are not the last value in chunks will never be
+ * used for zipping.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipLatest: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, readonly [A, A2]>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, readonly [A, A2]>;
+};
+/**
+ * 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
+ * produce a result.
+ *
+ * Note: tracking the latest value is done on a per-chunk basis. That means
+ * that emitted elements that are not the last value in chunks will never be
+ * used for zipping.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipLatestWith: {
+    <R2, E2, A2, A, A3>(that: Stream<R2, E2, A2>, f: (a: A, a2: A2) => A3): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A3>;
+    <R, E, R2, E2, A2, A, A3>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, f: (a: A, a2: A2) => A3): Stream<R | R2, E | E2, A3>;
+};
+/**
+ * Zips this stream with another point-wise, but keeps only the outputs of
+ * this stream.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipLeft: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A>;
+};
+/**
+ * Zips this stream with another point-wise, but keeps only the outputs of the
+ * other stream.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipRight: {
+    <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A2>;
+};
+/**
+ * Zips this stream with another point-wise and applies the function to the
+ * paired elements.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipWith: {
+    <R2, E2, A2, A, A3>(that: Stream<R2, E2, A2>, f: (a: A, a2: A2) => A3): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A3>;
+    <R, E, R2, E2, A2, A, A3>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, f: (a: A, a2: A2) => A3): Stream<R | R2, E | E2, A3>;
+};
+/**
+ * Zips this stream with another point-wise and applies the function to the
+ * paired elements.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipWithChunks: {
+    <R2, E2, A2, A, A3>(that: Stream<R2, E2, A2>, f: (left: Chunk.Chunk<A>, right: Chunk.Chunk<A2>) => readonly [Chunk.Chunk<A3>, Either.Either<Chunk.Chunk<A>, Chunk.Chunk<A2>>]): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A3>;
+    <R, E, R2, E2, A2, A, A3>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, f: (left: Chunk.Chunk<A>, right: Chunk.Chunk<A2>) => readonly [Chunk.Chunk<A3>, Either.Either<Chunk.Chunk<A>, Chunk.Chunk<A2>>]): Stream<R | R2, E | E2, A3>;
+};
+/**
+ * Zips each element with the next element if present.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipWithNext: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, readonly [A, Option.Option<A>]>;
+/**
+ * Zips each element with the previous element. Initially accompanied by
+ * `None`.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipWithPrevious: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, readonly [Option.Option<A>, A]>;
+/**
+ * Zips each element with both the previous and next element.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipWithPreviousAndNext: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, readonly [Option.Option<A>, A, Option.Option<A>]>;
+/**
+ * Zips this stream together with the index of elements.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipWithIndex: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, readonly [A, number]>;
+/**
+ * @since 1.0.0
+ * @category do notation
+ */
+export declare const Do: Stream<never, never, {}>;
+/**
+ * Binds a value from a stream in a `do` scope
+ *
+ * @since 1.0.0
+ * @category do notation
+ */
+export declare const bind: {
+    <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => Stream<R2, E2, A>, options?: {
+        readonly concurrency?: number | "unbounded";
+        readonly bufferSize?: number;
+    }): <R, E>(self: Stream<R, E, K>) => Stream<R2 | R, E2 | E, Effect.MergeRecord<K, {
+        [k in N]: A;
+    }>>;
+    <R, E, N extends string, K, R2, E2, A>(self: Stream<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => Stream<R2, E2, A>, options?: {
+        readonly concurrency?: number | "unbounded";
+        readonly bufferSize?: number;
+    }): Stream<R | R2, E | E2, Effect.MergeRecord<K, {
+        [k in N]: A;
+    }>>;
+};
+/**
+ * Binds an effectful value in a `do` scope
+ *
+ * @since 1.0.0
+ * @category do notation
+ */
+export declare const bindEffect: {
+    <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => Effect.Effect<R2, E2, A>, options?: {
+        readonly concurrency?: number | "unbounded";
+        readonly bufferSize?: number;
+    }): <R, E>(self: Stream<R, E, K>) => Stream<R2 | R, E2 | E, Effect.MergeRecord<K, {
+        [k in N]: A;
+    }>>;
+    <R, E, N extends string, K, R2, E2, A>(self: Stream<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => Effect.Effect<R2, E2, A>, options?: {
+        readonly concurrency?: number | "unbounded";
+        readonly bufferSize?: number;
+    }): Stream<R | R2, E | E2, Effect.MergeRecord<K, {
+        [k in N]: A;
+    }>>;
+};
+/**
+ * @since 1.0.0
+ * @category do notation
+ */
+export declare const bindTo: {
+    <N extends string>(tag: N): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Record<N, A>>;
+    <R, E, A, N extends string>(self: Stream<R, E, A>, tag: N): Stream<R, E, Record<N, A>>;
+};
+declare const let_: {
+    <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <R, E>(self: Stream<R, E, K>) => Stream<R, E, Effect.MergeRecord<K, {
+        [k in N]: A;
+    }>>;
+    <R, E, K, N extends string, A>(self: Stream<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => A): Stream<R, E, Effect.MergeRecord<K, {
+        [k in N]: A;
+    }>>;
+};
+export { 
+/**
+ * Bind a value in a `do` scope
+ *
+ * @since 1.0.0
+ * @category do notation
+ */
+let_ as let };
+/**
+ * Decode Uint8Array chunks into a stream of strings using the specified encoding.
+ *
+ * @since 1.0.0
+ * @category encoding
+ */
+export declare const decodeText: {
+    (encoding?: string): <R, E>(self: Stream<R, E, Uint8Array>) => Stream<R, E, string>;
+    <R, E>(self: Stream<R, E, Uint8Array>, encoding?: string): Stream<R, E, string>;
+};
+/**
+ * Encode a stream of strings into a stream of Uint8Array chunks using the specified encoding.
+ *
+ * @since 1.0.0
+ * @category encoding
+ */
+export declare const encodeText: <R, E>(self: Stream<R, E, string>) => Stream<R, E, Uint8Array>;
+//# sourceMappingURL=Stream.d.ts.map