/**
 * @since 1.0.0
 */
import type * as Chunk from "@effect/data/Chunk";
import type * as Context from "@effect/data/Context";
import type * as Duration from "@effect/data/Duration";
import type * as Either from "@effect/data/Either";
import type { LazyArg } from "@effect/data/Function";
import type * as HashMap from "@effect/data/HashMap";
import type * as HashSet from "@effect/data/HashSet";
import type * as Option from "@effect/data/Option";
import type { Pipeable } from "@effect/data/Pipeable";
import type { Predicate, Refinement } from "@effect/data/Predicate";
import type * as Unify from "@effect/data/Unify";
import type * as Cause from "@effect/io/Cause";
import type * as Effect from "@effect/io/Effect";
import type * as Exit from "@effect/io/Exit";
import type * as Hub from "@effect/io/Hub";
import type * as Queue from "@effect/io/Queue";
import type * as Scope from "@effect/io/Scope";
import type * as Channel from "@effect/stream/Channel";
import type * as MergeDecision from "@effect/stream/Channel/MergeDecision";
/**
 * @since 1.0.0
 * @category symbols
 */
export declare const SinkTypeId: unique symbol;
/**
 * @since 1.0.0
 * @category symbols
 */
export type SinkTypeId = typeof SinkTypeId;
/**
 * A `Sink<R, E, In, L, Z>` is used to consume elements produced by a `Stream`.
 * You can think of a sink as a function that will consume a variable amount of
 * `In` elements (could be 0, 1, or many), might fail with an error of type `E`,
 * and will eventually yield a value of type `Z` together with a remainder of
 * type `L` (i.e. any leftovers).
 *
 * @since 1.0.0
 * @category models
 */
export interface Sink<R, E, In, L, Z> extends Sink.Variance<R, E, In, L, Z>, Pipeable {
}
/**
 * @since 1.0.0
 * @category models
 */
export interface SinkUnify<A extends {
    [Unify.typeSymbol]?: any;
}> extends Effect.EffectUnify<A> {
    Sink?: () => A[Unify.typeSymbol] extends Sink<infer R, infer E, infer In, infer L, infer Z> | infer _ ? Sink<R, E, In, L, Z> : never;
}
/**
 * @category models
 * @since 1.0.0
 */
export interface SinkUnifyBlacklist extends Effect.EffectUnifyBlacklist {
    Sink?: true;
}
/**
 * @since 1.0.0
 * @category models
 */
declare module "@effect/io/Effect" {
    interface Effect<R, E, A> extends Sink<R, E, unknown, never, A> {
    }
    interface EffectUnifyBlacklist {
        Sink?: true;
    }
}
/**
 * @since 1.0.0
 */
export declare namespace Sink {
    /**
     * @since 1.0.0
     * @category models
     */
    interface Variance<R, E, In, L, Z> {
        readonly [SinkTypeId]: {
            _R: (_: never) => R;
            _E: (_: never) => E;
            _In: (_: In) => void;
            _L: (_: never) => L;
            _Z: (_: never) => Z;
        };
    }
}
/**
 * Replaces this sink's result with the provided value.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const as: {
    <Z2>(z: Z2): <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, L, Z2>;
    <R, E, In, L, Z, Z2>(self: Sink<R, E, In, L, Z>, z: Z2): Sink<R, E, In, L, Z2>;
};
/**
 * A sink that collects all elements into a `Chunk`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const collectAll: <In>() => Sink<never, never, In, never, Chunk.Chunk<In>>;
/**
 * A sink that collects first `n` elements into a chunk.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const collectAllN: <In>(n: number) => Sink<never, never, In, In, Chunk.Chunk<In>>;
/**
 * Repeatedly runs the sink and accumulates its results into a `Chunk`.
 *
 * @since 1.0.0
 * @category utils
 */
export declare const collectAllFrom: <R, E, In, L extends In, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, L, Chunk.Chunk<Z>>;
/**
 * A sink that collects all of its inputs into a map. The keys are extracted
 * from inputs using the keying function `key`; if multiple inputs use the
 * same key, they are merged using the `merge` function.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const collectAllToMap: <In, K>(key: (input: In) => K, merge: (x: In, y: In) => In) => Sink<never, never, In, never, HashMap.HashMap<K, In>>;
/**
 * A sink that collects first `n` keys into a map. The keys are calculated
 * from inputs using the keying function `key`; if multiple inputs use the the
 * same key, they are merged using the `merge` function.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const collectAllToMapN: <In, K>(n: number, key: (input: In) => K, merge: (x: In, y: In) => In) => Sink<never, never, In, In, HashMap.HashMap<K, In>>;
/**
 * A sink that collects all of its inputs into a set.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const collectAllToSet: <In>() => Sink<never, never, In, never, HashSet.HashSet<In>>;
/**
 * A sink that collects first `n` distinct inputs into a set.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const collectAllToSetN: <In>(n: number) => Sink<never, never, In, In, HashSet.HashSet<In>>;
/**
 * Accumulates incoming elements into a chunk until predicate `p` is
 * satisfied.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const collectAllUntil: <In>(p: Predicate<In>) => Sink<never, never, In, In, Chunk.Chunk<In>>;
/**
 * Accumulates incoming elements into a chunk until effectful predicate `p` is
 * satisfied.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const collectAllUntilEffect: <In, R, E>(p: (input: In) => Effect.Effect<R, E, boolean>) => Sink<R, E, In, In, Chunk.Chunk<In>>;
/**
 * Accumulates incoming elements into a chunk as long as they verify predicate
 * `p`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const collectAllWhile: <In>(predicate: Predicate<In>) => Sink<never, never, In, In, Chunk.Chunk<In>>;
/**
 * Accumulates incoming elements into a chunk as long as they verify effectful
 * predicate `p`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const collectAllWhileEffect: <In, R, E>(predicate: (input: In) => Effect.Effect<R, E, boolean>) => Sink<R, E, In, In, Chunk.Chunk<In>>;
/**
 * Repeatedly runs the sink for as long as its results satisfy the predicate
 * `p`. The sink's results will be accumulated using the stepping function `f`.
 *
 * @since 1.0.0
 * @category utils
 */
