import type { Either } from "../../Either";
import type { Option } from "../../Option";
import type { HasClock } from "../Clock";
import type { Exit } from "../Exit";
import type { Cause } from "../Exit/Cause";
import * as C from "../Exit/Cause";
import * as Sc from "../Schedule";
import type { Task } from "../Task";
import * as T from "../Task";
import { Stream } from "./model";
export declare const unwrap: <R, E, A>(fa: Task<R, E, Stream<R, E, A>>) => Stream<R, E, A>;
/**
 * 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.
 */
export declare const fromSchedule: <R, A>(schedule: Sc.Schedule<R, unknown, A>) => Stream<R & HasClock, never, A>;
/**
 * Creates a stream by effectfully peeling off the "layers" of a value of type `S`
 */
export declare const unfoldChunkM: <Z>(
   z: Z
) => <R, E, A>(f: (z: Z) => Task<R, E, Option<readonly [readonly A[], Z]>>) => Stream<R, E, A>;
/**
 * 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`.
 */
export declare const combineChunks: <R1, E1, B>(
   that: Stream<R1, E1, B>
) => <Z>(
   z: Z
) => <R, E, A, C>(
   f: (
      z: Z,
      s: Task<R, Option<E>, readonly A[]>,
      t: Task<R1, Option<E1>, readonly B[]>
   ) => Task<R & R1, never, Exit<Option<E1 | E>, readonly [readonly C[], Z]>>
) => (self: Stream<R, E, A>) => Stream<R & R1, E1 | E, C>;
/**
 * 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.
 *
 * By default pull is executed in parallel to preserve async semantics, see `zipWithSeq` for
 * a sequential alternative
 */
export declare function mapBothPar_<R, E, O, O2, O3, R1, E1>(
   stream: Stream<R, E, O>,
   that: Stream<R1, E1, O2>,
   f: (a: O, a1: O2) => O3,
   ps: "seq"
): Stream<R & R1, E1 | E, O3>;
export declare function mapBothPar_<R, E, O, O2, O3, R1, E1>(
   stream: Stream<R, E, O>,
   that: Stream<R1, E1, O2>,
   f: (a: O, a1: O2) => O3,
   ps?: "par" | "seq"
): Stream<R & R1, E1 | E, O3>;
export declare function mapBothPar<O, O2, O3, R1, E1>(
   that: Stream<R1, E1, O2>,
   f: (a: O, a1: O2) => O3,
   ps: "seq"
): <R, E>(stream: Stream<R, E, O>) => Stream<R & R1, E1 | E, O3>;
export declare function mapBothPar<O, O2, O3, R1, E1>(
   that: Stream<R1, E1, O2>,
   f: (a: O, a1: O2) => O3,
   ps?: "par" | "seq"
): <R, E>(stream: Stream<R, E, O>) => Stream<R & R1, E1 | E, O3>;
export declare const mapBoth_: <R, E, A, R1, E1, A1, B>(
   stream: Stream<R, E, A>,
   that: Stream<R1, E1, A1>,
   f: (a: A, a1: A1) => B
) => Stream<R & R1, E | E1, B>;
export declare const bothMap: <A, R1, E1, A1, B>(
   that: Stream<R1, E1, A1>,
   f: (a: A, a1: A1) => B
) => <R, E>(stream: Stream<R, E, A>) => Stream<R & R1, E1 | E, B>;
/**
 * 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.
 */
export declare const catchAllCause_: <R, E, A, R1, E2, B>(
   stream: Stream<R, E, A>,
   f: (e: Cause<E>) => Stream<R1, E2, B>
) => Stream<R & R1, E2, A | B>;
export declare const catchAllCause: <E, R1, E1, B>(
   f: (e: Cause<E>) => Stream<R1, E1, B>
) => <R, A>(stream: Stream<R, E, A>) => Stream<R & R1, E1, B | A>;
/**
 * Concatenates all of the streams in the chunk to one stream.
 */
export declare const concatAll: <R, E, A>(streams: Stream<R, E, A>[]) => Stream<R, E, A>;
/**
 * Executes the provided finalizer before this stream's finalizers run.
 */
export declare const ensuringFirst_: <R, E, A, R1>(
   self: Stream<R, E, A>,
   fin: Task<R1, never, unknown>
) => Stream<R & R1, E, A>;
/**
 * Executes the provided finalizer before this stream's finalizers run.
 */
