import type { Reader } from "@endo/stream";
import type { Infer } from "@metamask/superstruct";
import type { BaseReader, BaseWriter, ValidateInput } from "./BaseStream.cjs";
export declare const DuplexStreamSentinel: {
    readonly Syn: "@@Syn";
    readonly Ack: "@@Ack";
};
declare const SynStruct: import("@metamask/superstruct").Struct<{
    "@@Syn": true;
}, {
    "@@Syn": import("@metamask/superstruct").Struct<true, true>;
}>;
type DuplexStreamSyn = Infer<typeof SynStruct>;
export declare const isSyn: (value: unknown) => value is DuplexStreamSyn;
export declare const makeSyn: () => DuplexStreamSyn;
declare const AckStruct: import("@metamask/superstruct").Struct<{
    "@@Ack": true;
}, {
    "@@Ack": import("@metamask/superstruct").Struct<true, true>;
}>;
type DuplexStreamAck = Infer<typeof AckStruct>;
export declare const isAck: (value: unknown) => value is DuplexStreamAck;
export declare const makeAck: () => DuplexStreamAck;
type DuplexStreamSignal = DuplexStreamSyn | DuplexStreamAck;
export declare const isDuplexStreamSignal: (value: unknown) => value is DuplexStreamSignal;
/**
 * Make a validator for input to a duplex stream. Constructor helper for concrete
 * duplex stream implementations.
 *
 * Validators passed in by consumers must be augmented such that errors aren't
 * thrown for {@link DuplexStreamSignal} values.
 *
 * @param validateInput - The validator for the stream's input type.
 * @returns A validator for the stream's input type, or `undefined` if no
 * validation is desired.
 */
export declare const makeDuplexStreamInputValidator: <Read>(validateInput?: ValidateInput<Read>) => ((value: unknown) => value is Read) | undefined;
/**
 * The base of a duplex stream. Essentially a {@link BaseReader} with a `write()` method.
 * Backed up by separate {@link BaseReader} and {@link BaseWriter} instances under the hood.
 */
export declare abstract class BaseDuplexStream<Read, ReadStream extends BaseReader<Read>, Write = Read, WriteStream extends BaseWriter<Write> = BaseWriter<Write>> implements Reader<Read> {
    #private;
    /**
     * Reads the next value from the stream.
     *
     * @returns The next value from the stream.
     */
    next: () => Promise<IteratorResult<Read, undefined>>;
    /**
     * Writes a value to the stream.
     *
     * @param value - The next value to write to the stream.
     * @returns The result of writing the value.
     */
    write: (value: Write) => Promise<IteratorResult<undefined, undefined>>;
    /**
     * Constructs a new {@link BaseDuplexStream}.
     *
     * @param reader - The underlying reader for the duplex stream.
     * @param writer - The underlying writer for the duplex stream.
     */
    constructor(reader: ReadStream, writer: WriteStream);
    /**
     * Synchronizes the duplex stream with its remote counterpart. Must be awaited
     * before values can be read from or written to the stream. Idempotent.
     *
     * @returns A promise that resolves when the stream is synchronized.
     */
    synchronize(): Promise<void>;
    /**
     * Returns the async iterator for this stream.
     *
     * @returns This stream as an async iterator.
     */
    [Symbol.asyncIterator](): typeof this;
    /**
     * Drains the stream by passing each value to a handler function.
     *
     * @param handler - The function that will receive each value from the stream.
     */
    drain(handler: (value: Read) => void | Promise<void>): Promise<void>;
    /**
     * Pipes the stream to another duplex stream.
     *
     * @param sink - The duplex stream to pipe to.
     */
    pipe<Read2>(sink: DuplexStream<Read2, Read>): Promise<void>;
    /**
     * Closes the stream. Idempotent.
     *
     * @returns The final result for this stream.
     */
    return(): Promise<IteratorResult<Read, undefined>>;
    /**
     * Closes the stream with an error. Idempotent.
     *
     * @param error - The error to close the stream with.
     * @returns The final result for this stream.
     */
    throw(error: Error): Promise<IteratorResult<Read, undefined>>;
    /**
     * Closes the stream. Syntactic sugar for `throw(error)` or `return()`. Idempotent.
     *
     * @param error - The error to close the stream with.
     * @returns The final result for this stream.
     */
    end(error?: Error): Promise<IteratorResult<Read, undefined>>;
}
/**
 * A duplex stream. Essentially a {@link Reader} with a `write()` method.
 */
export type DuplexStream<Read, Write = Read> = Pick<BaseDuplexStream<Read, BaseReader<Read>, Write, BaseWriter<Write>>, 'next' | 'write' | 'drain' | 'pipe' | 'return' | 'throw' | 'end'> & {
    [Symbol.asyncIterator]: () => DuplexStream<Read, Write>;
};
export {};
//# sourceMappingURL=BaseDuplexStream.d.cts.map