export declare const collectAllWhileWith: {
    <Z, S>(options: {
        readonly initial: S;
        readonly while: Predicate<Z>;
        readonly body: (s: S, z: Z) => S;
    }): <R, E, In, L extends In>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, L, S>;
    <R, E, In, L extends In, Z, S>(self: Sink<R, E, In, L, Z>, options: {
        readonly initial: S;
        readonly while: Predicate<Z>;
        readonly body: (s: S, z: Z) => S;
    }): Sink<R, E, In, L, S>;
};
/**
 * Collects the leftovers from the stream when the sink succeeds and returns
 * them as part of the sink's result.
 *
 * @since 1.0.0
 * @category utils
 */
export declare const collectLeftover: <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, never, readonly [Z, Chunk.Chunk<L>]>;
/**
 * Transforms this sink's input elements.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapInput: (<In0, In>(f: (input: In0) => In) => <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In0, L, Z>) & (<R_1, E_1, L_1, Z_1, In0_1, In_1>(self: Sink<R_1, E_1, In_1, L_1, Z_1>, f: (input: In0_1) => In_1) => Sink<R_1, E_1, In0_1, L_1, Z_1>);
/**
 * Effectfully transforms this sink's input elements.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapInputEffect: (<In0, R2, E2, In>(f: (input: In0) => Effect.Effect<R2, E2, In>) => <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In0, L, Z>) & (<R_1, E_1, L_1, Z_1, In0_1, R2_1, E2_1, In_1>(self: Sink<R_1, E_1, In_1, L_1, Z_1>, f: (input: In0_1) => Effect.Effect<R2_1, E2_1, In_1>) => Sink<R_1 | R2_1, E_1 | E2_1, In0_1, L_1, Z_1>);
/**
 * Transforms this sink's input chunks. `f` must preserve chunking-invariance.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapInputChunks: {
    <In0, In>(f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>): <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In0, L, Z>;
    <R, E, L, Z, In0, In>(self: Sink<R, E, In, L, Z>, f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>): Sink<R, E, In0, L, Z>;
};
/**
 * Effectfully transforms this sink's input chunks. `f` must preserve
 * chunking-invariance.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapInputChunksEffect: {
    <In0, R2, E2, In>(f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>): <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In0, L, Z>;
    <R, E, L, Z, In0, R2, E2, In>(self: Sink<R, E, In, L, Z>, f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>): Sink<R | R2, E | E2, In0, L, Z>;
};
/**
 * A sink that counts the number of elements fed to it.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const count: Sink<never, never, unknown, never, number>;
/**
 * Creates a sink halting with the specified defect.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const die: (defect: unknown) => Sink<never, never, unknown, never, never>;
/**
 * Creates a sink halting with the specified message, wrapped in a
 * `RuntimeException`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const dieMessage: (message: string) => Sink<never, never, unknown, never, never>;
/**
 * Creates a sink halting with the specified defect.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const dieSync: (evaluate: LazyArg<unknown>) => Sink<never, never, unknown, never, never>;
/**
 * Transforms both inputs and result of this sink using the provided
 * functions.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const dimap: {
    <In0, In, Z, Z2>(options: {
        readonly onInput: (input: In0) => In;
        readonly onDone: (z: Z) => Z2;
    }): <R, E, L>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In0, L, Z2>;
    <R, E, L, In0, In, Z, Z2>(self: Sink<R, E, In, L, Z>, options: {
        readonly onInput: (input: In0) => In;
        readonly onDone: (z: Z) => Z2;
    }): Sink<R, E, In0, L, Z2>;
};
/**
 * Effectfully transforms both inputs and result of this sink using the
 * provided functions.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const dimapEffect: {
    <In0, R2, E2, In, Z, R3, E3, Z2>(options: {
        readonly onInput: (input: In0) => Effect.Effect<R2, E2, In>;
        readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>;
    }): <R, E, L>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R3 | R, E2 | E3 | E, In0, L, Z2>;
    <R, E, L, In0, R2, E2, In, Z, R3, E3, Z2>(self: Sink<R, E, In, L, Z>, options: {
        readonly onInput: (input: In0) => Effect.Effect<R2, E2, In>;
        readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>;
    }): Sink<R | R2 | R3, E | E2 | E3, In0, L, Z2>;
};
/**
 * Transforms both input chunks and result of this sink using the provided
 * functions.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const dimapChunks: {
    <In0, In, Z, Z2>(options: {
        readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>;
        readonly onDone: (z: Z) => Z2;
    }): <R, E, L>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In0, L, Z2>;
    <R, E, L, In0, In, Z, Z2>(self: Sink<R, E, In, L, Z>, options: {
        readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>;
        readonly onDone: (z: Z) => Z2;
    }): Sink<R, E, In0, L, Z2>;
};
/**
 * Effectfully transforms both input chunks and result of this sink using the
 * provided functions. `f` and `g` must preserve chunking-invariance.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const dimapChunksEffect: {
    <In0, R2, E2, In, Z, R3, E3, Z2>(options: {
        readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>;
        readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>;
    }): <R, E, L>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R3 | R, E2 | E3 | E, In0, L, Z2>;
    <R, E, L, In0, R2, E2, In, Z, R3, E3, Z2>(self: Sink<R, E, In, L, Z>, options: {
        readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<R2, E2, Chunk.Chunk<In>>;
        readonly onDone: (z: Z) => Effect.Effect<R3, E3, Z2>;
    }): Sink<R | R2 | R3, E | E2 | E3, In0, L, Z2>;
};
/**
 * A sink that ignores its inputs.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const drain: Sink<never, never, unknown, never, void>;
/**
 * Creates a sink that drops `n` elements.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const drop: <In>(n: number) => Sink<never, never, In, In, unknown>;
/**
 * Drops incoming elements until the predicate is satisfied.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const dropUntil: <In>(predicate: Predicate<In>) => Sink<never, never, In, In, unknown>;
/**
 * Drops incoming elements until the effectful predicate is satisfied.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const dropUntilEffect: <In, R, E>(predicate: (input: In) => Effect.Effect<R, E, boolean>) => Sink<R, E, In, In, unknown>;
/**
 * Drops incoming elements as long as the predicate is satisfied.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const dropWhile: <In>(predicate: Predicate<In>) => Sink<never, never, In, In, unknown>;
/**
 * Drops incoming elements as long as the effectful predicate is satisfied.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const dropWhileEffect: <In, R, E>(predicate: (input: In) => Effect.Effect<R, E, boolean>) => Sink<R, E, In, In, unknown>;
/**
 * Returns a new sink with an attached finalizer. The finalizer is guaranteed
 * to be executed so long as the sink begins execution (and regardless of
 * whether or not it completes).
 *
 * @since 1.0.0
 * @category finalization
 */
