import type { Either } from "../../Either";
import type { Option } from "../../Option";
import type { Exit } from "../Exit";
import * as M from "../Managed";
import * as T from "../Task";
import type { XQueue } from "../XQueue";
import type { Transducer } from "./internal/Transducer";
import type { EIO, IO, RIO } from "./model";
import { Stream } from "./model";
/**
 * Creates a stream from an array of values
 */
export declare const fromArray: <A>(c: readonly A[]) => IO<A>;
/**
 * Creates a stream from a task producing a value of type `A` or an empty Stream
 */
export declare const fromTaskOption: <R, E, A>(fa: T.Task<R, Option<E>, A>) => Stream<R, E, A>;
/**
 * Creates a stream from a task producing a value of type `A`
 */
export declare const fromTask: <R, E, A>(ef: T.Task<R, E, A>) => 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`.
 */
export declare const asyncOption: <R, E, A>(
   register: (
      resolve: (
         next: T.Task<R, Option<E>, readonly A[]>,
         offerCb?: ((e: Exit<never, boolean>) => void) | undefined
      ) => T.IO<Exit<never, boolean>>
   ) => 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 optionality of the error type `E` can be used to signal the end of the stream,
 * by setting it to `None`.
 */
export declare const async: <R, E, A>(
   register: (
      resolve: (
         next: T.Task<R, Option<E>, readonly A[]>,
         offerCb?: ((e: Exit<never, boolean>) => void) | undefined
      ) => T.IO<Exit<never, boolean>>
   ) => void,
   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`.
 */
export declare const asyncInterruptEither: <R, E, A>(
   register: (
      resolve: (
         next: T.Task<R, Option<E>, readonly A[]>,
         offerCb?: ((e: Exit<never, boolean>) => void) | undefined
      ) => T.IO<Exit<never, boolean>>
   ) => Either<T.RIO<R, void>, 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 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`.
 */
export declare const asyncInterrupt: <R, E, A>(
   register: (
      cb: (
         next: T.Task<R, Option<E>, readonly A[]>,
         offerCb?: ((e: Exit<never, boolean>) => void) | undefined
      ) => T.IO<Exit<never, boolean>>
   ) => T.RIO<R, void>,
   outputBuffer?: number
) => Stream<R, E, A>;
export declare const fail: <E>(e: E) => EIO<E, never>;
/**
 * Creates a stream from a task producing chunks of `A` values until it fails with None.
 */
export declare const repeatTaskChunkOption: <R, E, A>(ef: T.Task<R, Option<E>, readonly A[]>) => Stream<R, E, A>;
/**
 * Creates a stream from a task producing values of type `A` until it fails with None.
 */
export declare const repeatTaskOption: <R, E, A>(fa: T.Task<R, Option<E>, A>) => Stream<R, E, A>;
/**
 * Creates a stream from an `XQueue` of values
 */
export declare const fromArrayXQueue: <R, E, O>(queue: XQueue<never, R, unknown, E, never, O[]>) => Stream<R, E, O>;
/**
 * Creates a stream from an `XQueue` of values. The queue will be shutdown once the stream is closed.
 */
export declare const fromArrayXQueueWithShutdown: <R, E, A>(
   queue: XQueue<never, R, unknown, E, never, A[]>
) => Stream<R, E, A>;
/**
 * Creates a stream from an `XQueue` of values
 */
export declare const fromXQueue: <R, E, A>(queue: XQueue<never, R, unknown, E, never, A>) => Stream<R, E, A>;
/**
 * Creates a stream from an `XQueue` of values. The queue will be shutdown once the stream is closed.
 */
export declare const fromXQueueWithShutdown: <R, E, A>(
   queue: XQueue<never, R, unknown, E, never, A>
) => Stream<R, E, A>;
/**
 * The `Stream` that dies with the error.
 */
export declare const die: (e: unknown) => IO<never>;
/**
 * The stream that dies with an exception described by `message`.
 */
export declare const dieMessage: (message: string) => Stream<unknown, never, never>;
/**
 * The empty stream
 */
export declare const empty: IO<never>;
/**
 * The infinite stream of iterative function application: a, f(a), f(f(a)), f(f(f(a))), ...
 */
export declare const iterate: <A>(a: A, f: (a: A) => A) => IO<A>;
export declare const suspend: <R, E, A>(thunk: () => Stream<R, E, A>) => Stream<R, E, A>;
/**
 * Creates a single-valued stream from a managed resource
 */
export declare const managed: <R, E, A>(ma: M.Managed<R, E, A>) => Stream<R, E, A>;
/**
 * Creates a one-element stream that never fails and executes the finalizer when it ends.
 */
export declare const finalizer: <R>(finalizer: T.RIO<R, unknown>) => RIO<R, unknown>;
/**
 * Applies an aggregator to the stream, which converts one or more elements
 * of type `A` into elements of type `B`.
 */
export declare const aggregate_: <R, E, A, R1, E1, B>(
   stream: Stream<R, E, A>,
   transducer: Transducer<R1, E1, A, B>
) => Stream<R & R1, E | E1, B>;
/**
 * Applies an aggregator to the stream, which converts one or more elements
 * of type `A` into elements of type `B`.
 */
export declare const aggregate: <A, R1, E1, B>(
   transducer: Transducer<R1, E1, A, B>
) => <R, E>(stream: Stream<R, E, A>) => Stream<R & R1, E1 | E, B>;
/**
 * Creates a new `Stream` from a managed effect that yields chunks.
 * The effect will be evaluated repeatedly until it fails with a `None`
 * (to signify stream end) or a `Some<E>` (to signify stream failure).
 *
 * The stream evaluation guarantees proper acquisition and release of the
 * `Managed`.
 */
export declare const apply: <R, E, A>(proc: M.Managed<R, never, T.Task<R, Option<E>, readonly A[]>>) => Stream<R, E, A>;
/**
 * Creates a stream from a single value that will get cleaned up after the
 * stream is consumed
 */
export declare const bracket_: <R, E, A, R1>(
   acquire: T.Task<R, E, A>,
   release: (a: A) => T.Task<R1, never, any>
) => Stream<R & R1, E, A>;
/**
 * Creates a stream from a single value that will get cleaned up after the
 * stream is consumed
 */
export declare const bracket: <A, R1>(
   release: (a: A) => T.Task<R1, never, any>
) => <R, E>(acquire: T.Task<R, E, A>) => Stream<R & R1, E, A>;
/**
 * Creates a stream from a single value that will get cleaned up after the
 * stream is consumed
 */
export declare const bracketExit_: <R, E, A, R1>(
   acquire: T.Task<R, E, A>,
   release: (a: A, exit: Exit<unknown, unknown>) => T.Task<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
 */
export declare const bracketExit: <A, R1>(
   release: (a: A, exit: Exit<unknown, unknown>) => T.Task<R1, never, unknown>
) => <R, E>(acquire: T.Task<R, E, A>) => Stream<R & R1, E, A>;
//# sourceMappingURL=constructors.d.ts.map