import { Effect } from "@effect/core/io/Effect/definition";
import { Cause } from "@effect/core/io/Cause/definition";
import { Deferred } from "@effect/core/io/Deferred/definition";
import { ImmutableQueue } from "@tsplus/stdlib/collections/ImmutableQueue/definition";
import { Either } from "@tsplus/stdlib/data/Either/definition";
import { Ref } from "@effect/core/io/Ref/definition";
import { Exit } from "@effect/core/io/Exit/definition";
/**
 * Producer-side view of `SingleProducerAsyncInput` for variance purposes.
 */
export interface AsyncInputProducer<Err, Elem, Done> {
    readonly emit: (el: Elem) => Effect<never, never, unknown>;
    readonly done: (a: Done) => Effect<never, never, unknown>;
    readonly error: (cause: Cause<Err>) => Effect<never, never, unknown>;
    readonly awaitRead: Effect<never, never, unknown>;
}
/**
 * Consumer-side view of `SingleProducerAsyncInput` for variance purposes.
 */
export interface AsyncInputConsumer<Err, Elem, Done> {
    readonly takeWith: <A>(onError: (cause: Cause<Err>) => A, onElement: (element: Elem) => A, onDone: (done: Done) => A) => Effect<never, never, A>;
}
export type State<Err, Elem, Done> = StateEmpty | StateEmit<Err, Elem, Done> | StateError<Err> | StateDone<Done>;
export declare const DoneTypeId: unique symbol;
export type DoneTypeId = typeof DoneTypeId;
export declare class StateDone<Elem> {
    readonly a: Elem;
    readonly _typeId: DoneTypeId;
    constructor(a: Elem);
}
export declare const ErrorTypeId: unique symbol;
export type ErrorTypeId = typeof ErrorTypeId;
export declare class StateError<Err> {
    readonly cause: Cause<Err>;
    readonly _typeId: ErrorTypeId;
    constructor(cause: Cause<Err>);
}
export declare const EmptyTypeId: unique symbol;
export type EmptyTypeId = typeof EmptyTypeId;
export declare class StateEmpty {
    readonly notifyProducer: Deferred<never, void>;
    readonly _typeId: EmptyTypeId;
    constructor(notifyProducer: Deferred<never, void>);
}
export declare const EmitTypeId: unique symbol;
export type EmitTypeId = typeof EmitTypeId;
export declare class StateEmit<Err, Elem, Done> {
    readonly notifyConsumers: ImmutableQueue<Deferred<Err, Either<Done, Elem>>>;
    readonly _typeId: EmitTypeId;
    constructor(notifyConsumers: ImmutableQueue<Deferred<Err, Either<Done, Elem>>>);
}
/**
 * An MVar-like abstraction for sending data to channels asynchronously.
 * Designed for one producer and multiple consumers.
 *
 * Features the following semantics:
 *   - Buffer of size 1.
 *   - When emitting, the producer waits for a consumer to pick up the value to
 *     prevent "reading ahead" too much.
 *   - Once an emitted element is read by a consumer, it is cleared from the
 *     buffer, so that at most one consumer sees every emitted element.
 *   - When sending a done or error signal, the producer does not wait for a
 *     consumer to pick up the signal. The signal stays in the buffer after
 *     being read by a consumer, so it can be propagated to multiple consumers.
 *   - Trying to publish another emit/error/done after an error/done have
 *     already been published results in an interruption.
 *
 * @tsplus type effect/core/stream/Channel/SingleProducerAsyncInput
 * @tsplus companion effect/core/stream/Channel/SingleProducerAsyncInput.Ops
 */
export declare class SingleProducerAsyncInput<Err, Elem, Done> implements AsyncInputProducer<Err, Elem, Done>, AsyncInputConsumer<Err, Elem, Done> {
    readonly ref: Ref<State<Err, Elem, Done>>;
    constructor(ref: Ref<State<Err, Elem, Done>>);
    get take(): Effect<never, never, Exit<Either<Err, Done>, Elem>>;
    get close(): Effect<never, never, unknown>;
    get awaitRead(): Effect<never, never, unknown>;
    emit(el: Elem): Effect<never, never, unknown>;
    done(a: Done): Effect<never, never, unknown>;
    error(cause: Cause<Err>): Effect<never, never, unknown>;
    takeWith<X>(onError: (cause: Cause<Err>) => X, onElement: (element: Elem) => X, onDone: (done: Done) => X): Effect<never, never, X>;
}
/**
 * Creates a `SingleProducerAsyncInput`.
 * @tsplus static effect/core/stream/Channel/SingleProducerAsyncInput.Ops make
 * @tsplus location "@effect/core/stream/Channel/SingleProducerAsyncInput"
 */
export declare function make<Err, Elem, Done>(): Effect<never, never, SingleProducerAsyncInput<Err, Elem, Done>>;
//# sourceMappingURL=SingleProducerAsyncInput.d.ts.map