export declare const ensuring: {
    <R2, _>(finalizer: Effect.Effect<R2, never, _>): <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E, In, L, Z>;
    <R, E, In, L, Z, R2, _>(self: Sink<R, E, In, L, Z>, finalizer: Effect.Effect<R2, never, _>): Sink<R | R2, E, In, L, Z>;
};
/**
 * Returns a new sink with an attached finalizer. The finalizer is guaranteed
 * to be executed so long as the sink begins execution (and regardless of
 * whether or not it completes).
 *
 * @since 1.0.0
 * @category finalization
 */
export declare const ensuringWith: {
    <E, Z, R2, _>(finalizer: (exit: Exit.Exit<E, Z>) => Effect.Effect<R2, never, _>): <R, In, L>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E, In, L, Z>;
    <R, In, L, E, Z, R2, _>(self: Sink<R, E, In, L, Z>, finalizer: (exit: Exit.Exit<E, Z>) => Effect.Effect<R2, never, _>): Sink<R | R2, E, In, L, Z>;
};
/**
 * Accesses the whole context of the sink.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const context: <R>() => Sink<R, never, unknown, never, Context.Context<R>>;
/**
 * Accesses the context of the sink.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const contextWith: <R, Z>(f: (context: Context.Context<R>) => Z) => Sink<R, never, unknown, never, Z>;
/**
 * Accesses the context of the sink in the context of an effect.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const contextWithEffect: <R, R2, E, Z>(f: (context: Context.Context<R>) => Effect.Effect<R2, E, Z>) => Sink<R | R2, E, unknown, never, Z>;
/**
 * Accesses the context of the sink in the context of a sink.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const contextWithSink: <R0, R, E, In, L, Z>(f: (context: Context.Context<R0>) => Sink<R, E, In, L, Z>) => Sink<R0 | R, E, In, L, Z>;
/**
 * A sink that returns whether all elements satisfy the specified predicate.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const every: <In>(predicate: Predicate<In>) => Sink<never, never, In, In, boolean>;
/**
 * A sink that always fails with the specified error.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fail: <E>(e: E) => Sink<never, E, unknown, never, never>;
/**
 * A sink that always fails with the specified lazily evaluated error.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const failSync: <E>(evaluate: LazyArg<E>) => Sink<never, E, unknown, never, never>;
/**
 * Creates a sink halting with a specified `Cause`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const failCause: <E>(cause: Cause.Cause<E>) => Sink<never, E, unknown, never, never>;
/**
 * Creates a sink halting with a specified lazily evaluated `Cause`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Sink<never, E, unknown, never, never>;
/**
 * Filters the sink's input with the given predicate.
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const filterInput: {
    <In, In1 extends In, In2 extends In1>(f: Refinement<In1, In2>): <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In2, L, Z>;
    <In, In1 extends In>(f: Predicate<In1>): <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In1, L, Z>;
};
/**
 * Effectfully filter the input of this sink using the specified predicate.
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const filterInputEffect: {
    <R2, E2, In, In1 extends In>(f: (input: In1) => Effect.Effect<R2, E2, boolean>): <R, E, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In1, L, Z>;
    <R, E, L, Z, R2, E2, In, In1 extends In>(self: Sink<R, E, In, L, Z>, f: (input: In1) => Effect.Effect<R2, E2, boolean>): Sink<R | R2, E | E2, In1, L, Z>;
};
/**
 * Creates a sink that produces values until one verifies the predicate `f`.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const findEffect: {
    <Z, R2, E2>(f: (z: Z) => Effect.Effect<R2, E2, boolean>): <R, E, In, L extends In>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In, L, Option.Option<Z>>;
    <R, E, In, L extends In, Z, R2, E2>(self: Sink<R, E, In, L, Z>, f: (z: Z) => Effect.Effect<R2, E2, boolean>): Sink<R | R2, E | E2, In, L, Option.Option<Z>>;
};
/**
 * A sink that folds its inputs with the provided function, termination
 * predicate and initial state.
 *
 * @since 1.0.0
 * @category folding
 */