export declare const ensuringFirst: <R1>(
   fin: Task<R1, never, unknown>
) => <R, E, A>(self: Stream<R, E, A>) => Stream<R & R1, E, A>;
export declare type TerminationStrategy = "Left" | "Right" | "Both" | "Either";
/**
 * 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.
 */
export declare const mergeWith_: <R, E, A, R1, E1, B, C, C1>(
   sa: Stream<R, E, A>,
   sb: Stream<R1, E1, B>,
   l: (a: A) => C,
   r: (b: B) => C1,
   strategy?: TerminationStrategy
) => Stream<R1 & R, E | E1, C | C1>;
/**
 * 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.
 */
export declare const mergeWith: <R, E, A, R1, E1, B, C, C1>(
   that: Stream<R1, E1, B>,
   l: (a: A) => C,
   r: (b: B) => C1,
   strategy?: TerminationStrategy
) => (ma: Stream<R, E, A>) => Stream<R1 & R, E | E1, C | C1>;
/**
 * Merges this stream and the specified stream together.
 *
 * New produced stream will terminate when both specified stream terminate if no termination
 * strategy is specified.
 */
export declare const merge_: <R, E, A, R1, E1, B>(
   self: Stream<R, E, A>,
   that: Stream<R1, E1, B>,
   strategy?: TerminationStrategy
) => Stream<R1 & R, E | E1, A | B>;
/**
 * Merges this stream and the specified stream together.
 *
 * New produced stream will terminate when both specified stream terminate if no termination
 * strategy is specified.
 */
export declare const merge: <R1, E1, B>(
   sb: Stream<R1, E1, B>,
   strategy?: TerminationStrategy
) => <R, E, A>(sa: Stream<R, E, A>) => Stream<R1 & R, E1 | E, B | A>;
/**
 * Merges this stream and the specified stream together. New produced stream will
 * terminate when either stream terminates.
 */
export declare const mergeTerminateEither_: <R, E, A, R1, E1, B>(
   sa: Stream<R, E, A>,
   sb: Stream<R1, E1, B>
) => Stream<R1 & R, E | E1, A | B>;
/**
 * Merges this stream and the specified stream together. New produced stream will
 * terminate when either stream terminates.
 */
export declare const mergeTerminateEither: <R1, E1, B>(
   sb: Stream<R1, E1, B>
) => <R, E, A>(sa: Stream<R, E, A>) => Stream<R1 & R, E1 | E, B | A>;
/**
 * Merges this stream and the specified stream together. New produced stream will
 * terminate when this stream terminates.
 */
export declare const mergeTerminateLeft_: <R, E, A, R1, E1, B>(
   sa: Stream<R, E, A>,
   sb: Stream<R1, E1, B>
) => Stream<R1 & R, E | E1, A | B>;
/**
 * Merges this stream and the specified stream together. New produced stream will
 * terminate when this stream terminates.
 */
export declare const mergeTerminateLeft: <R1, E1, B>(
   sb: Stream<R1, E1, B>
) => <R, E, A>(sa: Stream<R, E, A>) => Stream<R1 & R, E1 | E, B | A>;
/**
 * Merges this stream and the specified stream together. New produced stream will
 * terminate when the specified stream terminates.
 */
export declare const mergeTerminateRight_: <R, E, A, R1, E1, B>(
   sa: Stream<R, E, A>,
   sb: Stream<R1, E1, B>
) => Stream<R1 & R, E | E1, A | B>;
/**
 * Merges this stream and the specified stream together. New produced stream will
 * terminate when the specified stream terminates.
 */
export declare const mergeTerminateRight: <R1, E1, B>(
   sb: Stream<R1, E1, B>
) => <R, E, A>(sa: Stream<R, E, A>) => Stream<R1 & R, E1 | E, B | A>;
/**
 * Merges this stream and the specified stream together to produce a stream of
 * eithers.
 */
export declare const mergeEither_: <R, E, A, R1, E1, B>(
   sa: Stream<R, E, A>,
   sb: Stream<R1, E1, B>,
   strategy?: TerminationStrategy
) => Stream<R & R1, E | E1, Either<A, B>>;
/**
 * Merges this stream and the specified stream together to produce a stream of
 * eithers.
 */
export declare const mergeEither: <R1, E1, B>(
   sb: Stream<R1, E1, B>,
   strategy?: TerminationStrategy
) => <R, E, A>(sa: Stream<R, E, A>) => Stream<R & R1, E1 | E, Either<A, B>>;
//# sourceMappingURL=combinators.d.ts.map