@fncts/io 0.0.1

package/Stream/api.d.ts

@@ -0,0 +1,1087 @@
+import { Either } from "@fncts/base/data/Either";
+import { Sink } from "@fncts/io/Sink/definition";
+import { Schedule } from "@fncts/io/Schedule/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Channel } from "@fncts/io/Channel";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Cause } from "@fncts/base/data/Cause";
+import { Lazy } from "@fncts/base/data/function";
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Future } from "@fncts/io/Future";
+import { Ref } from "@fncts/io/Ref";
+import { Environment } from "@fncts/base/data/Environment";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { Predicate } from "@fncts/base/data/Predicate";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Refinement } from "@fncts/base/data/Refinement";
+import { Layer } from "@fncts/io/Layer";
+import { Hub } from "@fncts/io/Hub/definition";
+import type { PHub } from "../Hub.js";
+import type { Canceler } from "../IO.js";
+import type { PQueue } from "../Queue.js";
+import type { Erase } from "@fncts/typelevel/Intersection.js";
+import { MergeDecision } from "../Channel/internal/MergeDecision.js";
+import { Queue } from "../Queue.js";
+import { Stream } from "./definition.js";
+import { Take } from "./internal/Take.js";
+/**
+ * Submerges the error case of an `Either` into the `Stream`.
+ * @tsplus getter fncts.io.Stream absolve
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function absolve<R, E, E2, A>(self: Stream<R, E, Either<E2, A>>): Stream<R, E | E2, 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.foldWeightedM` and `Sink.foldUntilM` for
+ * sinks that cover the common usecases.
+ * @tsplus fluent fncts.io.Stream aggregateAsync
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function aggregateAsync_<R, E, A extends A1, R1, E1, A1, B>(stream: Stream<R, E, A>, sink: Sink<R1, E1, A1, A1, B>): Stream<R & R1, E | E1, B>;
+/**
+ * Like `aggregateAsyncWithinEither`, but only returns the `Right` results.
+ * @tsplus fluent fncts.io.Stream aggregateAsyncWithin
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function aggregateAsyncWithin_<R, E, A extends A1, R1, E1, A1, B, R2, C>(stream: Stream<R, E, A>, sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>): Stream<R & R1 & R2, E | E1, 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.
+ * @tsplus fluent fncts.io.Stream aggregateAsyncWithinEither
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function aggregateAsyncWithinEither_<R, E, A extends A1, R1, E1, A1, B, R2, C>(stream: Stream<R, E, A>, sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>): Stream<R & R1 & R2, E | E1, Either<C, B>>;
+/**
+ * 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.
+ * @tsplus fluent fncts.io.Stream apFirst
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function apFirst_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>): Stream<R & R1, E | E1, 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.
+ * @tsplus fluent fncts.io.Stream apSecond
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function apSecond_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>): Stream<R & R1, E | E1, A1>;
+/**
+ * Maps the success values of this stream to the specified constant value.
+ * @tsplus fluent fncts.io.Stream as
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function as_<R, E, A, B>(stream: Stream<R, E, A>, b: Lazy<B>): Stream<R, E, B>;
+/**
+ * @tsplus static fncts.io.StreamOps asyncInterrupt
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function asyncInterrupt<R, E, A>(register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => Either<Canceler<R>, 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`.
+ * @tsplus static fncts.io.StreamOps asyncMaybe
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function asyncMaybe<R, E, A>(register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => Maybe<Stream<R, E, A>>, outputBuffer?: number): Stream<R, E, A>;
+/**
+ * @tsplus static fncts.io.StreamOps async
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function async<R, E, A>(register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => void, outputBuffer?: number): Stream<R, E, A>;
+/**
+ * @tsplus static fncts.io.StreamOps asyncIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function asyncIO<R, E, A, R1 = R, E1 = E>(register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => IO<R1, E1, unknown>, outputBuffer?: number): Stream<R & R1, E | E1, A>;
+/**
+ * Returns a stream whose failure and success channels have been mapped by
+ * the specified pair of functions, `f` and `g`.
+ */
+export declare function bimap_<R, E, E1, A, A1>(stream: Stream<R, E, A>, f: (e: E) => E1, g: (a: A) => A1): Stream<R, E1, A1>;
+/**
+ * Creates a stream from a single value that will get cleaned up after the
+ * stream is consumed
+ * @tsplus static fncts.io.StreamOps acquireRelease
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function acquireRelease_<R, E, A, R1>(acquire: IO<R, E, A>, release: (a: A) => IO<R1, never, unknown>): Stream<R & R1, E, A>;
+/**
+ * Creates a stream from a single value that will get cleaned up after the
+ * stream is consumed
+ * @tsplus static fncts.io.StreamOps acquireReleaseExit
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function acquireReleaseExit_<R, E, A, R1>(acquire: IO<R, E, A>, release: (a: A, exit: Exit<any, any>) => IO<R1, never, unknown>): Stream<R & R1, E, A>;
+/**
+ * Fan out the stream, producing a list of streams that have the same elements as this stream.
+ * The driver stream will only ever advance of the `maximumLag` chunks before the
+ * slowest downstream stream.
+ * @tsplus fluent fncts.io.Stream broadcast
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function broadcast_<R, E, A>(stream: Stream<R, E, A>, n: number, maximumLag: number): IO<R & Has<Scope>, never, Conc<Stream<unknown, E, A>>>;
+/**
+ * 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 of the `maximumLag` chunks before the
+ * slowest downstream stream.
+ * @tsplus fluent fncts.io.Stream broadcastDynamic
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function broadcastDynamic_<R, E, A>(stream: Stream<R, E, A>, maximumLag: number): IO<R & Has<Scope>, never, Stream<unknown, E, A>>;
+/**
+ * Converts the stream to a managed 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 backpressured.
+ *
+ * Queues can unsubscribe from upstream by shutting down.
+ * @tsplus fluent fncts.io.Stream broadcastedQueues
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function broadcastedQueues_<R, E, A>(stream: Stream<R, E, A>, n: number, maximumLag: number): IO<R & Has<Scope>, never, Conc<Hub.Dequeue<unknown, never, Take<E, A>>>>;
+/**
+ * Converts the stream to a managed 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 backpressured.
+ *
+ * Queues can unsubscribe from upstream by shutting down.
+ * @tsplus fluent fncts.io.Stream broadcastedQueuesDynamic
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function broadcastedQueuesDynamic_<R, E, A>(stream: Stream<R, E, A>, maximumLag: number): IO<R & Has<Scope>, never, IO<Has<Scope>, never, Hub.Dequeue<unknown, never, Take<E, A>>>>;
+/**
+ * Allows a faster producer to progress independently of a slower consumer by buffering
+ * up to `capacity` elements in a queue.
+ * @tsplus fluent fncts.io.Stream buffer
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function buffer_<R, E, A>(stream: Stream<R, E, A>, capacity: number): Stream<R, E, A>;
+/**
+ * @tsplus fluent fncts.io.Stream bufferChunks
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function bufferChunks_<R, E, A>(stream: Stream<R, E, A>, capacity: number): Stream<R, E, A>;
+/**
+ * Allows a faster producer to progress independently of a slower consumer by buffering
+ * elements into an unbounded queue.
+ * @tsplus getter fncts.io.Stream bufferUnbounded
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function bufferUnbounded<R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A>;
+/**
+ * Switches over to the stream produced by the provided function in case this one
+ * fails with a typed error.
+ * @tsplus fluent fncts.io.Stream catchAll
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function catchAll_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, f: (e: E) => Stream<R1, E1, A1>): Stream<R & R1, E1, A | A1>;
+/**
+ * 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.
+ * @tsplus fluent fncts.io.Stream catchAllCause
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function catchAllCause_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, f: (cause: Cause<E>) => Stream<R1, E1, A1>): Stream<R & R1, E1, A | A1>;
+/**
+ * Switches over to the stream produced by the provided function in case this one
+ * fails with some typed error.
+ * @tsplus fluent fncts.io.Stream catchJust
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function catchJust_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, pf: (e: E) => Maybe<Stream<R1, E1, A1>>): Stream<R & R1, E | E1, A | A1>;
+/**
+ * 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.
+ * @tsplus fluent fncts.io.Stream catchJustCause
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function catchJustCause_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, pf: (e: Cause<E>) => Maybe<Stream<R1, E1, A1>>): Stream<R & R1, E | E1, A | A1>;
+/**
+ * Returns a stream made of the concatenation in strict order of all the streams
+ * produced by passing each element of this stream to `f`
+ * @tsplus fluent fncts.io.Stream flatMap
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function flatMap_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => Stream<R1, E1, B>): Stream<R & R1, E | E1, B>;
+/**
+ * Exposes the underlying chunks of the stream as a stream of chunks of elements
+ * @tsplus getter fncts.io.Stream chunks
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function chunks<R, E, A>(stream: Stream<R, E, A>): Stream<R, E, Conc<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.
+ * @tsplus fluent fncts.io.Stream changesWith
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function changesWith_<R, E, A>(stream: Stream<R, E, A>, f: (x: A, y: A) => boolean): Stream<R, E, A>;
+/**
+ * Transforms all elements of the stream for as long as the specified partial function is defined.
+ * @tsplus fluent fncts.io.Stream collectWhile
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function collectWhile_<R, E, A, A1>(stream: Stream<R, E, A>, pf: (a: A) => Maybe<A1>): Stream<R, E, A1>;
+/**
+ * Effectfully transforms all elements of the stream for as long as the specified partial function is defined.
+ */
+export declare function collectWhileIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, pf: (a: A) => Maybe<IO<R1, E1, B>>): Stream<R & R1, E | E1, B>;
+/**
+ * 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.
+ * @tsplus fluent fncts.io.Stream combine
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function combine_<R, E, A, R1, E1, A1, S, R2, A2>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, s: S, f: (s: S, eff1: IO<R, Maybe<E>, A>, eff2: IO<R1, Maybe<E1>, A1>) => IO<R2, never, Exit<Maybe<E | E1>, readonly [A2, S]>>): Stream<R & R1 & R2, E | E1, A2>;
+/**
+ * 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`.
+ * @tsplus fluent fncts.io.Stream combineChunks
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function combineChunks_<R, E, A, R1, E1, A1, S, R2, A2>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, s: S, f: (s: S, l: IO<R, Maybe<E>, Conc<A>>, r: IO<R1, Maybe<E1>, Conc<A1>>) => IO<R2, never, Exit<Maybe<E | E1>, readonly [Conc<A2>, S]>>): Stream<R1 & R & R2, E | E1, A2>;
+/**
+ * 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.
+ * @tsplus fluent fncts.io.Stream concat
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function concat_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>): Stream<R & R1, E | E1, A | A1>;
+/**
+ * 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.
+ * @tsplus fluent fncts.io.Stream cross
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function cross_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, that: Stream<R1, E1, B>): Stream<R & R1, E | E1, readonly [A, B]>;
+/**
+ * Composes this stream with the specified stream to create a cartesian product of elements
+ * with a specified function.
+ * The `fb` stream would be run multiple times, for every element in the `fa` stream.
+ * @tsplus fluent fncts.io.Stream crossWith
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function crossWith_<R, E, A, R1, E1, B, C>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, f: (a: A, b: B) => C): Stream<R & R1, E | E1, C>;
+/**
+ * Provides some of the environment required to run this effect,
+ * leaving the remainder `R0`.
+ * @tsplus fluent fncts.io.Stream contramapEnvironment
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function contramapEnvironment_<R, E, A, R0>(ra: Stream<R, E, A>, f: (r0: Environment<R0>) => Environment<R>): Stream<R0, E, A>;
+/**
+ * @tsplus fluent fncts.io.Stream debounce
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function debounce_<R, E, A>(stream: Stream<R, E, A>, duration: number): Stream<R, E, A>;
+/**
+ * Switches to the provided stream in case this one is empty.
+ * @tsplus fluent fncts.io.Stream defaultIfEmpty
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function defaultIfEmpty_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>): Stream<R & R1, E | E1, A | B>;
+/**
+ * More powerful version of `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.
+ * @tsplus fluent fncts.io.Stream distributedWith
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function distributedWith_<R, E, A>(self: Stream<R, E, A>, n: number, maximumLag: number, decide: (_: A) => UIO<(_: number) => boolean>): IO<R & Has<Scope>, never, Conc<Queue.Dequeue<Exit<Maybe<E>, A>>>>;
+/**
+ * More powerful version of `ZStream#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.
+ * @tsplus fluent fncts.io.Stream distributedWithDynamic
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function distributedWithDynamic_<R, E, A>(self: Stream<R, E, A>, maximumLag: number, decide: (a: A) => UIO<(_: symbol) => boolean>, done?: (exit: Exit<Maybe<E>, never>) => UIO<any>): IO<R & Has<Scope>, never, UIO<readonly [symbol, Queue.Dequeue<Exit<Maybe<E>, A>>]>>;
+/**
+ * Converts this stream to a stream that executes its effects but emits no
+ * elements. Useful for sequencing effects using streams.
+ * @tsplus getter fncts.io.Stream drain
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function drain<R, E, A>(fa: Stream<R, E, A>): Stream<R, E, void>;
+/**
+ * Drops the specified number of elements from this stream.
+ * @tsplus fluent fncts.io.Stream drop
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function drop_<R, E, A>(stream: Stream<R, E, A>, n: number): Stream<R, E, A>;
+/**
+ * Drops all elements of the stream for as long as the specified predicate
+ * evaluates to `true`.
+ * @tsplus fluent fncts.io.Stream dropWhile
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function dropWhile_<R, E, A>(stream: Stream<R, E, A>, p: Predicate<A>): Stream<R, E, A>;
+/**
+ * Drops all elements of the stream until the specified predicate evaluates
+ * to `true`.
+ * @tsplus fluent fncts.io.Stream dropUntil
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function dropUntil_<R, E, A>(stream: Stream<R, E, A>, p: Predicate<A>): Stream<R, E, 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.
+ * @tsplus getter fncts.io.Stream either
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function either<R, E, A>(stream: Stream<R, E, A>): Stream<R, never, Either<E, A>>;
+/**
+ * @tsplus static fncts.io.StreamOps empty
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare const empty: Stream<unknown, never, never>;
+/**
+ * Halts the evaluation of this stream when the provided IO completes. The given IO
+ * 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 IO
+ * completes. See `interruptWhen` for this behavior.
+ *
+ * If the IO completes with a failure, the stream will emit that failure.
+ * @tsplus fluent fncts.io.Stream endWhen
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function endWhen_<R, E, A, R1, E1>(stream: Stream<R, E, A>, io: IO<R1, E1, any>): Stream<R & R1, E | E1, A>;
+/**
+ * @tsplus fluent fncts.io.Stream ensuring
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function ensuring_<R, E, A, R1>(self: Stream<R, E, A>, finalizer: IO<R1, never, any>): Stream<R & R1, E, A>;
+/**
+ * @tsplus static fncts.io.StreamOps environment
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function environment<R>(): Stream<R, never, Environment<R>>;
+/**
+ * Accesses the environment of the stream.
+ * @tsplus static fncts.io.StreamOps environmentWith
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function environmentWith<R, A>(f: (r: Environment<R>) => A): Stream<R, never, A>;
+/**
+ * Accesses the environment of the stream in the context of an effect.
+ * @tsplus static fncts.io.StreamOps environmentWithIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function environmentWithIO<R0, R, E, A>(f: (r0: Environment<R0>) => IO<R, E, A>): Stream<R0 & R, E, A>;
+/**
+ * Accesses the environment of the stream in the context of a stream.
+ * @tsplus static fncts.io.StreamOps environmentWithStream
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function environmentWithStream<R0, R, E, A>(f: (r0: Environment<R0>) => Stream<R, E, A>): Stream<R0 & R, E, A>;
+/**
+ * Halt a stream with the specified error
+ * @tsplus static fncts.io.StreamOps failNow
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function failNow<E>(error: E): Stream<unknown, E, never>;
+/**
+ * Halt a stream with the specified error
+ * @tsplus static fncts.io.StreamOps fail
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fail<E>(error: Lazy<E>): Stream<unknown, E, never>;
+/**
+ * The stream that always halts with `cause`.
+ * @tsplus static fncts.io.StreamOps failCauseNow
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function failCauseNow<E>(cause: Cause<E>): Stream<unknown, E, never>;
+/**
+ * The stream that always halts with `cause`.
+ * @tsplus static fncts.io.StreamOps failCause
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function failCause<E>(cause: Lazy<Cause<E>>): Stream<unknown, E, never>;
+/**
+ * @tsplus fluent fncts.io.Stream filter
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function filter_<R, E, A, B extends A>(fa: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>;
+export declare function filter_<R, E, A>(fa: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
+/**
+ * @tsplus fluent fncts.io.Stream filterIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function filterIO_<R, E, A, R1, E1>(fa: Stream<R, E, A>, f: (a: A) => IO<R1, E1, boolean>): Stream<R & R1, E | E1, A>;
+/**
+ * @tsplus fluent fncts.io.Stream filterMap
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function filterMap_<R, E, A, B>(fa: Stream<R, E, A>, f: (a: A) => Maybe<B>): Stream<R, E, B>;
+/**
+ * @tsplus fluent fncts.io.Stream filterMapIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function filterMapIO_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, f: (a: A) => IO<R1, E1, Maybe<B>>): Stream<R & R1, E | E1, B>;
+/**
+ * Finds the first element emitted by this stream that satisfies the provided predicate.
+ * @tsplus fluent fncts.io.Stream find
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function find_<R, E, A>(stream: Stream<R, E, A>, p: Predicate<A>): Stream<R, E, A>;
+/**
+ * Finds the first element emitted by this stream that satisfies the provided effectful predicate.
+ * @tsplus fluent fncts.io.Stream findIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function findIO_<R, E, A, R1, E1>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, boolean>): Stream<R & R1, E | E1, A>;
+/**
+ * Flattens this stream-of-streams into a stream made of the concatenation in
+ * strict order of all the streams.
+ * @tsplus getter fncts.io.Stream flatten
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function flatten<R, E, R1, E1, A>(self: Stream<R, E, Stream<R1, E1, A>>): Stream<R & R1, E | E1, A>;
+/**
+ * Unwraps `Exit` values that also signify end-of-stream by failing with `None`.
+ *
+ * For `Exit<E, A>` values that do not signal end-of-stream, prefer:
+ * @tsplus getter fncts.io.Stream flattenExitOption
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function flattenExitOption<R, E, E1, A>(stream: Stream<R, E, Exit<Maybe<E1>, A>>): Stream<R, E | E1, A>;
+/**
+ * Unwraps `Exit` values and flatten chunks that also signify end-of-stream by failing with `None`.
+ * @tsplus getter fncts.io.Stream flattenTake
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function flattenTake<R, E, E1, A>(stream: Stream<R, E, Take<E1, A>>): Stream<R, E | E1, A>;
+/**
+ * Submerges the chunks carried by this stream into the stream's structure, while
+ * still preserving them.
+ * @tsplus getter fncts.io.Stream flattenChunks
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function flattenChunks<R, E, A>(stream: Stream<R, E, Conc<A>>): Stream<R, E, A>;
+/**
+ * Repeats this stream forever.
+ * @tsplus getter fncts.io.Stream forever
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function forever<R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A>;
+/**
+ * Creates a stream from a `Chunk` of values
+ * @tsplus static fncts.io.StreamOps fromChunkNow
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fromChunkNow<O>(c: Conc<O>): Stream<unknown, never, O>;
+/**
+ * Creates a stream from a `Chunk` of values
+ * @tsplus static fncts.io.StreamOps fromChunk
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fromChunk<O>(c: Lazy<Conc<O>>): Stream<unknown, never, O>;
+/**
+ * Creates a single-valued stream from a managed resource
+ * @tsplus static fncts.io.StreamOps scoped
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function scoped<R, E, A>(stream: IO<R & Has<Scope>, E, A>): Stream<R, E, A>;
+/**
+ * Creates a stream from an effect producing a value of type `A`
+ * @tsplus static fncts.io.StreamOps fromIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fromIO<R, E, A>(fa: IO<R, E, A>): Stream<R, E, A>;
+/**
+ * Creates a stream from an effect producing a value of type `A` or an empty Stream
+ * @tsplus static fncts.io.StreamOps fromIOMaybe
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fromIOMaybe<R, E, A>(fa: IO<R, Maybe<E>, A>): Stream<R, E, A>;
+/**
+ * @tsplus static fncts.io.StreamOps fromAsyncIterable
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fromAsyncIterable<A>(iterable: AsyncIterable<A>): Stream<unknown, never, A>;
+/**
+ * @tsplus static fncts.io.StreamOps fromIterable
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fromIterable<A>(iterable: Iterable<A>, maxChunkSize?: number): Stream<unknown, never, A>;
+/**
+ * @tsplus static fncts.io.StreamOps fromIterableSingle
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fromIterableSingle<A>(iterable: Iterable<A>): Stream<unknown, never, A>;
+/**
+ * @tsplus static fncts.io.StreamOps fromPull
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fromPull<R, E, A>(scopedPull: IO<R & Has<Scope>, never, IO<R, Maybe<E>, Conc<A>>>): Stream<R, E, A>;
+/**
+ * Creates a stream from a `Queue` of values
+ * @tsplus static fncts.io.StreamOps fromQueue
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fromQueue_<R, E, O>(queue: PQueue<never, R, unknown, E, never, O>, maxChunkSize?: number): Stream<R, E, O>;
+/**
+ * @tsplus static fncts.io.StreamOps fromQueueWithShutdown
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fromQueueWithShutdown<R, E, A>(queue: PQueue<never, R, unknown, E, never, A>, maxChunkSize?: number): Stream<R, E, A>;
+/**
+ * Halt a stream with the specified exception
+ * @tsplus static fncts.io.StreamOps haltNow
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function haltNow(u: unknown): Stream<unknown, never, never>;
+/**
+ * Halt a stream with the specified exception
+ * @tsplus static fncts.io.StreamOps halt
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function halt(u: Lazy<unknown>): Stream<unknown, never, never>;
+/**
+ * Halts the evaluation of this stream when the provided IO completes. The
+ * given IO 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
+ * IO completes. See `interruptWhen` for this behavior.
+ *
+ * If the IO completes with a failure, the stream will emit that failure.
+ * @tsplus fluent fncts.io.Stream haltWhen
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function haltWhen_<R, E, A, R1, E1>(fa: Stream<R, E, A>, io: IO<R1, E1, any>): Stream<R & R1, E | E1, 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.
+ * @tsplus fluent fncts.io.Stream haltWhen
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function haltWhenFuture_<R, E, A, E1>(fa: Stream<R, E, A>, future: Future<E1, any>): Stream<R, E | E1, A>;
+/**
+ * @tsplus fluent fncts.io.Stream interleave
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function interleave_<R, E, A, R1, E1, B>(sa: Stream<R, E, A>, sb: Stream<R1, E1, B>): Stream<R & R1, E | E1, A | B>;
+/**
+ * Combines this stream and the specified stream deterministically using the
+ * stream of boolean values `b` to control which stream to pull from next.
+ * `true` indicates to pull from this stream and `false` indicates to pull
+ * from the specified stream. Only consumes as many elements as requested by
+ * `b`. If either this stream or the specified stream are exhausted further
+ * requests for values from that stream will be ignored.
+ * @tsplus fluent fncts.io.Stream interleaveWith
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function interleaveWith_<R, E, A, R1, E1, B, R2, E2>(sa: Stream<R, E, A>, sb: Stream<R1, E1, B>, b: Stream<R2, E2, boolean>): Stream<R & R1 & R2, E | E1 | E2, A | B>;
+/**
+ * Intersperse stream with provided element
+ */
+export declare function intersperse_<R, E, A, A1>(stream: Stream<R, E, A>, middle: A1): Stream<R, E, A | A1>;
+/**
+ * Interrupts the evaluation of this stream when the provided IO completes. The given
+ * IO 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 IO completes with a failure before the stream completes, the returned stream
+ * will emit that failure.
+ * @tsplus fluent fncts.io.Stream interruptWhen
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function interruptWhen_<R, E, A, R1, E1>(stream: Stream<R, E, A>, io: IO<R1, E1, any>): Stream<R & R1, E | E1, A>;
+/**
+ * @tsplus fluent fncts.io.Stream interruptWhen
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function interruptWhenFuture_<R, E, A, E1>(fa: Stream<R, E, A>, future: Future<E1, unknown>): Stream<R, E | E1, A>;
+/**
+ * Loops over the stream chunks concatenating the result of f
+ * @tsplus fluent fncts.io.Stream loopOnChunks
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function loopOnChunks_<R, E, A, R1, E1, A1>(stream: Stream<R, E, A>, f: (a: Conc<A>) => Channel<R1, E | E1, Conc<A>, unknown, E | E1, Conc<A1>, boolean>): Stream<R & R1, E | E1, A1>;
+/**
+ * Loops on chunks emitting partially
+ * @tsplus fluent fncts.io.Stream loopOnPartialChunks
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function loopOnPartialChunks_<R, E, A, R1, E1, A1>(stream: Stream<R, E, A>, f: (a: Conc<A>, emit: (a: A1) => UIO<void>) => IO<R1, E1, boolean>): Stream<R & R1, E | E1, A1>;
+/**
+ * Loops on chunks elements emitting partially
+ * @tsplus fluent fncts.io.Stream loopOnPartialChunksElements
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function loopOnPartialChunksElements_<R, E, A, R1, E1, A1>(stream: Stream<R, E, A>, f: (a: A, emit: (a: A1) => UIO<void>) => IO<R1, E1, void>): Stream<R & R1, E | E1, A1>;
+/**
+ * Transforms the elements of this stream using the supplied function.
+ * @tsplus fluent fncts.io.Stream map
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function map_<R, E, A, B>(stream: Stream<R, E, A>, f: (o: A) => B): Stream<R, E, B>;
+/**
+ * Statefully maps over the elements of this stream to produce new elements.
+ * @tsplus fluent fncts.io.Stream mapAccum
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapAccum_<R, E, A, S, B>(stream: Stream<R, E, A>, s: S, f: (s: S, a: A) => readonly [B, S]): Stream<R, E, B>;
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * new elements.
+ * @tsplus fluent fncts.io.Stream mapAccumIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapAccumIO_<R, E, A, R1, E1, S, B>(stream: Stream<R, E, A>, s: S, f: (s: S, a: A) => IO<R1, E1, readonly [B, S]>): Stream<R & R1, E | E1, B>;
+/**
+ * Transforms the chunks emitted by this stream.
+ * @tsplus fluent fncts.io.Stream mapChunks
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapChunks_<R, E, A, A1>(stream: Stream<R, E, A>, f: (chunk: Conc<A>) => Conc<A1>): Stream<R, E, A1>;
+/**
+ * Effectfully transforms the chunks emitted by this stream.
+ * @tsplus fluent fncts.io.Stream mapChunksIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapChunksIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (chunk: Conc<A>) => IO<R1, E1, Conc<B>>): Stream<R & R1, E | E1, B>;
+/**
+ * Maps each element to an iterable, and flattens the iterables into the
+ * output of this stream.
+ * @tsplus fluent fncts.io.Stream mapConcat
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapConcat_<R, E, A, B>(stream: Stream<R, E, A>, f: (a: A) => Iterable<B>): Stream<R, E, B>;
+/**
+ * Maps each element to a chunk, and flattens the chunks into the output of
+ * this stream.
+ * @tsplus fluent fncts.io.Stream mapConcatChunk
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapConcatChunk_<R, E, A, B>(stream: Stream<R, E, A>, f: (a: A) => Conc<B>): Stream<R, E, B>;
+/**
+ * Effectfully maps each element to a chunk, and flattens the chunks into
+ * the output of this stream.
+ * @tsplus fluent fncts.io.Stream mapConcatChunkIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapConcatChunkIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, Conc<B>>): Stream<R & R1, E | E1, B>;
+/**
+ * Effectfully maps each element to an iterable, and flattens the iterables into
+ * the output of this stream.
+ * @tsplus fluent fncts.io.Stream mapConcatIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapConcatIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, Iterable<B>>): Stream<R & R1, E | E1, B>;
+/**
+ * Transforms the errors emitted by this stream using `f`.
+ * @tsplus fluent fncts.io.Stream mapError
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapError_<R, E, E1, A>(stream: Stream<R, E, A>, f: (e: E) => E1): Stream<R, E1, A>;
+/**
+ * Transforms the full causes of failures emitted by this stream.
+ * @tsplus fluent fncts.io.Stream mapErrorCause
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapErrorCause_<R, E, A, E1>(fa: Stream<R, E, A>, f: (e: Cause<E>) => Cause<E1>): Stream<R, E1, A>;
+/**
+ * Maps over elements of the stream with the specified effectful function.
+ * @tsplus fluent fncts.io.Stream mapIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, B>): Stream<R & R1, E | E1, B>;
+/**
+ * Maps over elements of the stream with the specified effectful function,
+ * executing up to `n` invocations of `f` concurrently. Transformed elements
+ * will be emitted in the original order.
+ * @note This combinator destroys the chunking structure. It's recommended to use chunkN afterwards.
+ * @tsplus fluent fncts.io.Stream mapIOC
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapIOC_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, n: number, f: (a: A) => IO<R1, E1, B>): Stream<R & R1, E | E1, B>;
+/**
+ * Maps each element of this stream to another stream and returns the
+ * non-deterministic merge of those streams, executing up to `n` inner streams
+ * concurrently. Up to `bufferSize` elements of the produced streams may be
+ * buffered in memory by this operator.
+ * @tsplus fluent fncts.io.Stream mergeMap
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mergeMap_<R, E, A, R1, E1, B>(ma: Stream<R, E, A>, f: (a: A) => Stream<R1, E1, B>, n: number, bufferSize?: number): Stream<R & R1, E | E1, B>;
+/**
+ * Maps over elements of the stream with the specified effectful function,
+ * executing up to `n` invocations of `f` concurrently. The element order
+ * is not enforced by this combinator, and elements may be reordered.
+ * @tsplus fluent fncts.io.Stream mergeMapIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mergeMapIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, B>, n: number, bufferSize?: number): Stream<R & R1, E | E1, B>;
+/**
+ * @tsplus fluent fncts.io.Stream mergeEither
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mergeEither_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>): Stream<R & R1, E | E1, Either<A, B>>;
+export declare function mergeWithHandler<R, E>(terminate: boolean): (exit: Exit<E, unknown>) => MergeDecision<R, E, unknown, E, unknown>;
+export declare type TerminationStrategy = "Left" | "Right" | "Both" | "Either";
+/**
+ * @tsplus fluent fncts.io.Stream mergeWith
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mergeWith_<R, E, A, R1, E1, A1, B, C>(sa: Stream<R, E, A>, sb: Stream<R1, E1, A1>, l: (a: A) => B, r: (b: A1) => C, strategy?: TerminationStrategy): Stream<R & R1, E | E1, B | C>;
+/**
+ * Runs the specified effect if this stream fails, providing the error to the effect if it exists.
+ *
+ * Note: Unlike `IO.onError`, there is no guarantee that the provided effect will not be interrupted.
+ * @tsplus fluent fncts.io.Stream onError
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function onError_<R, E, A, R1>(stream: Stream<R, E, A>, cleanup: (e: Cause<E>) => IO<R1, never, any>): Stream<R & R1, E, A>;
+/**
+ * Switches to the provided stream in case this one fails with a typed error.
+ *
+ * See also Stream#catchAll
+ * @tsplus fluent fncts.io.Stream orElse
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function orElse_<R, E, A, R1, E1, A1>(stream: Stream<R, E, A>, that: Lazy<Stream<R1, E1, A1>>): Stream<R & R1, E1, A | A1>;
+/**
+ * Switches to the provided stream in case this one fails with a typed error.
+ *
+ * See also ZStream#catchAll
+ * @tsplus fluent fncts.io.Stream orElseEither
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function orElseEither_<R, E, A, R1, E1, A1>(stream: Stream<R, E, A>, that: Lazy<Stream<R1, E1, A1>>): Stream<R & R1, E1, Either<A, A1>>;
+/**
+ * Fails with given error in case this one fails with a typed error.
+ *
+ * See also Stream#catchAll
+ * @tsplus fluent fncts.io.Stream orElseFail
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function orElseFail_<R, E, A, E1>(stream: Stream<R, E, A>, e: Lazy<E1>): Stream<R, E1, A>;
+/**
+ * Switches to the provided stream in case this one fails with the `None` value.
+ *
+ * See also Stream#catchAll.
+ */
+export declare function orElseOptional_<R, E, A, R1, E1, A1>(stream: Stream<R, Maybe<E>, A>, that: Lazy<Stream<R1, Maybe<E1>, A1>>): Stream<R & R1, Maybe<E | E1>, A | A1>;
+/**
+ * Succeeds with the specified value if this one fails with a typed error.
+ * @tsplus fluent fncts.io.Stream orElseSucceed
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function orElseSucceed_<R, E, A, A1>(stream: Stream<R, E, A>, a: Lazy<A1>): Stream<R, never, A | A1>;
+/**
+ * @tsplus fluent fncts.io.Stream pipeThrough
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function pipeThrough_<R, E, A, R1, E1, L, Z>(ma: Stream<R, E, A>, sa: Sink<R1, E1, A, L, Z>): Stream<R & R1, E | E1, L>;
+/**
+ * Provides the stream with its required environment, which eliminates
+ * its dependency on `R`.
+ * @tsplus fluent fncts.io.Stream provideEnvironment
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function provideEnvironment_<R, E, A>(ra: Stream<R, E, A>, r: Environment<R>): Stream<unknown, E, A>;
+/**
+ * @tsplus fluent fncts.io.Stream provideLayer
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function provideLayer_<RIn, E, ROut, E1, A>(self: Stream<ROut, E, A>, layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): Stream<RIn, E | E1, A>;
+/**
+ * @tsplus fluent fncts.io.Stream provideSomeLayer
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function provideSomeLayer_<R, E, A, RIn, E1, ROut>(self: Stream<R, E, A>, layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): Stream<RIn & Erase<R, ROut>, E | E1, A>;
+/**
+ * Re-chunks the elements of the stream into chunks of
+ * `n` elements each.
+ * The last chunk might contain less than `n` elements
+ * @tsplus fluent fncts.io.Stream rechunk
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function rechunk_<R, E, A>(stream: Stream<R, E, A>, n: number): Stream<R, E, A>;
+/**
+ * Repeats the provided value infinitely.
+ * @tsplus static fncts.io.StreamOps repeatValue
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function repeatValue<A>(a: A): Stream<unknown, never, A>;
+/**
+ * Creates a stream from an effect producing a value of type `A` which repeats forever.
+ * @tsplus static fncts.io.StreamOps repeatIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function repeatIO<R, E, A>(fa: IO<R, E, A>): Stream<R, E, A>;
+/**
+ * Creates a stream from an effect producing values of type `A` until it fails with None.
+ * @tsplus static fncts.io.StreamOps repeatIOMaybe
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function repeatIOMaybe<R, E, A>(fa: IO<R, Maybe<E>, A>): Stream<R, E, A>;
+/**
+ * Creates a stream from an effect producing chunks of `A` values which repeats forever.
+ * @tsplus static fncts.io.StreamOps repeatIOChunk
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function repeatIOChunk<R, E, A>(fa: IO<R, E, Conc<A>>): Stream<R, E, A>;
+/**
+ * Creates a stream from an effect producing chunks of `A` values until it fails with None.
+ * @tsplus static fncts.io.StreamOps repeatIOChunkMaybe
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function repeatIOChunkMaybe<R, E, A>(fa: IO<R, Maybe<E>, Conc<A>>): Stream<R, E, A>;
+/**
+ * Runs the sink on the stream to produce either the sink's result or an error.
+ * @tsplus fluent fncts.io.Stream run
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function run_<R, E, A, R2, E2, Z>(stream: Stream<R, E, A>, sink: Sink<R2, E2, A, unknown, Z>): IO<R & R2, E | E2, Z>;
+/**
+ * Runs the stream and collects all of its elements to a chunk.
+ * @tsplus getter fncts.io.Stream runCollect
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function runCollect<R, E, A>(stream: Stream<R, E, A>): IO<R, E, Conc<A>>;
+/**
+ * Runs the stream and collects ignore its elements.
+ * @tsplus getter fncts.io.Stream runDrain
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function runDrain<R, E, A>(stream: Stream<R, E, A>): IO<R, E, void>;
+/**
+ * @tsplus fluent fncts.io.Stream runForeachScoped
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function runForeachScoped_<R, E, A, R2, E2>(self: Stream<R, E, A>, f: (a: A) => IO<R2, E2, any>): IO<R & R2 & Has<Scope>, E | E2, void>;
+/**
+ * Like `into`, but provides the result as a `Managed` to allow for scope
+ * composition.
+ * @tsplus fluent fncts.io.Stream runIntoElementsScoped
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function runIntoElementsScoped_<R, E, A, R1, E1>(stream: Stream<R, E, A>, queue: PQueue<R1, unknown, never, never, Exit<Maybe<E | E1>, A>, unknown>): IO<R & R1 & Has<Scope>, E | E1, void>;
+/**
+ * Like `Stream#into`, but provides the result as a `Managed` to allow for scope
+ * composition.
+ * @tsplus fluent fncts.io.Stream runIntoQueueScoped
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function runIntoQueueScoped_<R, R1, E extends E1, E1, A>(stream: Stream<R, E, A>, queue: PQueue<R1, never, never, unknown, Take<E1, A>, any>): IO<R & R1 & Has<Scope>, E | E1, void>;
+/**
+ * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
+ * composition.
+ * @tsplus fluent fncts.io.Stream runIntoHubScoped
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function runIntoHubScoped_<R, R1, E extends E1, E1, A>(stream: Stream<R, E, A>, hub: PHub<R1, never, never, unknown, Take<E1, A>, any>): IO<R & R1 & Has<Scope>, E | E1, void>;
+/**
+ * Runs the sink on the stream to produce either the sink's result or an error.
+ * @tsplus fluent fncts.io.Stream runScoped
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function runScoped_<R, E, A, R2, E2, Z>(stream: Stream<R, E, A>, sink: Sink<R2, E2, A, unknown, Z>): IO<R & R2 & Has<Scope>, E | E2, Z>;
+/**
+ * Statefully maps over the elements of this stream to produce all intermediate results
+ * of type `B` given an initial B.
+ * @tsplus fluent fncts.io.Stream scan
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function scan_<R, E, A, B>(sa: Stream<R, E, A>, b: B, f: (b: B, a: A) => B): Stream<R, E, B>;
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce all
+ * intermediate results of type `B` given an initial B.
+ * @tsplus fluent fncts.io.Stream scanIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function scanIO_<R, E, A, R1, E1, B>(sa: Stream<R, E, A>, b: B, f: (b: B, a: A) => IO<R1, E1, B>): Stream<R & R1, E | E1, B>;
+/**
+ * Statefully maps over the elements of this stream to produce all
+ * intermediate results.
+ * @tsplus fluent fncts.io.Stream scanReduce
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function scanReduce_<R, E, A extends B, B>(fa: Stream<R, E, A>, f: (b: B, a: A) => B): Stream<R, E, B>;
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * all intermediate results.
+ * @tsplus fluent fncts.io.Stream scanReduceIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function scanReduceIO_<R, E, A extends B, R1, E1, B>(fa: Stream<R, E, A>, f: (b: B, a: A) => IO<R1, E1, B>): Stream<R & R1, E | E1, B>;
+/**
+ * Creates a single-valued pure stream
+ * @tsplus static fncts.io.StreamOps succeedNow
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function succeedNow<O>(o: O): Stream<unknown, never, O>;
+/**
+ * Creates a single-valued pure stream
+ * @tsplus static fncts.io.StreamOps succeed
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function succeed<A>(a: Lazy<A>): Stream<unknown, never, A>;
+/**
+ * Takes the specified number of elements from this stream.
+ * @tsplus fluent fncts.io.Stream take
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function take_<R, E, A>(stream: Stream<R, E, A>, n: number): Stream<R, E, A>;
+/**
+ * @tsplus fluent fncts.io.Stream takeUntilIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function takeUntilIO_<R, E, A, R1, E1>(ma: Stream<R, E, A>, f: (a: A) => IO<R1, E1, boolean>): Stream<R & R1, E | E1, A>;
+/**
+ * Takes all elements of the stream until the specified predicate evaluates
+ * to `true`.
+ * @tsplus fluent fncts.io.Stream takeUntil
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function takeUntil_<R, E, A>(fa: Stream<R, E, A>, p: Predicate<A>): Stream<R, E, A>;
+/**
+ * @tsplus fluent fncts.io.Stream tap
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function tap_<R, E, A, R1, E1>(ma: Stream<R, E, A>, f: (a: A) => IO<R1, E1, any>): Stream<R & R1, E | E1, A>;
+/**
+ * Throttles 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. Chunks that do not meet the bandwidth constraints are dropped.
+ * The weight of each chunk is determined by the `costFn` function.
+ * @tsplus fluent fncts.io.Stream throttleEnforce
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function throttleEnforce_<R, E, A>(sa: Stream<R, E, A>, costFn: (chunk: Conc<A>) => number, units: number, duration: number, burst?: number): Stream<R, E, A>;
+/**
+ * Throttles 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. Chunks that do not meet the bandwidth constraints are dropped.
+ * The weight of each chunk is determined by the `costFn` effectful function.
+ * @tsplus fluent fncts.io.Stream throttleEnforceIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function throttleEnforceIO_<R, E, A, R1, E1>(sa: Stream<R, E, A>, costFn: (chunk: Conc<A>) => IO<R1, E1, number>, units: number, duration: number, burst?: number): Stream<R & R1, E | E1, A>;
+/**
+ * Converts the stream to a managed hub of chunks. After the managed hub is used,
+ * the hub will never again produce values and should be discarded.
+ * @tsplus fluent fncts.io.Stream toHub
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function toHub_<R, E, A>(stream: Stream<R, E, A>, capacity: number): IO<R & Has<Scope>, never, Hub<Take<E, A>>>;
+/**
+ * Interpret the stream as a managed pull
+ * @tsplus getter fncts.io.Stream toPull
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function toPull<R, E, A>(stream: Stream<R, E, A>): IO<R & Has<Scope>, never, IO<R, Maybe<E>, Conc<A>>>;
+/**
+ * Converts the stream to a managed queue of chunks. After the managed queue is used,
+ * the queue will never again produce values and should be discarded.
+ * @tsplus fluent fncts.io.Stream toQueue
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function toQueue_<R, E, A>(stream: Stream<R, E, A>, capacity?: number): IO<R & Has<Scope>, never, Queue<Take<E, A>>>;
+/**
+ * @tsplus fluent fncts.io.Stream toQueueDropping
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function toQueueDropping_<R, E, A>(stream: Stream<R, E, A>, capacity?: number): IO<R & Has<Scope>, never, Queue.Dequeue<Take<E, A>>>;
+/**
+ * @tsplus fluent fncts.io.Stream toQueueOfElements
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function toQueueOfElements_<R, E, A>(stream: Stream<R, E, A>, capacity?: number): IO<R & Has<Scope>, never, Queue.Dequeue<Exit<Maybe<E>, A>>>;
+/**
+ * @tsplus fluent fncts.io.Stream toQueueSliding
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function toQueueSliding_<R, E, A>(stream: Stream<R, E, A>, capacity?: number): IO<R & Has<Scope>, never, Queue.Dequeue<Take<E, A>>>;
+/**
+ * Converts the stream into an unbounded managed queue. After the managed queue
+ * is used, the queue will never again produce values and should be discarded.
+ * @tsplus getter fncts.io.Stream toQueueUnbounded
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function toQueueUnbounded<R, E, A>(stream: Stream<R, E, A>): IO<R & Has<Scope>, never, Queue<Take<E, A>>>;
+/**
+ * Creates a stream by effectfully peeling off the "layers" of a value of type `S`
+ * @tsplus static fncts.io.StreamOps unfoldChunkIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function unfoldChunkIO<R, E, A, S>(s: S, f: (s: S) => IO<R, E, Maybe<readonly [Conc<A>, S]>>): Stream<R, E, A>;
+/**
+ * Creates a stream by effectfully peeling off the "layers" of a value of type `S`
+ * @tsplus static fncts.io.StreamOps unfoldIO
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function unfoldIO<S, R, E, A>(s: S, f: (s: S) => IO<R, E, Maybe<readonly [A, S]>>): Stream<R, E, A>;
+/**
+ * @tsplus static fncts.io.StreamOps unfoldChunk
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function unfoldChunk<S, A>(s: S, f: (s: S) => Maybe<readonly [Conc<A>, S]>): Stream<unknown, never, A>;
+/**
+ * @tsplus static fncts.io.StreamOps unfold
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function unfold<S, A>(s: S, f: (s: S) => Maybe<readonly [A, S]>): Stream<unknown, never, A>;
+/**
+ * Creates a stream produced from an IO
+ * @tsplus static fncts.io.StreamOps unwrap
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function unwrap<R, E, R1, E1, A>(stream: IO<R, E, Stream<R1, E1, A>>): Stream<R & R1, E | E1, A>;
+/**
+ * Creates a stream produced from a managed
+ * @tsplus static fncts.io.StreamOps unwrapScoped
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function unwrapScoped<R0, E0, R, E, A>(stream: IO<R0 & Has<Scope>, E0, Stream<R, E, A>>): Stream<R0 & R, E0 | E, A>;
+/**
+ * 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.
+ * @tsplus fluent fncts.io.Stream zipWithLatest
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function zipWithLatest_<R, E, A, R1, E1, B, C>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, f: (a: A, b: B) => C): Stream<R & R1, E | E1, C>;