export declare const fold: <S, In>(s: S, contFn: Predicate<S>, f: (z: S, input: In) => S) => Sink<never, never, In, In, S>;
/**
 * Folds over the result of the sink
 *
 * @since 1.0.0
 * @category folding
 */
export declare const foldSink: {
    <R1, R2, E, E1, E2, In, In1 extends In, In2 extends In, L, L1, L2, Z, Z1, Z2>(options: {
        readonly onFailure: (err: E) => Sink<R1, E1, In1, L1, Z1>;
        readonly onSuccess: (z: Z) => Sink<R2, E2, In2, L2, Z2>;
    }): <R>(self: Sink<R, E, In, L, Z>) => Sink<R1 | R2 | R, E1 | E2, In1 & In2, L1 | L2, Z1 | Z2>;
    <R, R1, R2, E, E1, E2, In, In1 extends In, In2 extends In, L, L1, L2, Z, Z1, Z2>(self: Sink<R, E, In, L, Z>, options: {
        readonly onFailure: (err: E) => Sink<R1, E1, In1, L1, Z1>;
        readonly onSuccess: (z: Z) => Sink<R2, E2, In2, L2, Z2>;
    }): Sink<R | R1 | R2, E1 | E2, In1 & In2, L1 | L2, Z1 | Z2>;
};
/**
 * 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.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldChunks: <S, In>(s: S, contFn: Predicate<S>, f: (s: S, chunk: Chunk.Chunk<In>) => S) => Sink<never, never, In, never, S>;
/**
 * 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.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldChunksEffect: <S, R, E, In>(s: S, contFn: Predicate<S>, f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<R, E, S>) => Sink<R, E, In, In, S>;
/**
 * A sink that effectfully folds its inputs with the provided function,
 * termination predicate and initial state.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldEffect: <S, R, E, In>(s: S, contFn: Predicate<S>, f: (s: S, input: In) => Effect.Effect<R, E, S>) => Sink<R, E, In, In, S>;
/**
 * A sink that folds its inputs with the provided function and initial state.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldLeft: <S, In>(s: S, f: (s: S, input: In) => S) => Sink<never, never, In, never, S>;
/**
 * A sink that folds its input chunks with the provided function and initial
 * state. `f` must preserve chunking-invariance.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldLeftChunks: <S, In>(s: S, f: (s: S, chunk: Chunk.Chunk<In>) => S) => Sink<never, never, In, never, S>;
/**
 * A sink that effectfully folds its input chunks with the provided function
 * and initial state. `f` must preserve chunking-invariance.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldLeftChunksEffect: <S, R, E, In>(s: S, f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<R, E, S>) => Sink<R, E, In, never, S>;
/**
 * A sink that effectfully folds its inputs with the provided function and
 * initial state.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldLeftEffect: <S, R, E, In>(s: S, f: (s: S, input: In) => Effect.Effect<R, E, S>) => Sink<R, E, In, In, S>;
/**
 * Creates a sink that folds elements of type `In` into a structure of type
 * `S` until `max` elements have been folded.
 *
 * Like `Sink.foldWeighted`, but with a constant cost function of `1`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldUntil: <In, S>(s: S, max: number, f: (z: S, input: In) => S) => Sink<never, never, In, In, S>;
/**
 * Creates a sink that effectfully folds elements of type `In` into a
 * structure of type `S` until `max` elements have been folded.
 *
 * Like `Sink.foldWeightedEffect` but with a constant cost function of `1`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldUntilEffect: <S, R, E, In>(s: S, max: number, f: (s: S, input: In) => Effect.Effect<R, E, S>) => Sink<R, E, In, In, S>;
/**
 * Creates a sink that folds elements of type `In` into a structure of type
 * `S`, until `max` worth of elements (determined by the `costFn`) have been
 * folded.
 *
 * @note
 *   Elements that have an individual cost larger than `max` will force the
 *   sink to cross the `max` cost. See `Sink.foldWeightedDecompose` for a
 *   variant that can handle these cases.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldWeighted: <S, In>(options: {
    readonly initial: S;
    readonly maxCost: number;
    readonly cost: (s: S, input: In) => number;
    readonly body: (s: S, input: In) => S;
}) => Sink<never, never, In, In, S>;
/**
 * Creates a sink that folds elements of type `In` into a structure of type
 * `S`, until `max` worth of elements (determined by the `costFn`) have been
 * folded.
 *
 * The `decompose` function will be used for decomposing elements that cause
 * an `S` aggregate to cross `max` into smaller elements. For example:
 *
 * ```ts
 * pipe(
 *   Stream.make(1, 5, 1),
 *   Stream.transduce(
 *     Sink.foldWeightedDecompose(
 *       Chunk.empty<number>(),
 *       4,
 *       (n: number) => n,
 *       (n: number) => Chunk.make(n - 1, 1),
 *       (acc, el) => pipe(acc, Chunk.append(el))
 *     )
 *   ),
 *   Stream.runCollect
 * )
 * ```
 *
 * The stream would emit the elements `Chunk(1), Chunk(4), Chunk(1, 1)`.
 *
 * Be vigilant with this function, it has to generate "simpler" values or the
 * fold may never end. A value is considered indivisible if `decompose` yields
 * the empty chunk or a single-valued chunk. In these cases, there is no other
 * choice than to yield a value that will cross the threshold.
 *
 * `Sink.foldWeightedDecomposeEffect` allows the decompose function to return an
 * effect value, and consequently it allows the sink to fail.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldWeightedDecompose: <S, In>(options: {
    readonly initial: S;
    readonly maxCost: number;
    readonly cost: (s: S, input: In) => number;
    readonly decompose: (input: In) => Chunk.Chunk<In>;
    readonly body: (s: S, input: In) => S;
}) => Sink<never, never, In, In, S>;
/**
 * Creates a sink that effectfully folds elements of type `In` into a
 * structure of type `S`, until `max` worth of elements (determined by the
 * `costFn`) have been folded.
 *
 * The `decompose` function will be used for decomposing elements that cause
 * an `S` aggregate to cross `max` into smaller elements. Be vigilant with
 * this function, it has to generate "simpler" values or the fold may never
 * end. A value is considered indivisible if `decompose` yields the empty
 * chunk or a single-valued chunk. In these cases, there is no other choice
 * than to yield a value that will cross the threshold.
 *
 * See `Sink.foldWeightedDecompose` for an example.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldWeightedDecomposeEffect: <S, In, R, E, R2, E2, R3, E3>(options: {
    readonly initial: S;
    readonly maxCost: number;
    readonly cost: (s: S, input: In) => Effect.Effect<R, E, number>;
    readonly decompose: (input: In) => Effect.Effect<R2, E2, Chunk.Chunk<In>>;
    readonly body: (s: S, input: In) => Effect.Effect<R3, E3, S>;
}) => Sink<R | R2 | R3, E | E2 | E3, In, In, S>;
/**
 * Creates a sink that effectfully folds elements of type `In` into a
 * structure of type `S`, until `max` worth of elements (determined by the
 * `costFn`) have been folded.
 *
 * @note
 *   Elements that have an individual cost larger than `max` will force the
 *   sink to cross the `max` cost. See `Sink.foldWeightedDecomposeEffect` for
 *   a variant that can handle these cases.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const foldWeightedEffect: <S, In, R, E, R2, E2>(options: {
    readonly initial: S;
    readonly maxCost: number;
    readonly cost: (s: S, input: In) => Effect.Effect<R, E, number>;
    readonly body: (s: S, input: In) => Effect.Effect<R2, E2, S>;
}) => Sink<R | R2, E | E2, In, In, S>;
/**
 * A sink that executes the provided effectful function for every element fed
 * to it.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const forEach: <In, R, E, _>(f: (input: In) => Effect.Effect<R, E, _>) => Sink<R, E, In, never, void>;
/**
 * A sink that executes the provided effectful function for every chunk fed to
 * it.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const forEachChunk: <In, R, E, _>(f: (input: Chunk.Chunk<In>) => Effect.Effect<R, E, _>) => Sink<R, E, In, never, void>;
/**
 * A sink that executes the provided effectful function for every chunk fed to
 * it until `f` evaluates to `false`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const forEachChunkWhile: <In, R, E>(f: (input: Chunk.Chunk<In>) => Effect.Effect<R, E, boolean>) => Sink<R, E, In, In, void>;
/**
 * A sink that executes the provided effectful function for every element fed
 * to it until `f` evaluates to `false`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const forEachWhile: <In, R, E>(f: (input: In) => Effect.Effect<R, E, boolean>) => Sink<R, E, In, In, void>;
/**
 * Runs this sink until it yields a result, then uses that result to create
 * another sink from the provided function which will continue to run until it
 * yields a result.
 *
 * This function essentially runs sinks in sequence.
 *
 * @since 1.0.0
 * @category sequencing
 */
