import * as E from "../../Either";
import type { Option } from "../../Option";
import type { Exit } from "../Exit";
import type { Cause } from "../Exit/Cause";
import * as T from "../Task";
import type { IO, RIO } from "./model";
import { Stream } from "./model";
/**
 * Creates a single-valued pure stream
 */
export declare const pure: <A>(a: A) => IO<A>;
/**
 * Taskfully transforms the chunks emitted by this stream.
 */
export declare const mapChunksM_: <R, E, A, R1, E1, B>(
   fa: Stream<R, E, A>,
   f: (chunks: readonly A[]) => T.Task<R1, E1, readonly B[]>
) => Stream<R & R1, E | E1, B>;
/**
 * Taskfully transforms the chunks emitted by this stream.
 */
export declare const mapChunksM: <A, R1, E1, A1>(
   f: (chunks: readonly A[]) => T.Task<R1, E1, readonly A1[]>
) => <R, E>(fa: Stream<R, E, A>) => Stream<R & R1, E1 | E, A1>;
/**
 * Transforms the chunks emitted by this stream.
 */
export declare const mapChunks_: <R, E, A, B>(
   fa: Stream<R, E, A>,
   f: (chunks: readonly A[]) => readonly B[]
) => Stream<R, E, B>;
/**
 * Transforms the chunks emitted by this stream.
 */
export declare const mapChunks: <A, B>(
   f: (chunks: readonly A[]) => readonly B[]
) => <R, E>(fa: Stream<R, E, A>) => Stream<R, E, B>;
/**
 * Transforms the chunks emitted by this stream.
 */
export declare const map_: <R, E, A, B>(fa: Stream<R, E, A>, f: (a: A) => B) => Stream<R, E, B>;
/**
 * Transforms the chunks emitted by this stream.
 */
export declare const map: <A, B>(f: (a: A) => B) => <R, E>(fa: Stream<R, E, A>) => Stream<R, E, B>;
/**
 * Maps over elements of the stream with the specified effectful function.
 */
export declare const mapM_: <R, E, A, R1, E1, B>(
   fa: Stream<R, E, A>,
   f: (a: A) => T.Task<R1, E1, B>
) => Stream<R & R1, E | E1, B>;
/**
 * Maps over elements of the stream with the specified effectful function.
 */
