import type { Either } from "../../../Either";
import * as M from "../../Managed/_core";
import * as T from "../../Task";
import * as Push from "./Push";
export declare class Sink<R, E, I, L, Z> {
   readonly push: M.Managed<R, never, Push.Push<R, E, I, L, Z>>;
   constructor(push: M.Managed<R, never, Push.Push<R, E, I, L, Z>>);
}
/**
 * Creates a sink from a Push
 */
export declare const fromPush: <R, E, I, L, Z>(push: Push.Push<R, E, I, L, Z>) => Sink<R, E, I, L, Z>;
/**
 * A sink that immediately ends with the specified value.
 */
export declare const succeed: <Z, I>(z: Z) => Sink<unknown, never, I, I, Z>;
/**
 * A sink that effectfully folds its input chunks with the provided function, termination predicate and initial state.
 * `contFn` condition is checked only for the initial value and at the end of processing of each chunk.
 * `f` and `contFn` must preserve chunking-invariance.
 */
export declare const foldArraysM: <Z>(
   z: Z
) => (contFn: (s: Z) => boolean) => <I, R, E>(f: (s: Z, i: readonly I[]) => T.Task<R, E, Z>) => Sink<R, E, I, I, Z>;
/**
 * A sink that folds its input chunks with the provided function, termination predicate and initial state.
 * `contFn` condition is checked only for the initial value and at the end of processing of each chunk.
 * `f` and `contFn` must preserve chunking-invariance.
 */
export declare const foldArrays: <Z>(
   z: Z
) => (contFn: (s: Z) => boolean) => <I>(f: (s: Z, i: readonly I[]) => Z) => Sink<unknown, never, I, I, Z>;
/**
 * A sink that folds its input chunks with the provided function and initial state.
 * `f` must preserve chunking-invariance.
 */
export declare const foldLeftArrays: <Z>(z: Z) => <I>(f: (s: Z, i: readonly I[]) => Z) => Sink<unknown, never, I, I, Z>;
/**
 * A sink that collects all of its inputs into an array.
 */
export declare const collectAll: <A>() => Sink<unknown, never, A, A, readonly A[]>;
/**
 * Runs both sinks in parallel on the input, returning the result or the error from the
 * one that finishes first.
 */
export declare const raceBoth: <R1, E1, I1 extends I, L1, Z1, I>(
   that: Sink<R1, E1, I1, L1, Z1>
) => <R, E, L, Z>(self: Sink<R, E, I, L, Z>) => Sink<R1 & R, E1 | E, I1, L1 | L, Either<Z, Z1>>;
/**
 * A sink that executes the provided effectful function for every element fed to it.
 */
export declare const foreach: <I, R1, E1>(f: (i: I) => T.Task<R1, E1, any>) => Sink<R1, E1, I, I, void>;
//# sourceMappingURL=Sink.d.ts.map