export declare const flatMap: {
    <R1, E1, In, In1 extends In, L, L1, Z, Z1>(f: (z: Z) => Sink<R1, E1, In1, L1, Z1>): <R, E>(self: Sink<R, E, In, L, Z>) => Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>;
    <R, E, R1, E1, In, In1 extends In, L, L1, Z, Z1>(self: Sink<R, E, In, L, Z>, f: (z: Z) => Sink<R1, E1, In1, L1, Z1>): Sink<R | R1, E | E1, In & In1, L | L1, Z1>;
};
/**
 * Creates a sink from a `Channel`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromChannel: <R, E, In, L, Z>(channel: Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z>) => Sink<R, E, In, L, Z>;
/**
 * Creates a `Channel` from a Sink.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const toChannel: <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z>;
/**
 * Creates a single-value sink produced from an effect.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromEffect: <R, E, Z>(effect: Effect.Effect<R, E, Z>) => Sink<R, E, unknown, never, Z>;
/**
 * Create a sink which publishes each element to the specified hub.
 *
 * @param shutdown If `true`, the hub will be shutdown after the sink is evaluated (defaults to `false`)
 * @since 1.0.0
 * @category constructors
 */
export declare const fromHub: <In>(hub: Hub.Hub<In>, options?: {
    readonly shutdown?: boolean;
}) => Sink<never, never, In, never, void>;
/**
 * Creates a sink from a chunk processing function.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromPush: <R, E, In, L, Z>(push: Effect.Effect<R, never, (_: Option.Option<Chunk.Chunk<In>>) => Effect.Effect<R, readonly [Either.Either<E, Z>, Chunk.Chunk<L>], void>>) => Sink<Exclude<R, Scope.Scope>, E, In, L, Z>;
/**
 * Create a sink which enqueues each element into the specified queue.
 *
 * @param shutdown If `true`, the queue will be shutdown after the sink is evaluated (defaults to `false`)
 * @since 1.0.0
 * @category constructors
 */