export declare const mapM: <A, R1, E1, A1>(
   f: (o: A) => T.Task<R1, E1, A1>
) => <R, E>(fa: Stream<R, E, A>) => Stream<R & R1, E1 | E, A1>;
export declare const first_: <R, E, A, D>(pab: Stream<R, E, A>, f: (e: E) => D) => Stream<R, D, A>;
export declare const first: <E, D>(f: (e: E) => D) => <R, A>(pab: Stream<R, E, A>) => Stream<R, D, A>;
export declare const mapError: <E, D>(f: (e: E) => D) => <R, A>(pab: Stream<R, E, A>) => Stream<R, D, A>;
export declare const mapErrorCause_: <R, E, A, E1>(
   stream: Stream<R, E, A>,
   f: (e: Cause<E>) => Cause<E1>
) => Stream<R, E1, A>;
export declare const mapErrorCause: <E, D>(
   f: (e: Cause<E>) => Cause<D>
) => <R, A>(stream: Stream<R, E, A>) => Stream<R, D, 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`
 */
export declare const chain_: <R, E, A, Q, D, B>(
   fa: Stream<R, E, A>,
   f: (a: A) => Stream<Q, D, B>
) => Stream<R & Q, E | D, B>;
/**
 * Returns a stream made of the concatenation in strict order of all the streams
 * produced by passing each element of this stream to `f0`
 */
export declare const chain: <A, Q, D, B>(
   f: (a: A) => Stream<Q, D, B>
) => <R, E>(fa: Stream<R, E, A>) => Stream<Q & R, D | E, B>;
/**
 * Flattens this stream-of-streams into a stream made of the concatenation in
 * strict order of all the streams.
 */
export declare const flatten: <R, E, Q, D, A>(ffa: Stream<R, E, Stream<Q, D, A>>) => Stream<Q & R, E | D, A>;
export declare const absolve: <R, E, A, E1>(stream: Stream<R, E, E.Either<E1, A>>) => Stream<R, E | E1, A>;
export declare const ask: <R>() => RIO<R, R>;
export declare const asks: <R, A>(f: (_: R) => A) => Stream<R, never, A>;
export declare const asksTask: <R0, R, E, A>(f: (_: R0) => T.Task<R, E, A>) => Stream<R & R0, E, A>;
export declare const asksM: <R0, R, E, A>(f: (_: R0) => Stream<R, E, A>) => Stream<R0 & R, E, A>;
/**
 * Statefully and effectfully maps over the elements of this stream to produce
 * new elements.
 */
export declare const mapAccumM_: <R, E, A, R1, E1, B, Z>(
   stream: Stream<R, E, A>,
   z: Z,
   f: (z: Z, a: A) => T.Task<R1, E1, [Z, B]>
) => Stream<R & R1, E | E1, B>;
export declare const mapAccumM: <Z>(
   z: Z
) => <A, R1, E1, B>(
   f: (z: Z, a: A) => T.Task<R1, E1, [Z, B]>
) => <R, E>(stream: Stream<R, E, A>) => Stream<R & R1, E1 | E, B>;
export declare const mapAccum_: <R, E, A, B, Z>(
   stream: Stream<R, E, A>,
   z: Z,
   f: (z: Z, a: A) => [Z, B]
) => Stream<R, E, B>;
export declare const mapAccum: <Z>(
   z: Z
) => <A, B>(f: (z: Z, a: A) => [Z, B]) => <R, E>(stream: Stream<R, E, A>) => Stream<R, E, B>;
export declare const mapConcat_: <R, E, A, B>(stream: Stream<R, E, A>, f: (a: A) => Iterable<B>) => Stream<R, E, B>;
export declare const mapConcat: <A, B>(f: (a: A) => Iterable<B>) => <R, E>(stream: Stream<R, E, A>) => Stream<R, E, B>;
export declare const mapConcatChunk_: <R, E, A, B>(
   stream: Stream<R, E, A>,
   f: (a: A) => readonly B[]
) => Stream<R, E, B>;
export declare const mapConcatChunk: <A, B>(
   f: (a: A) => readonly B[]
) => <R, E>(stream: Stream<R, E, A>) => Stream<R, E, B>;
export declare const mapConcatChunkM_: <R, E, A, R1, E1, B>(
   stream: Stream<R, E, A>,
   f: (a: A) => T.Task<R1, E1, readonly B[]>
) => Stream<R & R1, E | E1, B>;
export declare const mapConcatChunkM: <A, R1, E1, B>(
   f: (a: A) => T.Task<R1, E1, readonly B[]>
) => <R, E>(stream: Stream<R, E, A>) => Stream<R & R1, E1 | E, B>;
export declare const mapConcatM_: <R, E, A, R1, E1, B>(
   stream: Stream<R, E, A>,
   f: (a: A) => T.Task<R1, E1, Iterable<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.
 */
export declare const mapMPar_: (
   n: number
) => <R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => T.Task<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.
 */
export declare const mapMPar: (
   n: number
) => <A, R1, E1, B>(f: (a: A) => T.Task<R1, E1, B>) => <R, E>(stream: Stream<R, E, A>) => Stream<R & R1, E1 | E, B>;
/**
 * Creates a stream from an asynchronous callback that can be called multiple times
 * The registration of the callback itself returns a task. The optionality of the
 * error type `E` can be used to signal the end of the stream, by setting it to `None`.
 */
export declare const asyncTask: <R, E, A, R1 = R, E1 = E>(
   register: (
      cb: (
         next: T.Task<R, Option<E>, readonly A[]>,
         offerCb?: ((e: Exit<never, boolean>) => void) | undefined
      ) => T.IO<Exit<never, boolean>>
   ) => T.Task<R1, E1, unknown>,
   outputBuffer?: number
) => Stream<R & R1, E | E1, A>;
//# sourceMappingURL=methods.d.ts.map