export declare const fromQueue: <In>(queue: Queue.Enqueue<In>, options?: {
    readonly shutdown?: boolean;
}) => Sink<never, never, In, never, void>;
/**
 * Creates a sink containing the first value.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const head: <In>() => Sink<never, never, In, In, Option.Option<In>>;
/**
 * Drains the remaining elements from the stream after the sink finishes
 *
 * @since 1.0.0
 * @category utils
 */
export declare const ignoreLeftover: <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, never, Z>;
/**
 * Creates a sink containing the last value.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const last: <In>() => Sink<never, never, In, In, Option.Option<In>>;
/**
 * Creates a sink that does not consume any input but provides the given chunk
 * as its leftovers
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const leftover: <L>(chunk: Chunk.Chunk<L>) => Sink<never, never, unknown, L, void>;
/**
 * Transforms this sink's result.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const map: {
    <Z, Z2>(f: (z: Z) => Z2): <R, E, In, L>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, L, Z2>;
    <R, E, In, L, Z, Z2>(self: Sink<R, E, In, L, Z>, f: (z: Z) => Z2): Sink<R, E, In, L, Z2>;
};
/**
 * Effectfully transforms this sink's result.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapEffect: {
    <Z, R2, E2, Z2>(f: (z: Z) => Effect.Effect<R2, E2, Z2>): <R, E, In, L>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In, L, Z2>;
    <R, E, In, L, Z, R2, E2, Z2>(self: Sink<R, E, In, L, Z>, f: (z: Z) => Effect.Effect<R2, E2, Z2>): Sink<R | R2, E | E2, In, L, Z2>;
};
/**
 * Transforms the errors emitted by this sink using `f`.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapError: {
    <E, E2>(f: (error: E) => E2): <R, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E2, In, L, Z>;
    <R, In, L, Z, E, E2>(self: Sink<R, E, In, L, Z>, f: (error: E) => E2): Sink<R, E2, In, L, Z>;
};
/**
 * Transforms the leftovers emitted by this sink using `f`.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapLeftover: {
    <L, L2>(f: (leftover: L) => L2): <R, E, In, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, L2, Z>;
    <R, E, In, Z, L, L2>(self: Sink<R, E, In, L, Z>, f: (leftover: L) => L2): Sink<R, E, In, L2, Z>;
};
/**
 * Creates a sink which transforms it's inputs into a string.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const mkString: Sink<never, never, unknown, never, string>;
/**
 * Creates a sink which never terminates.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const never: Sink<never, never, unknown, never, never>;
/**
 * Switch to another sink in case of failure
 *
 * @since 1.0.0
 * @category error handling
 */
export declare const orElse: {
    <R2, E2, In2, L2, Z2>(that: LazyArg<Sink<R2, E2, In2, L2, Z2>>): <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In & In2, L2 | L, Z2 | Z>;
    <R, E, In, L, Z, R2, E2, In2, L2, Z2>(self: Sink<R, E, In, L, Z>, that: LazyArg<Sink<R2, E2, In2, L2, Z2>>): Sink<R | R2, E | E2, In & In2, L | L2, Z | Z2>;
};
/**
 * Provides the sink with its required context, which eliminates its
 * dependency on `R`.
 *
 * @since 1.0.0
 * @category context
 */
export declare const provideContext: {
    <R>(context: Context.Context<R>): <E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<never, E, In, L, Z>;
    <E, In, L, Z, R>(self: Sink<R, E, In, L, Z>, context: Context.Context<R>): Sink<never, E, In, L, Z>;
};
/**
 * Runs both sinks in parallel on the input, , returning the result or the
 * error from the one that finishes first.
 *
 * @since 1.0.0
 * @category utils
 */
export declare const race: {
    <R1, E1, In1, L1, Z1>(that: Sink<R1, E1, In1, L1, Z1>): <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R1 | R, E1 | E, In & In1, L1 | L, Z1 | Z>;
    <R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Sink<R1, E1, In1, L1, Z1>): Sink<R | R1, E | E1, In & In1, L | L1, Z | Z1>;
};
/**
 * Runs both sinks in parallel on the input, returning the result or the error
 * from the one that finishes first.
 *
 * @since 1.0.0
 * @category utils
 */
export declare const raceBoth: {
    <R1, E1, In1, L1, Z1>(that: Sink<R1, E1, In1, L1, Z1>, options?: {
        readonly capacity?: number;
    }): <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R1 | R, E1 | E, In & In1, L1 | L, Either.Either<Z, Z1>>;
    <R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Sink<R1, E1, In1, L1, Z1>, options?: {
        readonly capacity?: number;
    }): Sink<R | R1, E | E1, In & In1, L | L1, Either.Either<Z, Z1>>;
};
/**
 * Runs both sinks in parallel on the input, using the specified merge
 * function as soon as one result or the other has been computed.
 *
 * @since 1.0.0
 * @category utils
 */
export declare const raceWith: {
    <R2, E2, In2, L2, Z2, E, Z, Z3, Z4>(options: {
        readonly other: Sink<R2, E2, In2, L2, Z2>;
        readonly onSelfDone: (exit: Exit.Exit<E, Z>) => MergeDecision.MergeDecision<R2, E2, Z2, E2 | E, Z3>;
        readonly onOtherDone: (exit: Exit.Exit<E2, Z2>) => MergeDecision.MergeDecision<R2, E, Z, E2 | E, Z4>;
        readonly capacity?: number;
    }): <R, In, L>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In & In2, L2 | L, Z3 | Z4>;
    <R, In, L, R2, E2, In2, L2, Z2, E, Z, Z3, Z4>(self: Sink<R, E, In, L, Z>, options: {
        readonly other: Sink<R2, E2, In2, L2, Z2>;
        readonly onSelfDone: (exit: Exit.Exit<E, Z>) => MergeDecision.MergeDecision<R2, E2, Z2, E2 | E, Z3>;
        readonly onOtherDone: (exit: Exit.Exit<E2, Z2>) => MergeDecision.MergeDecision<R2, E, Z, E2 | E, Z4>;
        readonly capacity?: number;
    }): Sink<R | R2, E2 | E, In & In2, L | L2, Z3 | Z4>;
};
/**
 * @since 1.0.0
 * @category error handling
 */
export declare const refineOrDie: {
    <E, E2>(pf: (error: E) => Option.Option<E2>): <R, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E2, In, L, Z>;
    <R, In, L, Z, E, E2>(self: Sink<R, E, In, L, Z>, pf: (error: E) => Option.Option<E2>): Sink<R, E2, In, L, Z>;
};
/**
 * @since 1.0.0
 * @category error handling
 */
export declare const refineOrDieWith: <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown) => <R, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E2, In, L, Z>;
/**
 * A sink that returns whether an element satisfies the specified predicate.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const some: <In>(predicate: Predicate<In>) => Sink<never, never, In, In, boolean>;
/**
 * Splits the sink on the specified predicate, returning a new sink that
 * consumes elements until an element after the first satisfies the specified
 * predicate.
 *
 * @since 1.0.0
 * @category utils
 */
export declare const splitWhere: {
    <In>(f: Predicate<In>): <R, E, L extends In, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, In, Z>;
    <R, E, L extends In, Z, In>(self: Sink<R, E, In, L, Z>, f: Predicate<In>): Sink<R, E, In, In, Z>;
};
/**
 * A sink that immediately ends with the specified value.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const succeed: <Z>(z: Z) => Sink<never, never, unknown, never, Z>;
/**
 * A sink that sums incoming numeric values.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const sum: Sink<never, never, number, never, number>;
/**
 * Summarize a sink by running an effect when the sink starts and again when
 * it completes.
 *
 * @since 1.0.0
 * @category utils
 */
export declare const summarized: {
    <R2, E2, Z2, Z3>(summary: Effect.Effect<R2, E2, Z2>, f: (start: Z2, end: Z2) => Z3): <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In, L, readonly [Z, Z3]>;
    <R, E, In, L, Z, R2, E2, Z2, Z3>(self: Sink<R, E, In, L, Z>, summary: Effect.Effect<R2, E2, Z2>, f: (start: Z2, end: Z2) => Z3): Sink<R | R2, E | E2, In, L, readonly [Z, Z3]>;
};
/**
 * Returns a lazily constructed sink that may require effects for its
 * creation.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const suspend: <R, E, In, L, Z>(evaluate: LazyArg<Sink<R, E, In, L, Z>>) => Sink<R, E, In, L, Z>;
/**
 * A sink that immediately ends with the specified lazy value.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const sync: <Z>(evaluate: LazyArg<Z>) => Sink<never, never, unknown, never, Z>;
/**
 * A sink that takes the specified number of values.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const take: <In>(n: number) => Sink<never, never, In, In, Chunk.Chunk<In>>;
/**
 * @since 1.0.0
 * @category constructors
 */
export declare const timed: Sink<never, never, unknown, never, Duration.Duration>;
/**
 * Creates a sink produced from an effect.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const unwrap: <R, E, R2, E2, In, L, Z>(effect: Effect.Effect<R, E, Sink<R2, E2, In, L, Z>>) => Sink<R | R2, E | E2, In, L, Z>;
/**
 * Creates a sink produced from a scoped effect.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const unwrapScoped: <R, E, In, L, Z>(effect: Effect.Effect<R, E, Sink<R, E, In, L, Z>>) => Sink<Exclude<R, Scope.Scope>, E, In, L, Z>;
/**
 * Returns the sink that executes this one and times its execution.
 *
 * @since 1.0.0
 * @category utils
 */
export declare const withDuration: <R, E, In, L, Z>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In, L, readonly [Z, Duration.Duration]>;
/**
 * Feeds inputs to this sink until it yields a result, then switches over to
 * the provided sink until it yields a result, finally combining the two
 * results into a tuple.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zip: {
    <R2, E2, In, In2 extends In, L, L2, Z, Z2>(that: Sink<R2, E2, In2, L2, Z2>, options?: {
        readonly concurrent?: boolean;
    }): <R, E>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In & In2, L | L2, readonly [Z, Z2]>;
    <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2>(self: Sink<R, E, In, L, Z>, that: Sink<R2, E2, In2, L2, Z2>, options?: {
        readonly concurrent?: boolean;
    }): Sink<R | R2, E | E2, In & In2, L | L2, readonly [Z, Z2]>;
};
/**
 * Like `Sink.zip` but keeps only the result from this sink.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipLeft: {
    <R2, E2, In, In2 extends In, L, L2, Z, Z2>(that: Sink<R2, E2, In2, L2, Z2>, options?: {
        readonly concurrent?: boolean;
    }): <R, E>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In & In2, L | L2, Z>;
    <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2>(self: Sink<R, E, In, L, Z>, that: Sink<R2, E2, In2, L2, Z2>, options?: {
        readonly concurrent?: boolean;
    }): Sink<R | R2, E | E2, In & In2, L | L2, Z>;
};
/**
 * Like `Sink.zip` but keeps only the result from `that` sink.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipRight: {
    <R2, E2, In, In2 extends In, L, L2, Z, Z2>(that: Sink<R2, E2, In2, L2, Z2>, options?: {
        readonly concurrent?: boolean;
    }): <R, E>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In & In2, L | L2, Z2>;
    <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2>(self: Sink<R, E, In, L, Z>, that: Sink<R2, E2, In2, L2, Z2>, options?: {
        readonly concurrent?: boolean;
    }): Sink<R | R2, E | E2, In & In2, L | L2, Z2>;
};
/**
 * Feeds inputs to this sink until it yields a result, then switches over to
 * the provided sink until it yields a result, finally combining the two
 * results with `f`.
 *
 * @since 1.0.0
 * @category zipping
 */
export declare const zipWith: {
    <R2, E2, In, In2 extends In, L, L2, Z, Z2, Z3>(that: Sink<R2, E2, In2, L2, Z2>, f: (z: Z, z1: Z2) => Z3, options?: {
        readonly concurrent?: boolean;
    }): <R, E>(self: Sink<R, E, In, L, Z>) => Sink<R2 | R, E2 | E, In & In2, L | L2, Z3>;
    <R, E, R2, E2, In, In2 extends In, L, L2, Z, Z2, Z3>(self: Sink<R, E, In, L, Z>, that: Sink<R2, E2, In2, L2, Z2>, f: (z: Z, z1: Z2) => Z3, options?: {
        readonly concurrent?: boolean;
    }): Sink<R | R2, E | E2, In & In2, L | L2, Z3>;
};
//# sourceMappingURL=Sink.d.ts.map